double expression() // deal with + and - { double left = term(); // read and evaluate a Term Token t = ts.get(); // get the next token from token stream while(true) { switch(t.kind) { case '+': left += term(); // evaluate Term and add t = ts.get(); break; case '-': left -= term(); // evaluate Term and subtract t = ts.get(); break; default: ts.putback(t); // put t back into the token stream return left; // finally: no more + or -: return the answer } } }
const std::shared_ptr<Expr> Setup::expr(Expr::Id expr_id) { switch (expr_id.type) { case Expr::Term: return term(expr_id.index); case Expr::Func: return func(expr_id.index); case Expr::Select: return select(expr_id.index); case Expr::Invalid: throw std::logic_error("Invalid expression"); } assert(false); }
int expr (FILE *fp) { int val,k; char ch[10]; val=term(fp); while(1) { if( ex == '\0') ch[0] = fgetc(fp); else { ch[0] = ex; ex = '\0'; } if(ch[0]=='+') val=val+term(fp); else break; } ex = ch[0]; return val; }
void expression() /* 式のコンパイル */ { KeyId k; k = token.kind; if (k==Plus || k==Minus){ token = nextToken(); term(); if (k==Minus) genCodeO(neg); }else term(); k = token.kind; while (k==Plus || k==Minus){ token = nextToken(); term(); if (k==Minus) genCodeO(sub); else genCodeO(add); k = token.kind; } }
bool Interpreter::add() { match('+'); currentStatement->createNodeAbove(new AddOp); currentStatement->goUp(); //syntaxTree->writeLexem("+"); //syntaxTree->createRightChild(); //syntaxTree->goRight(); if (!term()) return false; currentStatement->goUp(); return true; }
/** * Change real and effective UID and GID * * @param __ruid - real UID * @param __rgid - real GID * @param __uid - effective UID * @param __gid - effective GID */ static void chugid (long __ruid, long __rgid, long __uid, long __gid) { if (__uid == __ruid && __gid == __rgid) { return; } if (setgroups (0, NULL) < 0) { lrvm_ipc_send_command ("exec_error", "\"Unable to call setgroups()\""); lrvm_ipc_done (); term (); } if (!allow_uid || !allow_gid) { lrvm_ipc_send_command ("exec_error","\"Execution with such GID and UID " "is not allowed\""); lrvm_ipc_done (); term (); } if (__gid >= 0 && __gid != __rgid && setregid (__gid, __gid) < 0) { lrvm_ipc_send_command ("exec_error", "\"Unable to change effective GID\""); lrvm_ipc_done (); term (); } if (__uid >= 0 && __uid != __ruid && setreuid (__uid, __uid) < 0) { lrvm_ipc_send_command ("exec_error", "\"Unable to change effective UID\""); lrvm_ipc_done (); term (); } }
void digraph::sortAdjLists() { // Sort all the adjacency lists and initialize li values. vertex u; edge e; for (u = 1; u <= n(); u++) { sortAlist(u); // now recompute li values li[u] = Null; for (e = first(u); e != term(u); e = next(u,e)) { if (u == head(e)) li[u] = e; } } }
int expression() { int retVal; if (isAddop(look)) { retVal = 0; } else { retVal = term(); } while (isAddop(look)) { switch (look) { case '+': match('+'); retVal += term(); break; case '-': match('-'); retVal -= term(); break; } } return retVal; }
static CTerm *New(const Complex &val=Complex(0.0,0.0)) { s_terms.MtxLock(); if (s_terms.empty()) { s_terms.MtxUnLock(); return new CTerm(val); } CTerm *term(s_terms.back()); s_terms.pop_back(); s_terms.MtxUnLock(); term->m_this=val; return term; }
expr_prime() { /* expression' -> PLUS term expression' * | epsilon */ if( match( PLUS ) ) { advance(); term(); expr_prime(); } }
void expression() { if (token.sym == plussym) { getToken(); term(); //add emit(2, 0, 2); } else if (token.sym == minussym) { getToken(); term(); //sub emit(2, 0, 3); } else term(); while(token.sym == plussym || token.sym == minussym) { if (token.sym == plussym) { getToken(); term(); //add emit(2, 0, 2); } else if (token.sym == minussym) { getToken(); term(); //sub emit(2, 0, 3); } } }
static DV4Term *New(const Vec4D &val) { s_terms.MtxLock(); if (s_terms.empty()) { s_terms.MtxUnLock(); return new DV4Term(val); } DV4Term *term(s_terms.back()); s_terms.pop_back(); s_terms.MtxUnLock(); term->m_this=val; return term; }
void term(){ if(look == '*'){ match("*"); term(); emitln("xor ebx, ebx"); settype(reduceptr(current_type)); STRSWITCH(current_type) STRCASE("short") emitln("mov bx, word [eax]"); STRCASE("char") emitln("mov bl, byte [eax]"); STRDEFAULT emitln("mov ebx, dword [eax]"); STRSWITCHEND emitln("xchg eax, ebx"); } else if(look == '('){ match("("); emitln("push eax"); expression(); match(")"); } else if(look == '"'){ emitln("mov eax, %s", add_string(getstring('"'))); current_type = "char*"; } else if(look == '\''){ match("'"); emitln("mov eax, %d", look); getcharacter(); match("'"); current_type = "char"; } else if(is_in(dynstring("%c", look), "+", "-", NULL)){ emitln("push dword 0"); operator(); } else if(isalpha(look)){ identifier(); } else if(isdigit(look)){ emitln("mov eax, %s", getnumber()); } else expected("Number or variable"); }
/* evaluate an expression term, eval_err will indicate it any expression evaluation occurs */ static struct eval_value_t /* value to expression term */ term(struct eval_state_t *es) /* expression evaluator */ { enum eval_token_t tok; struct eval_value_t val, val1; val = factor(es); if (eval_error) return err_value; tok = peek_next_token(es); switch (tok) { case tok_mult: (void)get_next_token(es); val = f_mult(val, term(es)); if (eval_error) return err_value; break; case tok_div: (void)get_next_token(es); val1 = term(es); if (eval_error) return err_value; if (f_eq_zero(val1)) { eval_error = ERR_DIV0; return err_value; } val = f_div(val, val1); break; default:; } return val; }
static MItem* expression() { // special case: expression is a list reference if (follows(MT_IDENT)) { MSymbol* list = peek_symbol(token->text); if (list != NULL && list->built_in == NULL && list->data != NULL && list->data->n >= 0) { next_token(); // only "=", "}", ";" or "," must follow if (!follows(MT_EQUAL) && !follows(MT_END) && !follows(MT_COMMA) && !follows(MT_SEMICOL)) serror("invalid use of list."); return list->data; } } // handle unary + and - double unary = 1.0; if (follows(MT_PLUS) || follows(MT_MINUS)) { if (follows(MT_MINUS)) unary = -1.0; next_token(); } double result = unary * term(); while (follows(MT_PLUS) || follows(MT_MINUS)) { if (follows(MT_PLUS)) { next_token(); result += term(); } else { next_token(); result -= term(); } } MItem* it = new_item(); it->n = -1; it->val = result; return it; }
void nip::parse::Parser::element() { if (accept(KEY_TRAIT)) { trait_declaration(); } else if (accept(KEY_INTRIN)) { intrinsic_declaration(); } else if (accept(KEY_DEFINE)) { function_definition(); } else if (accept(KEY_INSTANCE)) { instance_definition(); } else if (accept(KEY_PERMIT)) { permission_definition(); } else if (accept(KEY_ABOUT)) { about_section(); } else if (accept(KEY_TYPE)) { if (accept(KEY_SYNONYM)) { type_synonym(); } else { type_definition(); } } else if (accept(KEY_VOCAB)) { if (accept(KEY_SYNONYM)) { vocabulary_synonym(); } else { vocabulary_definition(); } } else if (accept(KEY_IMPORT)) { import_element(); } else if (accept(KEY_EXPORT)) { // export_element(); // Not implimented error("export isn't a supported language feature"); } else { while (!is(NEWLINE, SEMI_COLON)) { term(); } } endofstatement(); newlines(); }
RegexNode *RegexParser::concat(const char **str) { if (**str && **str != ')') { RegexNode *left = term(str); if (!left) return NULL; RegexNode *right = concat(str); if (right) return new ConcatNode(left, right); else return left; } else return new NullNode(); }
static void additive_expression() { int op_token; term(); while(token == TOK_PLUS || token == TOK_MINUS) { op_token = token; match(token); term(); if(op_token == TOK_PLUS){ gen_code("adi\n"); }else if(op_token == TOK_MINUS){ gen_code("sbi\n"); } else{ //common_error } } }
int expr_prime() { /* exp2 -> PLUS term exp1 * | epsilon */ if( match( PLUS ) ) { advance(); term(); printf("+\n"); exp1(); } }
char *expression() { /* expression -> term expression' * expression' -> PLUS term expression' | epsilon */ char *tempvar, *tempvar2; int plus; tempvar = term(); while( ( plus = match( PLUS ) ) || match( MINUS ) ) { advance(); tempvar2 = term(); if( plus ) printf(" %s += %s\n", tempvar, tempvar2 ); else printf(" %s -= %s\n", tempvar, tempvar2 ); freename( tempvar2 ); } return tempvar; }
Option<Term> lambdaTerm(TokenStream& tokens) { assert(tokens->type == Token::LAMBDA); tokens.advance(); if (tokens->type == Token::IDENTIFIER) { string id = tokens->identifierValue; tokens.advance(); Option<Term> body = term(tokens); if (body.exists()) { return Option<Term>(lambdaTerm(id, *body)); } else return body; } else return errorTerm("expected identifier"); }
double expression() { double left = term(); Token t = ts.get(); // Token stream while(true) { switch(t.kind) { case '+': left += term(); t = ts.get(); break; case '-': left -= term(); t = ts.get(); break; default: ts.putback(t); return left; } } }
Ast::Expression* Parser::term() { Ast::UnaryOp* left = primary(); ++current; if(current->type != TokenType::Operator) { --current; return new Ast::Expression(left); } const char op = current->getValue<char>(); if(op != '*' && op != '/') { --current; return new Ast::Expression(left); } return new Ast::Expression(left, term(), op); }
VNGError Vngo3Dfx::init() { grGlideInit(); if (!grSstQueryHardware (&hwconfig)) { term(); return (VNGO_MISSING_HARDWARE); } type_info = SCREENTYPE_3DFX; grSstSelect(0); return (VNGO_NO_ERROR); }
Ast::Expression* Parser::expression() { Ast::Expression* left = term(); ++current; if(current->type != TokenType::Operator) { --current; return left; } const char op = current->getValue<char>(); if(op != '+' && op != '-') { --current; return left; } return new Ast::Expression(left, expression(), op); }
/* * Abramawitz and Stegun: Eq. (7.1.5) gives a series for erf(z) good * for all z, but converges faster for smallish abs(z), say abs(z) < 2. */ std::complex<double> cerf_series(const std::complex<double>& z) { const double tiny = std::numeric_limits<double>::min(); std::complex<double> sum(0.0); std::complex<double> term(z); std::complex<double> z2(z*z); for (int n = 0; (n < 3) || (abs(term) > abs(sum) * tiny); n++) { sum += term / static_cast<double>(2 * n + 1); term *= -z2 / static_cast<double>(n + 1); } return sum * 2.0 / sqrt(pi); }
static int expression (void) { int t1, t2, op; t1 = term(); op = tokenizer_token(); while(op == T_PLUS || op == T_MINUS) { tokenizer_next(); t2 = term(); switch (op) { case T_PLUS: t1 = t1 + t2; break; case T_MINUS: t1 = t1 - t2; break; } op = tokenizer_token(); } return t1; }
void expr() { term(); while(true){ if ( '+' == lookahead) { match('+'); term(); if (parse_fail()) break; else std::cout<<'+'; }else if('-' == lookahead){ match('-'); term(); if (parse_fail()) break; else std::cout<<'-'; } else return; } }
void crewav () { char buf[1000]; struct wave_header header; int duree; int freq; int samples_per_sec; int nbytes; char x; int i; float y; duree = 10; freq = 440; samples_per_sec = 0x5622; nbytes = duree * samples_per_sec; T = duree * (2*3.1415926); init (); memcpy ((char *)&header.riff, "RIFF", 4); memcpy ((char *)&header.wave, "WAVE", 4); memcpy ((char *)&header.fmt, "fmt ", 4); memcpy ((char *)&header.data, "data", 4); header.len_data = nbytes; header.len_riff = nbytes + 36; header.len_fmt = 16; header.x = 1; header.n_chan = 1; header.samples_per_sec = samples_per_sec; header.bytes_per_sec = samples_per_sec; header.bytes_per_sample = 1; header.bit_per_sample = 8; save ((char *)&header, sizeof(header)); for (i=0; i<nbytes; i++) { /*x = 0x80 + 0x7F * sin (i * freq / samples_per_sec); */ y = fn (2*3.1415926*(float)i / (float)samples_per_sec); x = 0x80 + 0x7F * y; save (&x, 1); } x = 0; save (&x, 1); term(); }
void lgCmdFuncUnix(int argc, char* argv[]) { if(1 == argc) { term("Usage: unix [shell command like 'ls']"); } char cmd[200] = {0}; int i=0; for(i=1; i<argc; i++) { if((strlen(cmd)+strlen(argv[i])) > sizeof(cmd)/sizeof(cmd[0])) { term("too long unix cmd"); return; } sprintf(cmd+strlen(cmd), "%s ", argv[i]); } char recv[1024] = {0}; int size = sizeof(recv)/sizeof(recv[0]); getResultFromSystemCall(cmd, recv, &size); if(size > 0) { term("%s", recv); } return; }