コード例 #1
0
ファイル: expr_calculator.cpp プロジェクト: pbscrimmage/PPaP
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
        }
    }
}
コード例 #2
0
ファイル: setup.cpp プロジェクト: mngr777/ants
 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);
 }
コード例 #3
0
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;
}
コード例 #4
0
ファイル: compile.c プロジェクト: kzfm1024/misc
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;
	}
}
コード例 #5
0
bool Interpreter::add()
{
    match('+');

    currentStatement->createNodeAbove(new AddOp);
    currentStatement->goUp();
    //syntaxTree->writeLexem("+");
    //syntaxTree->createRightChild();
    //syntaxTree->goRight();
    if (!term()) return false;
    currentStatement->goUp();
    return true;
}
コード例 #6
0
ファイル: main.c プロジェクト: Nazg-Gul/WebTester
/**
 * 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 ();
    }
}
コード例 #7
0
ファイル: digraph.cpp プロジェクト: caiograg/grafalgo
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;
        }
    }
}
コード例 #8
0
ファイル: main.c プロジェクト: chadw75/letsbuildacompiler
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;
}
コード例 #9
0
ファイル: Term.C プロジェクト: ktf/sherpa
    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;
    }
コード例 #10
0
ファイル: basic_parser.c プロジェクト: Anipik/Compiler
expr_prime()
{
    /* expression' -> PLUS term expression'
     *              | epsilon
     */

    if( match( PLUS ) )
    {
        advance();
        term();
        expr_prime();
    }
}
コード例 #11
0
ファイル: parser_generator.c プロジェクト: brunzero/module_3
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);
        }
    }
}
コード例 #12
0
ファイル: Term.C プロジェクト: ktf/sherpa
    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;
    }
コード例 #13
0
ファイル: simple.c プロジェクト: 16Bitt/libcc
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");
}
コード例 #14
0
ファイル: eval.c プロジェクト: k4v/CA614-Project
/* 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;
}
コード例 #15
0
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;
}
コード例 #16
0
ファイル: parser.cpp プロジェクト: Sirflankalot/nip
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();
}
コード例 #17
0
ファイル: regex.cpp プロジェクト: darksideos/kraken
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();
}
コード例 #18
0
ファイル: parse.c プロジェクト: pexcn/Lily
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
		}
		
	}
	
}
コード例 #19
0
int expr_prime()
{  
     /* exp2 -> PLUS term exp1
     * 				| epsilon
     */

    if( match( PLUS ) )
    {
		advance();
        term();
        printf("+\n");
        exp1();
    }
}
コード例 #20
0
ファイル: code_gen.c プロジェクト: anilkagak2/compiler
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;
}
コード例 #21
0
        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");
        }
コード例 #22
0
ファイル: calc2.cpp プロジェクト: kaustubhb/PPPCpp
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;
    }
  }
}
コード例 #23
0
ファイル: TokenHandler.cpp プロジェクト: AnotherTest/-English
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);
}
コード例 #24
0
VNGError Vngo3Dfx::init()
{
    grGlideInit();
    if (!grSstQueryHardware (&hwconfig))
    {
        term();
        return (VNGO_MISSING_HARDWARE);
    }

    type_info = SCREENTYPE_3DFX;

    grSstSelect(0);
    return (VNGO_NO_ERROR);
}
コード例 #25
0
ファイル: TokenHandler.cpp プロジェクト: AnotherTest/-English
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);
}
コード例 #26
0
ファイル: erf.cpp プロジェクト: mobiusklein/mzR
  /*
   * 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);
  }
コード例 #27
0
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;
}
コード例 #28
0
ファイル: main.cpp プロジェクト: fezhang/Dragon
 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;
     }
 }
コード例 #29
0
ファイル: crewav.cpp プロジェクト: jbailhache/log
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();
}
コード例 #30
0
ファイル: lgModule.c プロジェクト: Abioy/dust
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;
}