static void on_privmsg( irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) { char nick[256]; char host[256]; char *msg; /* printf("<%s> %s \n", origin, params[1]); */ irc_target_get_nick(origin, nick, 256); irc_target_get_host(origin, host, 256); msg = irc_color_strip_from_mirc(params[1]); if ( (!is_voice(nick) && !is_op(nick)) || ((is_voice(nick) || is_op(nick)) && !botcmd_parse(session, msg, nick, host, 1))) { send_to_log(nick, msg); } free(msg); }
void NativeMovRegMem::verify() { NativeInstruction::verify(); // make sure code pattern is actually a "ld" or "st" of some sort. int i0 = long_at(0); int op3 = inv_op3(i0); assert((int)add_offset == NativeMovConstReg::add_offset, "sethi size ok"); if (!(is_op(i0, Assembler::ldst_op) && inv_immed(i0) && 0 != (op3 < op3_ldst_int_limit ? (1 << op3 ) & (op3_mask_ld | op3_mask_st) : (1 << (op3 - op3_ldst_int_limit)) & (op3_mask_ldf | op3_mask_stf)))) { int i1 = long_at(ldst_offset); Register rd = inv_rd(i0); op3 = inv_op3(i1); if (!is_op(i1, Assembler::ldst_op) && rd == inv_rs2(i1) && 0 != (op3 < op3_ldst_int_limit ? (1 << op3 ) & (op3_mask_ld | op3_mask_st) : (1 << (op3 - op3_ldst_int_limit)) & (op3_mask_ldf | op3_mask_stf))) { fatal("not a ld* or st* op"); } } }
int bot_parse_service(struct IRC *bot, char *server, char *command, char *me, char *channel, char *msg){ if(DEBUG){ printf("[server: %s] [command: %s] [me: %s] [channel: %s] %s\n",server,command,me,channel,msg); } // 353 is the NAMES list if(strcasecmp(command, "353") == 0){ parse_op(bot,msg); if(DEBUG){ print_op(bot); } } if(strcasecmp(command, "MODE") ==0){ if((msg[0]=='+') && (msg[1]=='o')){ // if it's not already in the oplist if(is_op(bot,&msg[3])==-1){ add_op(bot,&msg[3]); if(DEBUG){ print_op(bot); } } } else if((msg[0]=='-') && (msg[1]=='o')){ if(is_op(bot,&msg[3])!=-1){ rm_op(bot,&msg[3]); if(DEBUG){ print_op(bot); } } } } return 0; }
int evalRPN(vector<string>& tokens) { stack<int> val; for (string s : tokens) { if ( !is_op(s) ) { val.push( stoi(s) ); } else { int num2 = val.top(); val.pop(); int num1 = val.top(); val.pop(); if (s == "+") { val.push(num1 + num2); } else if ( s == "-") { val.push(num1 - num2); } else if ( s == "*") { val.push(num1 * num2); } else if ( s == "/") { val.push(num1 / num2); } } } return val.top(); }
void handle_folding(Instruction *head) { if (!head->next || !head->next->next) { return; } Instruction *prev = head, *current = prev->next, *next = current->next; while (current && next) { if (prev->opcode == LOADI && current->opcode == LOADI && is_op(next)) { int first = prev->field2, second = current->field2, dest = next->field1; prev->field1 = dest; if (next->opcode == ADD) { prev->field2 = first + second; } else if (next->opcode == MUL) { prev->field2 = first * second; } else { prev->field2 = first - second; } Instruction *tmp = next->next; free(current); free(next); prev->next = tmp; if (prev->next && prev->next->next) { current = prev->next; next = current->next; } else { return; } } else { prev = current; current = next; next = next->next; } } }
int find_dominant_operator(int p, int q) { int op = -1; int priority = -1; int i; int in_parenthes = 0; for(i = p; i <= q; i ++) { if(tokens[i].type == '(') { in_parenthes ++; continue; } if(tokens[i].type == ')') { in_parenthes --; continue; } if(!is_op(tokens[i].type)) continue; if(in_parenthes > 0) continue; if(priority <= get_priority(tokens[i].type)) { priority = get_priority(tokens[i].type); op = i; } } return op; }
bool ExpressionManager::op_num_ratio_check(string expression){ int op_cnt = 0; int num_cnt = 0; char exp_str[STR_BUFF_SIZE]; exp_str[0] = '\0'; //create a C string from the expression string //for use in strtok strcat(exp_str, expression.c_str()); char * token; //use strtok to tokenize the string //separating by spaces token = strtok(exp_str, " "); while(token != NULL){ //cout << "token: " << token << "\n"; if(is_int_num(string(token))){ num_cnt++; } else if(is_op( *token)){ op_cnt++; } else if(strchr(symbols, *token) != NULL){ //it's fine } else { //it's not fine return false; } //increment to the next token token = strtok(NULL, " "); } return ((num_cnt - 1) == op_cnt); }
void NativeCall::verify() { NativeInstruction::verify(); // make sure code pattern is actually a call instruction int x = long_at(0); if (!is_op(x, Assembler::call_op)) { fatal("not a call: 0x%x @ " INTPTR_FORMAT, x, p2i(instruction_address())); } }
bool NativeInstruction::is_load_store_with_small_offset(Register reg) { int x = long_at(0); if (is_op(x, Assembler::ldst_op) && inv_rs1(x) == reg && inv_immed(x)) { return true; } return false; }
//========================================================================================================== //========================================================================================================== Production::Production(vector<Symbol> _symbols, string _action_name): symbols(_symbols), action_name(_action_name) { // Find the last symbol that is an operator auto iter = find_if(symbols.rbegin(), symbols.rend(), [](Symbol sym){ return is_op(sym); }); if(iter != symbols.rend()) op = get_op(*iter); else op = nullptr; }
static expr_code(stream, node, need_lval) { auto op = node[0]; if ( op == '()' ) do_call( stream, node, need_lval ); else if ( is_op(node[0]) ) opexpr_code( stream, node, need_lval ); else return leaf_code( stream, node, need_lval ); }
/** * tests helper functions is_var() and is_op() */ static char * test_helpers() { char tmp[VAR_LENGTH+1], str[LINE_LENGTH]; char * trimmed; int ret, i; printf("Testing %s\n", __FUNCTION__); /* test is_var() from A-Z */ for (i='A'; i<='Z'; i++) { tmp[0] = i; tmp[1] = '\0'; ret = is_var(tmp); mu_assert("error, ret != 1", ret == 1); } /* test bogus inputs */ /* small letter */ tmp[0] = 'a'; ret = is_var(tmp); mu_assert("error, ret != 0", ret == 0); /* number */ tmp[0] = '1'; ret = is_var(tmp); mu_assert("error, ret != 0", ret == 0); /* test is_op */ tmp[0] = '+'; ret = is_op(tmp); mu_assert("error, ret != 1", ret == 1); tmp[0] = '-'; ret = is_op(tmp); mu_assert("error, ret != 1", ret == 1); tmp[0] = '*'; ret = is_op(tmp); mu_assert("error, ret != 1", ret == 1); tmp[0] = '/'; ret = is_op(tmp); mu_assert("error, ret != 1", ret == 1); /* test bogus inputs */ tmp[0] = '='; ret = is_op(tmp); mu_assert("error, ret != 0", ret == 0); tmp[0] = '^'; ret = is_op(tmp); mu_assert("error, ret != 0", ret == 0); tmp[0] = '$'; ret = is_op(tmp); mu_assert("error, ret != 0", ret == 0); /* test trim_space() */ strcpy(str, "\t\tFD 30 \t\t "); trimmed = trim_space(str); mu_assert("error, trimmed != \"FD 30\"", strsame(trimmed, "FD 30")); strcpy(str, " \t \tDO A FROM 1 TO 8 { \t\t "); trimmed = trim_space(str); mu_assert("error, trimmed != \"DO A FROM 1 TO 8 {\"", strsame(trimmed, "DO A FROM 1 TO 8 {")); return 0; }
void out_formula(formula *v) { if (!is_op(v->smb)) { printf("%c", v->smb); return; } printf("("); out_formula(v->left); printf("%c", v->smb); out_formula(v->right); printf(")"); }
int validate_expr(char *expression) { char x, op; int vt, opt, level; char ops[STACK_SIZE]; vt = -1; opt = -1; while ((x = *expression++) != '\0') if (is_value(x)) { vt += 1; } else if (is_op(x)) { level = op_level(x); while (opt >= 0 && level < op_level(ops[opt]) && \ ops[opt] != LEFTP) { op = ops[opt]; opt -= 1; if (op == PLUS || op == MULT) vt -= 1; if (vt < 0) return 0; } if (x == RIGHP) { while (opt >=0 && ops[opt] != LEFTP) { op = ops[opt]; if (op == PLUS || op == MULT) vt -= 1; if (vt < 0) return 0; opt -= 1; } if (opt < 0) return 0; opt -= 1; } else { ops[++opt] = x; } } else if (!is_whitespace(x)){ return 0; } while (opt >= 0) { op = ops[opt]; if (op == LEFTP) return 0; if (op == PLUS || op == MULT) vt -= 1; if (vt < 0) return 0; opt -= 1; } return vt == 0 && opt == -1; }
void handle_simplification(Instruction *head) { if (!head->next || !head->next->next) { return; } Instruction *prev = head, *current = prev->next, *next = current->next; while (current && next) { if ((prev->opcode == LOADI || current->opcode == LOADI) && is_op(next)) { int new_value = -1; if (next->opcode == ADD || next->opcode == SUB) { if (prev->field2 == 0) { new_value = current->field2; } else if (current->field2 == 0) { new_value = prev->field2; } else if (prev->field2 == current->field2) { new_value = 0; } } else { if (prev->field2 == 0 || current->field2 == 0) { new_value = 0; } else if (prev->field2 == 1) { new_value = current->field2; } else if (current->field2 == 1) { new_value = prev->field2; } } if (new_value != -1) { if (current->opcode == LOAD) { prev->opcode = LOAD; } prev->field1 = next->field1; prev->field2 = new_value; Instruction *tmp = next->next; free(current); free(next); prev->next = tmp; if (prev->next && prev->next->next) { current = prev->next; next = current->next; } else { return; } } else { prev = current; current = next; next = next->next; } } else { prev = current; current = next; next = next->next; } } }
static char *next_operator(char *str, char *end_expr, t_bistro *bistro) { int nb_par; char *save_str; nb_par = 0; save_str = str; if (IS_GRP_BEG(*str, bistro)) nb_par++; while (++str < end_expr) if (IS_GRP_BEG(*str, bistro)) nb_par++; else if (IS_GRP_END(*str, bistro)) { if (--nb_par < 0) my_puterror(E_SYNTAX); } else if (!nb_par && is_op(*str, bistro) && !is_op(*(str - 1), bistro)) return str; return NULL; }
/* Eval the args given to -test and computes the function, unused */ ast_st* eval_args(int argc, const char ** argv, int par, int * index) { ast_st *tmp1, *tmp2; kind_en op = Nothing; int i; for (i = 0; i < argc; i++) { if (!strcmp(argv[i],"(")) { tmp2 = eval_args(argc-i, argv+i+1, 1, index); if (tmp2 == NULL) return NULL; i += *index; } else if (!strcmp(argv[i], ")")) if (par) { *index = i+1; return tmp1; } else { printf("Closing parenthesis unmatched\n"); return NULL; } else if (is_op(argv[i])) { op = get_op(argv[i]); } else { int val = !strcmp(argv[i], "") ? 0 : atoi(argv[i]); tmp2 = create_int(val); if (op != Nothing) { tmp1 = create_node(op, tmp1, tmp2); op = Nothing; } else tmp1 = tmp2; } } if (!par) return tmp1; else { printf("Opening parenthesis unmatched\n"); return NULL; } }
uint32_t expr(char *e, bool *success) { if(!make_token(e)) { *success = false; return 0; } /* TODO: Insert codes to evaluate the expression. */ int i; for(i = 0; i < nr_token; i ++) { if(tokens[i].type == '*' && (i == 0 || is_op(tokens[i-1].type))) { tokens[i].type = DEREF; } } /* TEST: printf("Test func:expr(char*,bool*)\n and the nr_token is %d\n",nr_token); */ uint32_t result = eval(0, nr_token-1, success); return result; }
gf8 do_read( char * s, int * index ) { char op = 0; skip(' ',s,index); if (is_num(s[*index])) return read_number(s,index); if (is_op(s[*index])) { op = s[*index];*index = (*index) + 1; return read_op(op,s,index); } if (s[*index] == 0) return 0; if (s[*index] == '\n') { *index = *index + 1; return do_read(s,index); } printf("Unknown character %c\n",s[*index]); exit(-1); }
static expr *parse_rhs(expr *lhs, int priority) { for(;;){ int this_pri, next_pri; e_op op; expr *rhs; op = tok_cur; if(!is_op(op)) return lhs; /* eof, rparen and colon covered here */ this_pri = PRECEDENCE(op); if(this_pri > priority) return lhs; /* eat the op */ tok_next(); /* special case for ternary */ if(op == tok_question){ expr *if_t = parse(); if(tok_cur != tok_colon) CPP_DIE("colon expected for ternary-? operator"); tok_next(); rhs = parse(); lhs = expr_new_top(lhs, if_t, rhs); }else{ rhs = parse_primary(); /* now on the next op, or eof (in which case, precedence returns -1 */ next_pri = PRECEDENCE(tok_cur); if(next_pri < this_pri) { /* next is tighter, give it our rhs as its lhs */ rhs = parse_rhs(rhs, next_pri); } lhs = expr_op(op, lhs, rhs); } } }
char* get_arg(struct expr_node **expr,char *p,int line_count) { int m_type; struct expr_node *new_expr,*new_expr2,*save_expr,*save_tree; char s1[MAXSTR]; p=get_token(p); m_type=is_item(line_count); new_expr=(struct expr_node*)malloc(sizeof(struct expr_node)); if(new_expr==NULL) { sprintf(s1,"at line %d, error malloc exr_node",line_count);die(s1);} new_expr->type=m_type; strncpy(new_expr->str,my_token,MAXSTR); new_expr->left=NULL; new_expr->right=NULL; p=skip_space(p); if((*p=='\n')||(*p==',')|| (is_bool_op(p,line_count))) { *expr=new_expr; return p; } p=get_token(p); m_type=is_op(line_count); new_expr2=(struct expr_node*)malloc(sizeof(struct expr_node)); if(new_expr2==NULL) { sprintf(s1,"at line %d, error malloc exr_node",line_count);die(s1);} new_expr2->type=m_type; strncpy(new_expr2->str,my_token,MAXSTR); new_expr2->left=new_expr; new_expr2->right=NULL; *expr=new_expr2; p=skip_space(p); p=get_arg(&(new_expr2->right),p,line_count); if((new_expr2->type<new_expr2->right->type)&&(new_expr2->type<3)&&(new_expr2->right->type<3)) { save_expr=new_expr2->right; save_tree=new_expr2->right->left; new_expr2->right->left=new_expr2; save_expr->left->right=save_tree; *expr=save_expr; } return p; }
struct POLISH *read_POLISH() { char word[VARMAXLEN]; struct POLISH *rv = NULL; ///////////// long old_offset = ftell(stdin); if(scanf("%s", word) == EOF) syntax_error("unexpected end", "POLISH"); if(strcmp(word, ";") == 0) { return rv; } else if(strlen(word) == 1 && is_op(word[0])) { /*printf("here is op\n");*/ rv = (struct POLISH*)malloc(sizeof(struct POLISH)); rv->type = PO_OP; rv->po.op = word[0]; rv->next = read_POLISH(); } else { /*printf("here is varnum\n");*/ fseek(stdin, old_offset, SEEK_SET); rv = (struct POLISH*)malloc(sizeof(struct POLISH)); rv->type = PO_VN; rv->po.vn = read_VARNUM(); rv->next = read_POLISH(); } return rv; }
t_inst *create_inst(char *s, int where, t_inst *head, int c) { t_inst *maillon; maillon = (t_inst *)malloc(sizeof(t_inst)); maillon->is_label = 0; maillon->where = -1; maillon->s = ft_strdup(erase_char(s)); maillon->opcode = 0; if (!head) { maillon->value = find_opcode(s); maillon->size = 1; if (maillon->value == -1) bad_instruction(c); maillon->opcode = is_op(maillon->value); } else find_value(s, maillon, head, c); maillon->where = where; maillon->next = NULL; return (maillon); }
void tokenizer::name() { assert(m_scope == 0); const char* p = mp_char; char c = *mp_char; if (c == '[') ++m_scope; else if (c == ']') { m_tokens.push_back(new lexer_name_token(p, 1)); next(); return; } size_t len = 1; for (next(); has_char(); next(), ++len) { c = *mp_char; if (c == '[') { ++m_scope; } else if (c == ']') { if (!m_scope) break; --m_scope; } else if (is_op(c)) break; } m_tokens.push_back(new lexer_name_token(p, len)); }
string ExpressionManager::infixToPostfix(string infixExpression){ stack<char> symbols; string out_str = ""; //do tests for the validity of the infix expression if(!isBalanced(infixExpression)){ return invalid; } if(!op_num_ratio_check(infixExpression)){ return invalid; } char exp_str[STR_BUFF_SIZE]; exp_str[0] = '\0'; //create a C string from the expression string //for use in strtok strcat(exp_str, infixExpression.c_str()); char * token; //use strtok to tokenize the string //separating by spaces token = strtok(exp_str, " "); while( 1 ){ if(token == NULL){ while(!symbols.empty()){ out_str += symbols.top(); out_str += " "; symbols.pop(); } break; } //cout << "token: " << token << "\n"; if(is_int_num(string(token))){ out_str += string(token); out_str += " "; } else if(is_paren( *token ) == OPEN_PAREN){ symbols.push( *token ); } else if(is_paren( *token ) == CLOSE_PAREN){ char top_char = symbols.top(); symbols.pop(); while(get_precedence(top_char) > OPEN_PAREN){ //symbols.pop(); out_str += top_char; out_str += " "; top_char = symbols.top(); symbols.pop(); } } else if(is_op( *token )){ if(symbols.empty()){ symbols.push( *token ); } else { char top_char = symbols.top(); int top_prec = get_precedence(top_char); int token_prec = get_precedence( *token ); while( top_prec >= token_prec ){ //go through any tokens with greater than or equal precedence symbols.pop(); out_str += top_char; out_str += " "; if(symbols.empty()){ break; } top_char = symbols.top(); top_prec = get_precedence(top_char); } symbols.push( *token ); } } //increment to the next token token = strtok(NULL, " "); } //to remove the last part of the string (the trailing space) //if using C++11 you can do out_str.pop_back(); out_str.erase(out_str.end() - 1); return out_str; }
void tokenizer::run() { if (!m_size) // Nothing to do. return; init(); while (has_char()) { if (is_digit(*mp_char)) { numeral(); continue; } if (!is_op(*mp_char)) { name(); continue; } if (is_arg_sep(*mp_char)) { op(op_sep); continue; } switch (*mp_char) { case ' ': space(); break; case '+': op(op_plus); break; case '-': op(op_minus); break; case '/': op(op_divide); break; case '*': op(op_multiply); break; case '=': op(op_equal); break; case '<': op(op_less); break; case '>': op(op_greater); break; case '(': op(op_open); break; case ')': op(op_close); break; case '"': string(); break; } } }
char *infix2postfix(const char *expr, const size_t esize, const hefesto_int_t main_call) { const char *efinis = expr + esize, *e; char *t, *term, *tt; hefesto_common_stack_ctx *sp = NULL, *dp = NULL; hefesto_common_list_ctx *lp = NULL, *l; hefesto_int_t p, tp; size_t sz; hefesto_int_t bracket = 0; char *indexing; char *iexpr; char *args; size_t offset, count; hefesto_int_t state = 0; term = (char *) hefesto_mloc(HEFESTO_MAX_BUFFER_SIZE); memset(term, 0, HEFESTO_MAX_BUFFER_SIZE); t = term; *t = 0; for (e = expr; e != efinis; e++) { if (*e == 0) break; if (*e == '\n' || *e == '\r' || *e == '\t' || *e == ' ') continue; if (*e != 0 && *e != ' ' && *e != '\n' && *e != '\r' && *e != '\t' && *e != '(' && *e != ')' && !is_op(*e) && *e != '[' && !is_hefesto_string_tok(*e)) { *t = *e; t++; *t = 0; continue; } else if (is_hefesto_string_tok(*e)) { offset = 0; iexpr = get_next_string(e, &offset); e += offset; for (indexing = iexpr; *indexing != 0; indexing++, t++) *t = *indexing; free(iexpr); *t = 0; } else if (*e == '(' && !is_hefesto_numeric_constant(term) && !is_hefesto_string(term) && *term && *term != '(' && !is_op(*term)) { bracket++; offset = 0; args = get_next_call_args(e, &offset); if (*args) { iexpr = infix2postfix_function_args(args, strlen(args)); tt = t; for (indexing = iexpr; *indexing != 0; indexing++, t++) *t = *indexing; *t = 0; free(iexpr); count = 0; for (t = tt; *t != 0; t++) { if (*t == '(') { count++; } else if (*t == ')') { count--; } else if (*t == '"') { t++; while (*t != '"' && *t != 0) { t++; if (*t == '\\') t += 2; } } } // WARN(Santiago): null buffer position skipping avoidance. while (*t == 0 && t != term) { t--; } t++; tt = ((char *)e + offset); while (is_hefesto_blank(*tt)) tt++; // can't add one more ')' because this is a function that is an // argument of another function if (*tt == ',') count--; while (count > 0) { *t = ')'; t++; count--; } *t = 0; } e += offset; free(args); if (*e == ')') e++; } else if ((*e == '-' || *e == '+') && t == term && isdigit(*(e+1)) && state == 0) { *t = *e; t++; continue; } if ((is_op(*e) || *e == '(' || *e == ')') && t == term) { *t = *e; t++; *t = 0; if (is_op(*(e+1)) && *e != '(' && *e != ')') { // composed operands *t = *(e+1); e++; t++; *t = 0; } state = 0; } else if ((e + 1) != efinis) e--; if (strcmp(term,"(") == 0) { sp = hefesto_common_stack_ctx_push(sp, (void *) term, t - term, HEFESTO_VAR_TYPE_UNTYPED); } else if(strcmp(term, ")") == 0) { t = (char *)hefesto_common_stack_ctx_data_on_top(sp); if (t && strcmp(t, "(") != 0) { while (sp && sp->data != NULL && strcmp(sp->data, "(") != 0) { lp = add_data_to_hefesto_common_list_ctx(lp, hefesto_common_stack_ctx_data_on_top(sp), hefesto_common_stack_ctx_dsize_on_top(sp)); dp = hefesto_common_stack_ctx_on_top(sp); sp = hefesto_common_stack_ctx_pop(sp); del_hefesto_common_stack_ctx(dp); } } dp = hefesto_common_stack_ctx_on_top(sp); sp = hefesto_common_stack_ctx_pop(sp); del_hefesto_common_stack_ctx(dp); } else if ((p = get_op_precedence(term)) != -1) { tp = get_op_precedence(hefesto_common_stack_ctx_data_on_top(sp)); while (tp != -1 && tp >= p) { lp = add_data_to_hefesto_common_list_ctx(lp, hefesto_common_stack_ctx_data_on_top(sp), hefesto_common_stack_ctx_dsize_on_top(sp)); dp = hefesto_common_stack_ctx_on_top(sp); sp = hefesto_common_stack_ctx_pop(sp); del_hefesto_common_stack_ctx(dp); tp = get_op_precedence(hefesto_common_stack_ctx_data_on_top(sp)); } sp = hefesto_common_stack_ctx_push(sp, (void *) term, t - term, HEFESTO_VAR_TYPE_UNTYPED); } else { lp = add_data_to_hefesto_common_list_ctx(lp, term, t - term); state = 1; } t = term; *t = 0; } if (*term) { sp = hefesto_common_stack_ctx_push(sp, (void *) term, t - term, HEFESTO_VAR_TYPE_UNTYPED); } while (!hefesto_common_stack_ctx_empty(sp)) { lp = add_data_to_hefesto_common_list_ctx(lp, hefesto_common_stack_ctx_data_on_top(sp), hefesto_common_stack_ctx_dsize_on_top(sp)); dp = hefesto_common_stack_ctx_on_top(sp); sp = hefesto_common_stack_ctx_pop(sp); del_hefesto_common_stack_ctx(dp); } free(term); for (p = 0, sz = 0, l = lp; l; l = l->next, p++) { sz += l->dsize; } sz += (size_t) p; term = (char *) hefesto_mloc(sz); *term = 0; for (l = lp; l; l = l->next) { if (*(char *)l->data == '(') continue; strncat(term, (char *) l->data, sz - 1); if (l->next && *(char *)l->next->data != '[') strncat(term, " ", sz - 1); } del_hefesto_common_list_ctx(lp); return term; }
string ExpressionManager::postfixToInfix(string postfixExpression){ if(!op_num_ratio_check(postfixExpression)){ return invalid; } if(strcspn(postfixExpression.c_str(), symbols) != postfixExpression.length()){ //a postfix expression shouldn't have any paren symbols return invalid; } if(!is_op(postfixExpression[postfixExpression.length() - 1])){ //if the last character of the expression is not an operator //then it must not be a valid postfix expression return invalid; } stack<string> exp_stack; string out_str = ""; string right; string left; char exp_str[STR_BUFF_SIZE]; exp_str[0] = '\0'; //create a C string from the expression string //for use in strtok strcat(exp_str, postfixExpression.c_str()); char * token; //use strtok to tokenize the string //separating by spaces token = strtok(exp_str, " "); while(token != NULL){ //cout << "token: " << token << "\n"; if(is_int_num(string(token))){ exp_stack.push( string(token) ); } else if(is_op( *token)){ right = exp_stack.top(); exp_stack.pop(); left = exp_stack.top(); exp_stack.pop(); string push_str; push_str += "( "; push_str += left; push_str += " "; push_str += string(token); push_str += " "; push_str += right; push_str += " )"; exp_stack.push(push_str); } else { //it's not fine return invalid; } //increment to the next token token = strtok(NULL, " "); } out_str = exp_stack.top(); return out_str; }
float eval(char *expr){ float nums[80]; char ops[80]; char c; char temp_string[80]; int t,s; int line=0,neg=0,done=0; int sparens; float temp_result; /* Parse String */ nums[0]=0; for (t=0;(c=expr[t]);t++) { if (nums[line]==0 && c=='-') { neg=1; } else if (('0' <= c && c <= '9') || c=='.') { sscanf(expr+t,"%f",&nums[line]); while (('0' <= expr[t] && expr[t] <= '9') || expr[t]=='.') t++; t--; if (neg) nums[line] = -nums[line]; } else if (is_op(c)) { ops[line]=c; line++; nums[line]=0; neg=0; } else if (c != ' ') { Error("Parse Error on string"); error=1; return 0; } } ops[line]=0; /* Handle Parenthases */ sparens=0; for (t=0;t<line;t++) { if (ops[t]=='(') sparens++; if (ops[t]==')') sparens--; } if (sparens != 0) { Error("Error with parenthases."); error=1; return 0; } while(!done) { sparens=-1; for (t=0;t<line;t++) { if (ops[t]=='(') { sparens=t; } else if (ops[t]==')') { if (sparens==-1) { Error("Error with parenthases."); error=1; return 0; } *temp_string='\0'; for (s=sparens+1;s<=t;s++) sprintf(temp_string,"%s%f%c",temp_string,nums[s],ops[s]); temp_string[strlen(temp_string)-1]='\0'; temp_result=eval(temp_string); ops[sparens]=ops[t+1]; for (s=sparens+1;s<line-t+1;s++) { ops[s]=ops[(t-sparens)+s+1]; nums[s]=nums[(t-sparens)+s+1]; } nums[sparens]=temp_result; line-=(t-sparens)+1; t=line; } } if (sparens==-1) done=1; if (t==line-1 && sparens != -1) { Error("Error with parenthases."); error=1; return 0; done=1; } } /* Handle Exponent */ for (t=0;t<line;t++) { if (ops[t]=='^') { nums[t]=pow(nums[t],nums[t+1]); ops[t]=ops[t+1]; for (s=t+1;s<line;s++) { nums[s]=nums[s+1]; ops[s]=ops[s+1]; } line--; t--; } } /* Handle Mult and Div */ for (t=0;t<line;t++) { if (ops[t]=='*') nums[t]*=nums[t+1]; else if (ops[t]== '/') nums[t] /= nums[t+1]; if (ops[t]=='*' || ops[t]=='/') { ops[t]=ops[t+1]; for (s=t+1;s<line;s++) { nums[s]=nums[s+1]; ops[s]=ops[s+1]; } line--; t--; } } /* Handle Add and Sub */ for (t=0;t<line;t++) { if (ops[t]=='+') nums[t]+=nums[t+1]; else if (ops[t]== '-') nums[t] -= nums[t+1]; if (ops[t]=='+' || ops[t]=='-') { ops[t]=ops[t+1]; for (s=t+1;s<line;s++) { nums[s]=nums[s+1]; ops[s]=ops[s+1]; } line--; t--; } } if (line != 0) { printf("Error processing string %s\n",expr); exit(); } return (nums[0]); }
string ExpressionManager::postfixEvaluate(string postfixExpression){ if(!op_num_ratio_check(postfixExpression)){ return invalid; } if(strcspn(postfixExpression.c_str(), symbols) != postfixExpression.length()){ //a postfix expression shouldn't have any paren symbols return invalid; } //if(!is_op(postfixExpression[postfixExpression.length() - 1])){ // //if the last character of the expression is not an operator // //then it must not be a valid postfix expression // return invalid; //} stack<int> exp_stack; string out_str = ""; string right; string left; char exp_str[STR_BUFF_SIZE]; exp_str[0] = '\0'; //create a C string from the expression string //for use in strtok strcat(exp_str, postfixExpression.c_str()); char * token; //use strtok to tokenize the string //separating by spaces token = strtok(exp_str, " "); while(token != NULL){ //cout << "token: " << token << "\n"; if(is_int_num(string(token))){ exp_stack.push( atoi(token) ); } else if(is_op( *token)){ if(exp_stack.empty()){ return invalid; } int iright = exp_stack.top(); exp_stack.pop(); if(exp_stack.empty()){ return invalid; } int ileft = exp_stack.top(); exp_stack.pop(); //int iright = stoi(right); //int ileft = stoi(left); //stringstream ps; int eval = 0; switch (*token){ case '+': eval = ileft + iright; break; case '-': eval = ileft - iright; break; case '*': eval = ileft * iright; break; case '/': if(iright == 0 ) return invalid; eval = ileft / iright; break; case '%': if(iright == 0 ) return invalid; eval = ileft % iright; break; } exp_stack.push(eval); } else { //it's not fine return invalid; } //increment to the next token token = strtok(NULL, " "); } if(!exp_stack.empty()){ char out_buff[STR_BUFF_SIZE]; sprintf(out_buff, "%i", exp_stack.top()); out_str = out_buff; } else { return invalid; } return out_str; }