void parse_expression(void) { Token t; parse_term(); for(;;) { t = get_token(); if (t.type != T_ADD && t.type != T_SUB && t.type != T_OR && t.type != T_AND && t.type != T_XOR) { unget_token(); break; } parse_term(); Opcode op = OP_ADD; if (t.type == T_ADD) { op = OP_ADD; } else if (t.type == T_SUB) { op = OP_SUB; } else if (t.type == T_OR) { op = OP_OR; } else if (t.type == T_AND) { op = T_AND; } else if (t.type == T_XOR) { op = T_XOR; } vm_add_opcode(op); } }
double parse_expression() { double v1; double v2; Token token; v1 = parse_term(); for (;;) { my_get_token(&token); if (token.kind != ADD_OPERATOR_TOKEN && token.kind != SUB_OPERATOR_TOKEN) { unget_token(&token); break; } v2 = parse_term(); if (token.kind == ADD_OPERATOR_TOKEN) { v1 += v2; } else if (token.kind == SUB_OPERATOR_TOKEN) { v1 -= v2; } else { unget_token(&token); } } return v1; }
/****************************************************************************** rest_expr := + term rest_expr - term rest_expr (nil) *****************************************************************************/ void parse_rest_expr( val_t* val ) { printtab(); dprintf("parse_rest_expr()\n"); level++; if ( match_char( '+' ) ) { val_t val2; parse_term( &val2 ); val->d.fval += val2.d.fval; parse_rest_expr( val ); } else if ( match_char( '-' ) ) { val_t val2; parse_term( &val2 ); val->d.fval /= val2.d.fval; parse_rest_expr( val ); } else if ( match_eof() ) { } else { } level--; return; }
static AVEvalExpr * parse_subexpr(Parser *p) { AVEvalExpr * e = parse_term(p); while(*p->s == '+' || *p->s == '-') { e= new_eval_expr(e_add, 1, e, parse_term(p)); }; return e; }
/*------------------------------------------------------------------------- * Function: parse_range * * Purpose: Tries to parse a range expression of the form `I1:I2' * where I1 and I2 are integer constants. * * Return: Success: A range object. * * Failure: &ErrorCell * * Programmer: Robb Matzke * [email protected] * Jan 3 1997 * * Modifications: * *------------------------------------------------------------------------- */ static obj_t parse_range (lex_t *f, int skipnl) { obj_t lt=NIL, rt=NIL, retval=NIL; int lo, hi; lt = parse_term (f, skipnl); if (&ErrorCell==lt) return &ErrorCell; if (TOK_COLON==lex_token (f, NULL, skipnl)) { lex_consume (f); rt = parse_term (f, skipnl); if (&ErrorCell==rt) { obj_dest (rt); return &ErrorCell; } /* * Both arguments must be integer constants. */ if (!num_isint(lt)) { out_error ("Range: left limit is not an integer constant: ", lt); obj_dest (lt); obj_dest (rt); return &ErrorCell; } if (!num_isint(rt)) { out_error ("Range: right limit is not an integer constant: ", rt); obj_dest (lt); obj_dest (rt); return &ErrorCell; } /* * The constants must be in a reasonable order. */ lo = num_int (lt); hi = num_int (rt); if (hi<lo) { out_errorn ("Range: inverted range %d:%d changed to %d:%d", lo, hi, hi, lo); lo = num_int (rt); hi = num_int (lt); } /* * Create the range object. */ lt = obj_dest (lt); rt = obj_dest (rt); retval = obj_new (C_RANGE, lo, hi); } else { retval = lt; } return retval; }
expr *parse_expr() { expr *l = parse_term(); char c = getchar(); while (c != '\n' && (c == '+' || c == '-')) { expr *r = parse_term(); l = binop(c, l, r); c = getchar(); } ungetc(c, stdin); return l; }
static RegExp * parse_diff(void) { RegExp *e, *f; e = parse_term(); while (curtok == '\\') { get_next_token(); /* \ */ f = parse_term(); e = mkDiff(e, f); if(!e) Scanner_fatal(in, "can only difference char sets"); } return e; }
/*----------------------------------------------------------------------*/ static ast_expression_t *parse_signed_term(parse_state_t *p) { ast_expression_t *term; /* TODO:jkd handle unary op */ term = parse_term(p); return term; }
static struct tdb_event_filter *parse_filter(const tdb *db, const char *filter_expression, int verbose) { char *dup = strdup(filter_expression); char *expr = dup; char *ctx = NULL; char *token = NULL; struct tdb_event_filter *filter = tdb_event_filter_new(); if (!dup || !filter) DIE("Out of memory."); while ((token = strtok_r(expr, " \n\t", &ctx))){ int is_negative = 0; if (*token == '&'){ if (verbose) fprintf(stderr, "AND\n"); tdb_event_filter_new_clause(filter); }else{ tdb_item item = parse_term(db, token, &is_negative, dup, verbose); tdb_event_filter_add_term(filter, item, is_negative); } expr = NULL; } free(dup); return filter; }
/*----------------------------------------------------------------------*/ static ast_expression_t *parse_sum_op(parse_state_t *p, ast_expression_t *left) { token_t* token; token = peek_token(p); if (token == NULL) { return NULL; } else if (token->type == TK_PLUS || token->type == TK_MINUS) { ast_expression_t *right; ast_expression_t *bin_op; ast_expression_t *sum_op; next_token(p); right = parse_term(p); bin_op = ALLOC(sizeof(ast_expression_t)); BZERO(bin_op); bin_op->tag = AST_EXPRESSION_BIN_OP; bin_op->u.bin_op.left = left; bin_op->u.bin_op.right = right; bin_op->u.bin_op.operation = token->type; sum_op = parse_sum_op(p, bin_op); return sum_op != NULL ? sum_op : bin_op; } else { return NULL; } }
void parse_expression(){ char t; parse_term(); for(;;){ t = get_token(); if(t != '+' && t != '-'){ e_index--; // トークンを押し戻す break; } parse_term(); if(t == '+'){ printf("OP_ADD\n"); }else if(t == '-'){ printf("OP_SUB\n"); } } }
std::string SimplifyParser::simplify (const std::string & expression) { // simplify terms like APP APP S K K begin(expression); SimplifyTerm term = parse_term(); end(); return term.route; }
// expression = term { add_op term } | // expression "?" expression ":" expression // expression logical_op expression // variable "=" expression // add_op = "+" | "-" static enum v7_err parse_expression(struct v7 *v7) { #ifdef V7_DEBUG const char *stmt_str = v7->cursor; #endif int op; v7->cur_obj = &v7->scopes[v7->current_scope]; TRY(parse_term(v7)); while (*v7->cursor == '-' || *v7->cursor == '+') { int ch = *v7->cursor; TRY(match(v7, ch)); TRY(parse_term(v7)); TRY(do_arithmetic_op(v7, ch)); } if ((op = is_logical_op(v7->cursor)) > OP_XX) { v7->cursor += op == OP_LT || op == OP_GT ? 1 : 2; skip_whitespaces_and_comments(v7); TRY(parse_expression(v7)); TRY(do_logical_op(v7, op)); } // Parse assignment if (*v7->cursor == '=') { //printf("=> cur_obj: %p\n", cur_obj); TRY(parse_assignment(v7, v7->cur_obj)); } // Parse ternary operator if (*v7->cursor == '?') { int condition_true = v7_is_true(v7_top(v7)[-1]); int old_no_exec = v7->no_exec; TRY(match(v7, '?')); v7->no_exec = old_no_exec || !condition_true; TRY(parse_expression(v7)); TRY(match(v7, ':')); v7->no_exec = old_no_exec || condition_true; TRY(parse_expression(v7)); v7->no_exec = old_no_exec; } return V7_OK; }
void parse_paramListFollow(unode_str_t* param) { symbol_t* var; e_data_t func_param_type; switch(next_token.type) { case TT_COMMA: match(TT_COMMA); parse_term(); if (param) func_param_type = param->item.type; else error("Bad function call parameters types/count", ERROR_TYPE_COMPAT); //var_init(); //TODO: ??? switch (curr_token.type) { case TT_LIT_INT: func_call_add_param(INT_DT); if (func_param_type == INT_DT) generate_param_push_int(curr_token.int_val); else generate_param_push_double((double)curr_token.int_val); break; case TT_LIT_DOUBLE: func_call_add_param(DOUBLE_DT); if (func_param_type == DOUBLE_DT) generate_param_push_double(curr_token.double_val); else generate_param_push_int((int)curr_token.double_val); break; case TT_LIT_STRING: func_call_add_param(STRING_DT); generate_param_push_string(curr_token.str); break; case TT_IDENTIFICATOR: var = var_table_find(curr_token.str); if (var == NULL) { error("Reference to undefined variable", ERROR_SEM); } else if (var->def != true) { error("Trying to use uninitialized variable", ERROR_UNDEF); } else { func_call_add_param(var->type); if (var->type == DOUBLE_DT && func_param_type == INT_DT) generate_param_conv_push(var->addr, true, false); else if (var->type == INT_DT && func_param_type == DOUBLE_DT) generate_param_conv_push(var->addr, false, true); else generate_param_push(var->addr); } break; default: ; } ++param_count; parse_paramListFollow(param->prev); break; default: return; } }
struct node *parse_arithmetic(struct compiler *compiler) { struct node *result = parse_term(compiler); while (lexer_current(compiler) == T_ADD || lexer_current(compiler) == T_SUB) { struct node *node = alloc_node(compiler, N_BINARY_OP); node->op = lexer_current(compiler); node->left = result; lexer_next(compiler); node->right = parse_term(compiler); result = node; } return result; }
/* +, - */ static ASTNode *parse_clause(Parser *p) /* better name? */ { ASTNode *expr = parse_term(p); loop: switch (peek_id(p)) { case TOK_PLUS: accept(p); ignore_eols(p); expr = ast_create_2(AST_ADD, expr, parse_term(p)); goto loop; case TOK_MINUS: accept(p); ignore_eols(p); expr = ast_create_2(AST_SUB, expr, parse_term(p)); goto loop; } return expr; }
instruction_ptr Parser::parse_expression() { int start_line = current_lexeme().line(); instruction_ptr left = parse_term(); if (!left) return instruction_ptr(); while (match_current_lexeme_simple_arithmetic()) { Lexeme lexeme = current_lexeme(); next_lexeme(); instruction_ptr right = parse_term(); if (!right) { report_current_syntax_error(); return instruction_ptr(); } switch (lexeme.type()) { case kAddition: left = instruction_ptr(new ArithmeticOperationInstruction(start_line, kAdd, left, right)); break; case kSubtraction: left = instruction_ptr(new ArithmeticOperationInstruction(start_line, kSub, left, right)); break; default: { report_current_syntax_error(); return instruction_ptr(); } } } return left; }
Cmd* Parser::parse_pre_unary() { Cmd* cmd = tokenizer.peek(); if (tokenizer.consume(TOKEN_MINUS)) { return new(cmd) CmdNegate( parse_pre_unary() ); } else { return parse_term(); } }
int parse_expression(CALC_ELEMENT ** e) { CALC_ELEMENT *t1 = NULL, *t2 = NULL; PARSE_SYMBOL s; if (parse_term(&t1) != 0) return -1; /* we have one here, which is nice... */ s = get_symbol(); while ((s == PARSE_ADD) || (s == PARSE_SUB)) { accept(s); if (parse_term(&t2) != 0) { free_calc_element(t1); return -1; } if (s == PARSE_ADD) t1 = create_bin_op('+', t1, t2); else t1 = create_bin_op('-', t1, t2); t2 = NULL; s = get_symbol(); } *e = t1; return 0; }
void parse_coutStmt() { switch(next_token.type) { case TT_KW_COUT: match(TT_KW_COUT); match(TT_OP_STREAM_OUT); parse_term(); symbol_t* var; if (curr_token.type == TT_IDENTIFICATOR) { var = var_table_find(curr_token.str); if (var == NULL) { error("Reference to undefined variable", ERROR_SEM); } else if (var->def != true) { error("Trying to use uninitialized variable", ERROR_UNDEF); } switch(var->type) { case INT_DT: generate_cout_int(var->addr); break; case DOUBLE_DT: generate_cout_double(var->addr); break; case STRING_DT: generate_cout_string(var->addr); break; default: ; } } switch(curr_token.type) { case TT_LIT_INT: generate_cout_int_lit(curr_token.int_val); break; case TT_LIT_DOUBLE: generate_cout_double_lit(curr_token.double_val); break; case TT_LIT_STRING: generate_cout_string_lit(curr_token.str); break; default: ; } parse_coutStmtFollow(); break; default: error("Syntactic error: Failed to parse the program", ERROR_SYN); } }
/****************************************************************************** expr := term rest_expr *****************************************************************************/ void parse_expr(val_t* val) { printtab(); dprintf("parse_expr()\n"); level++; if ( match_variable( val ) ) { parse_rest_var( val ); } else { parse_term( val ); parse_rest_expr( val ); } level--; return; }
struct expression *parse_exp() { struct expression *term = parse_term(); if (is_empty_expression(term)) return NULL; if (current_token == NULL) return NULL; switch (current_token->type) { case OpAnd: advanceToken(); struct expression *exp = new_op_expression(AndExp, term, parse_exp()); if (is_right_child_empty(exp)) { destroy_expression(exp); return NULL; } return exp; default: return term; } }
struct expression *parse_term() { struct expression *term; if (current_token == NULL) return NULL; switch (current_token->type) { case Var: term = new_var_expression(current_token->u.var_id); advanceToken(); return term; case LeftParen: advanceToken(); term = parse_prop(); if (is_empty_expression(term)) { return NULL; } switch (current_token->type) { case RightParen: advanceToken(); return term; default: return NULL; } case OpNot: advanceToken(); term = new_op_expression(NotExp, parse_term(), NULL); if (is_left_child_empty(term)) { destroy_expression(term); return NULL; } return term; default: return NULL; } }
Data* parse_aexpr(char** p) { Data* ret = NULL; while(parse_ws(p),**p) { int sign ; sign = parse_sign(p); if( !ret || sign ) { Data* term = parse_term(p); if( term->type == TYPE_ERROR ) { dispose(ret); return term; /*Throw the error*/ } else if( !ret ) /* First term */ { if( sign != 0 && term->type == TYPE_STRING ) /* There are one or more negitive/positive sign before A string*/ /* e.g. : +"illegal"*/ { dispose(term); dispose(ret); return Raise(SYNTAX); /*raise a syntax error*/ } else ret = term; if( sign < 0 ) {/*only INTEGER and REAL */ if( term->type == TYPE_INTEGER ) term->storage.Integer = -term->storage.Integer; else term->storage.Real = -term->storage.Real; } } else if( term->type == TYPE_STRING ) { ret = temp_var(ret); if( sign > 0 ) /* AC + STRING */ { if( ret->type != TYPE_STRING ) { /* non-string + string is illegal */ dispose(term); dispose(ret); return Raise(TYPE_MISMATCH); } /* do strcat */ char* A = ret->storage.String; char* B = term->storage.String; int lA = strlen(A); int lB = strlen(B); char* temp = (char*)malloc( lA + lB + 1); strcpy( temp , A ); strcpy( temp + lA , B ); ret->storage.String = temp; if( A != init_value[TYPE_STRING].String ) free(A); /*dispose old string*/ dispose(term); /*dispose this term*/ } else { /* AC - string is illegal */ dispose(term); dispose(ret); return Raise(TYPE_MISMATCH); } } else if( term->type == TYPE_INTEGER ) { ret = temp_var(ret); /*AC + INTEGER*/ if( ret->type == TYPE_STRING ) {/*Type Mismatch*/ dispose(ret); dispose(term); return Raise(TYPE_MISMATCH); } else if( ret->type == TYPE_INTEGER ) {/*Integer + Integer*/ ret->storage.Integer += sign * term->storage.Integer; dispose(term); } else if( ret->type == TYPE_REAL ) {/*Real + Integer*/ ret->storage.Real += sign * term->storage.Integer; dispose(term); } } else if( term->type == TYPE_REAL ) { double org; ret = temp_var(ret); /*AC + REAL */ if( ret->type == TYPE_STRING ) {/*Type Mismatch*/ dispose(ret); dispose(term); return Raise(TYPE_MISMATCH); } if( ret->type == TYPE_REAL ) org = ret->storage.Real; else org = ret->storage.Integer; ret->type = TYPE_REAL; ret->storage.Real = org + sign * term->storage.Real; dispose(term); } } else break; } if( ret == NULL ) ret=Raise(SYNTAX); return ret; }
static int parse_term(units *v, int scale_indicator, int parenthesised, int rigid) { int negative = 0; for (;;) if (parenthesised && tok.space()) tok.next(); else if (tok.ch() == '+') tok.next(); else if (tok.ch() == '-') { tok.next(); negative = !negative; } else break; unsigned char c = tok.ch(); switch (c) { case '|': // | is not restricted to the outermost level // tbl uses this tok.next(); if (!parse_term(v, scale_indicator, parenthesised, rigid)) return 0; int tem; tem = (scale_indicator == 'v' ? curdiv->get_vertical_position().to_units() : curenv->get_input_line_position().to_units()); if (tem >= 0) { if (*v < INT_MIN + tem) { error("numeric overflow"); return 0; } } else { if (*v > INT_MAX + tem) { error("numeric overflow"); return 0; } } *v -= tem; if (negative) { if (*v == INT_MIN) { error("numeric overflow"); return 0; } *v = -*v; } return 1; case '(': tok.next(); c = tok.ch(); if (c == ')') { if (rigid) return 0; warning(WARN_SYNTAX, "empty parentheses"); tok.next(); *v = 0; return 1; } else if (c != 0 && strchr(SCALE_INDICATOR_CHARS, c) != 0) { tok.next(); if (tok.ch() == ';') { tok.next(); scale_indicator = c; } else { error("expected `;' after scale-indicator (got %1)", tok.description()); return 0; } } else if (c == ';') { scale_indicator = 0; tok.next(); } if (!parse_expr(v, scale_indicator, 1, rigid)) return 0; tok.skip(); if (tok.ch() != ')') { if (rigid) return 0; warning(WARN_SYNTAX, "missing `)' (got %1)", tok.description()); } else tok.next(); if (negative) { if (*v == INT_MIN) { error("numeric overflow"); return 0; } *v = -*v; } return 1; case '.': *v = 0; break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': *v = 0; do { if (*v > INT_MAX/10) { error("numeric overflow"); return 0; } *v *= 10; if (*v > INT_MAX - (int(c) - '0')) { error("numeric overflow"); return 0; } *v += c - '0'; tok.next(); c = tok.ch(); } while (csdigit(c)); break; case '/': case '*': case '%': case ':': case '&': case '>': case '<': case '=': warning(WARN_SYNTAX, "empty left operand"); *v = 0; return rigid ? 0 : 1; default: warning(WARN_NUMBER, "numeric expression expected (got %1)", tok.description()); return 0; } int divisor = 1; if (tok.ch() == '.') { tok.next(); for (;;) { c = tok.ch(); if (!csdigit(c)) break; // we may multiply the divisor by 254 later on if (divisor <= INT_MAX/2540 && *v <= (INT_MAX - 9)/10) { *v *= 10; *v += c - '0'; divisor *= 10; } tok.next(); } } int si = scale_indicator; int do_next = 0; if ((c = tok.ch()) != 0 && strchr(SCALE_INDICATOR_CHARS, c) != 0) { switch (scale_indicator) { case 'z': if (c != 'u' && c != 'z') { warning(WARN_SCALE, "only `z' and `u' scale indicators valid in this context"); break; } si = c; break; case 0: warning(WARN_SCALE, "scale indicator invalid in this context"); break; case 'u': si = c; break; default: if (c == 'z') { warning(WARN_SCALE, "`z' scale indicator invalid in this context"); break; } si = c; break; } // Don't do tok.next() here because the next token might be \s, which // would affect the interpretation of m. do_next = 1; } switch (si) { case 'i': *v = scale(*v, units_per_inch, divisor); break; case 'c': *v = scale(*v, units_per_inch*100, divisor*254); break; case 0: case 'u': if (divisor != 1) *v /= divisor; break; case 'f': *v = scale(*v, 65536, divisor); break; case 'p': *v = scale(*v, units_per_inch, divisor*72); break; case 'P': *v = scale(*v, units_per_inch, divisor*6); break; case 'm': { // Convert to hunits so that with -Tascii `m' behaves as in nroff. hunits em = curenv->get_size(); *v = scale(*v, em.is_zero() ? hresolution : em.to_units(), divisor); } break; case 'M': { hunits em = curenv->get_size(); *v = scale(*v, em.is_zero() ? hresolution : em.to_units(), divisor*100); } break; case 'n': { // Convert to hunits so that with -Tascii `n' behaves as in nroff. hunits en = curenv->get_size()/2; *v = scale(*v, en.is_zero() ? hresolution : en.to_units(), divisor); } break; case 'v': *v = scale(*v, curenv->get_vertical_spacing().to_units(), divisor); break; case 's': while (divisor > INT_MAX/(sizescale*72)) { divisor /= 10; *v /= 10; } *v = scale(*v, units_per_inch, divisor*sizescale*72); break; case 'z': *v = scale(*v, sizescale, divisor); break; default: assert(0); } if (do_next) tok.next(); if (negative) { if (*v == INT_MIN) { error("numeric overflow"); return 0; } *v = -*v; } return 1; }
static int parse_expr(units *v, int scale_indicator, int parenthesised, int rigid) { int result = parse_term(v, scale_indicator, parenthesised, rigid); while (result) { if (parenthesised) tok.skip(); int op = tok.ch(); switch (op) { case '+': case '-': case '/': case '*': case '%': case ':': case '&': tok.next(); break; case '>': tok.next(); if (tok.ch() == '=') { tok.next(); op = OP_GEQ; } else if (tok.ch() == '?') { tok.next(); op = OP_MAX; } break; case '<': tok.next(); if (tok.ch() == '=') { tok.next(); op = OP_LEQ; } else if (tok.ch() == '?') { tok.next(); op = OP_MIN; } break; case '=': tok.next(); if (tok.ch() == '=') tok.next(); break; default: return result; } units v2; if (!parse_term(&v2, scale_indicator, parenthesised, rigid)) return 0; int overflow = 0; switch (op) { case '<': *v = *v < v2; break; case '>': *v = *v > v2; break; case OP_LEQ: *v = *v <= v2; break; case OP_GEQ: *v = *v >= v2; break; case OP_MIN: if (*v > v2) *v = v2; break; case OP_MAX: if (*v < v2) *v = v2; break; case '=': *v = *v == v2; break; case '&': *v = *v > 0 && v2 > 0; break; case ':': *v = *v > 0 || v2 > 0; break; case '+': if (v2 < 0) { if (*v < INT_MIN - v2) overflow = 1; } else if (v2 > 0) { if (*v > INT_MAX - v2) overflow = 1; } if (overflow) { error("addition overflow"); return 0; } *v += v2; break; case '-': if (v2 < 0) { if (*v > INT_MAX + v2) overflow = 1; } else if (v2 > 0) { if (*v < INT_MIN + v2) overflow = 1; } if (overflow) { error("subtraction overflow"); return 0; } *v -= v2; break; case '*': if (v2 < 0) { if (*v > 0) { if ((unsigned)*v > -(unsigned)INT_MIN / -(unsigned)v2) overflow = 1; } else if (-(unsigned)*v > INT_MAX / -(unsigned)v2) overflow = 1; } else if (v2 > 0) { if (*v > 0) { if (*v > INT_MAX / v2) overflow = 1; } else if (-(unsigned)*v > -(unsigned)INT_MIN / v2) overflow = 1; } if (overflow) { error("multiplication overflow"); return 0; } *v *= v2; break; case '/': if (v2 == 0) { error("division by zero"); return 0; } *v /= v2; break; case '%': if (v2 == 0) { error("modulus by zero"); return 0; } *v %= v2; break; default: assert(0); } } return result; }