自学教程：C++ term函数代码示例

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 voidchugid (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;}