Esempio n. 1
0
void
test_const()
    {
    test_exception e;
    boost::exception const & c(e);
    boost::exception & m(e);
    BOOST_TEST(is_const(boost::get_error_info<test_1>(c)));
    BOOST_TEST(!is_const(boost::get_error_info<test_1>(m)));
    }
Esempio n. 2
0
// *change 1.2.3a 'do_strict' insists that the signatures match exactly; otherwise
// we allow for looser matches (particularly method signatures)
bool Signature::match(const Signature& sig, bool do_strict) const
{
// Comparing signatures 
// *fix 1.2.2b (Eric) Functions w/ no args can be incorrectly matched
 if (this == &sig) return true;
 if (size() != sig.size() || !class_ptr() != !sig.class_ptr()) return false;
 // *fix 1.2.3 Method signatures made tighter in 'exact match' mode
 if (class_ptr() != NULL && sig.class_ptr() != NULL) {
     if ((do_strict && class_ptr() != sig.class_ptr())
        || !sig.class_ptr()->inherits_from(class_ptr()))
     return false; // *fix 1.2.1 Member function signatures are distinct!
 }
 if (is_const() != sig.is_const())
     return false; // *fix 0.9.6 constness makes signatures distinct
 if (stdarg() != sig.stdarg())
     return false; // *fix 1.2.3 (Eric) And so does whether this is stdarg or not
 
 Signature::iterator ti,tio;
 try {
 for(ti = begin(), tio = sig.begin(); ti != end(); ++ti,++tio)
   if (!(*ti == *tio)) return false;
 } catch(...) {
   return false;
 }
 //* return tio == sig.end() && ti == end(); //true;
 return true;
}
Esempio n. 3
0
/* Returns instantiate token list in a string (last argument) Uses
   CONNECTOR to connect the tokens together. 
   if "failflag" is 0 then Return 1 if ok, 0 if failure.
   Otherwise, exit on failure.
   */
int instantiate_into_string(token_list l, instantiation_list inst,char str[],
			    int failflag)
{
  instantiation_list i;
  char *p;
  token_list t = l;

  for(p = str; t; t = t->next) {
    if (is_const(t->item))  /* just copy over */
      { strcpy(p,t->item); p+=strlen(t->item); *p++ = CONNECTOR; }
    else {
      for(i=inst; i; i = i->next)
        if (strcmp(i->var_part, t->item) == SAME) {
	  if (i->const_part == NULL) {i = NULL; break;}
          strcpy(p,i->const_part);p+=strlen(i->const_part);*p++ = CONNECTOR;
          break;
        }
      if (!i) {
	if (failflag) do_error("instantiation failed");
	return 0;
      }
    }
  }
  *(--p) = '\0';
  return 1;
}
Esempio n. 4
0
bool is_const(Expr e) {
    if (e.as<IntImm>()) return true;
    if (e.as<FloatImm>()) return true;
    if (const Cast *c = e.as<Cast>()) {
        return is_const(c->value);
    }
    if (const Ramp *r = e.as<Ramp>()) {
        return is_const(r->base) && is_const(r->stride);
    }

    if (const Broadcast *b = e.as<Broadcast>()) {
        return is_const(b->value);
    }
    return false;
            
}
Esempio n. 5
0
inline int get_repeat(struct ir_remote *remote)
{
	if (!get_lead(remote))
		return (0);
	if (is_biphase(remote)) {
		if (!expectspace(remote, remote->srepeat))
			return (0);
		if (!expectpulse(remote, remote->prepeat))
			return (0);
	} else {
		if (!expectpulse(remote, remote->prepeat))
			return (0);
		set_pending_space(remote->srepeat);
	}
	if (!get_trail(remote))
		return (0);
	if (!get_gap
	    (remote,
	     is_const(remote) ? (min_gap(remote) >
				 rec_buffer.sum ? min_gap(remote) -
				 rec_buffer.sum : 0) : (has_repeat_gap(remote) ? remote->repeat_gap : min_gap(remote))
	    ))
		return (0);
	return (1);
}
Esempio n. 6
0
Dimension Dimension::set_extent(Expr extent) {
    param.set_extent_constraint(d, extent);
    // Propagate constant bounds into estimates as well.
    if (is_const(extent)) {
        param.set_extent_constraint_estimate(d, extent);
    }
    return *this;
}
Esempio n. 7
0
Dimension Dimension::set_min(Expr min) {
    param.set_min_constraint(d, min);
    // Propagate constant bounds into estimates as well.
    if (is_const(min)) {
        param.set_min_constraint_estimate(d, min);
    }
    return *this;
}
Esempio n. 8
0
bool cmp_operand(Operand first, Operand second)
{
    if (first == second) {
        return true;
    }
    else if (is_const(first) && is_const(second) && first->type == second->type) {
        switch (first->type) {
            case OPE_INTEGER: return first->integer == second->integer;
            case OPE_CHAR: return first->integer == second->integer;
            case OPE_FLOAT: return first->real == second->real;
            default: PANIC("Unexpected");
        }
        return false;
    }
    else {
        return false;
    }
}
Esempio n. 9
0
void Lex_analyzer::addToken(int tokenType, QString tokenValue){
    TokenType *t = new TokenType;
    Token *tok = new Token;
    switch(tokenType){
    case 1:
        if(is_keyword(tokenValue,t)){
            qDebug() <<"Token" <<tokenValue <<"found in keywords: id=" <<t->id  <<"type=" <<t->type <<endl;
            tok->id=t->id;
            tok->tokclass = "keywords";
            tok->toktype = t->type;
            tok->value = tokenValue;
            tokens->append(tok);
        }else if(is_type(tokenValue,t)){
            qDebug() <<"Token" <<tokenValue <<"found in types: id=" <<t->id  <<"type=" <<t->type <<endl;
            tok->id=t->id;
            tok->tokclass = "types";
            tok->toktype = t->type;
            tok->value = tokenValue;
            tokens->append(tok);
        }else{
            is_id(tokenValue, t);
            qDebug() <<"Token" <<tokenValue <<"found in/inserted to ids: id=" <<t->id  <<"type=" <<t->type <<endl;
            tok->id=t->id;
            tok->tokclass = "ids";
            tok->toktype = t->type;
            tok->value = tokenValue;
            tokens->append(tok);
        }
        break;
    case 2:
        is_const(tokenValue, t);
        qDebug() <<"Token" <<tokenValue <<"found in/inserted to constants: id=" <<t->id  <<"type=" <<t->type <<endl;
        tok->id=t->id;
        tok->tokclass = "constants";
        tok->toktype = t->type;
        tok->value = tokenValue;
        tokens->append(tok);
        break;
    case 3:
    case 4:
        if(is_operator(tokenValue, t)){
            qDebug() <<"Token" <<tokenValue <<"found in operators/separators: id=" <<t->id  <<"type=" <<t->type <<endl;
            tok->id=t->id;
            tok->tokclass = "separators";
            tok->toktype = t->type;
            tok->value = tokenValue;
            tokens->append(tok);
        }else{
            qDebug() <<"Error unknown token type: " <<tokenType  <<endl;
        }
        break;
    default:
        qDebug() <<"Error unknown token type: " <<tokenType  <<endl;
    }
    qDebug() <<"Adding token of type[" <<tokenType <<"] = " <<tokenValue  <<endl;
}
Esempio n. 10
0
static int sanityChecks(struct ir_remote *rem)
{
	struct ir_ncode *codes;
	struct ir_code_node *node;

	if (!rem->name)
	{
		logprintf(LOG_ERR,"you must specify a remote name");
		return 0;
	}
	if(rem->gap == 0)
	{
		logprintf(LOG_WARNING, "you should specify a valid gap value");
	}
	if(has_repeat_gap(rem) && is_const(rem))
	{
		logprintf(LOG_WARNING, "repeat_gap will be ignored if "
			  "CONST_LENGTH flag is set");
	}

	if(is_raw(rem)) return 1;

	if((rem->pre_data&gen_mask(rem->pre_data_bits)) != rem->pre_data)
	{
		logprintf(LOG_WARNING, "invalid pre_data found for %s",
			  rem->name);
		rem->pre_data &= gen_mask(rem->pre_data_bits);
	}
	if((rem->post_data&gen_mask(rem->post_data_bits)) != rem->post_data)
	{
		logprintf(LOG_WARNING, "invalid post_data found for %s",
			  rem->name);
		rem->post_data &= gen_mask(rem->post_data_bits);
	}
	for(codes = rem->codes; codes->name != NULL; codes++)
	{
		if((codes->code&gen_mask(rem->bits)) != codes->code)
		{
			logprintf(LOG_WARNING, "invalid code found for %s: %s",
				  rem->name, codes->name);
			codes->code &= gen_mask(rem->bits);
		}
		for(node = codes->next; node != NULL; node = node->next)
		{
			if((node->code&gen_mask(rem->bits)) != node->code)
			{
				logprintf(LOG_WARNING, "invalid code found "
					 "for %s: %s",
					  rem->name, codes->name);
				node->code &= gen_mask(rem->bits);
			}
		}
	}

	return 1;
}
Esempio n. 11
0
void match_types(Expr &a, Expr &b) {
    if (a.type() == b.type()) return;

    // First widen to match
    if (a.type().is_scalar() && b.type().is_vector()) {
        a = new Broadcast(a, b.type().width);
    } else if (a.type().is_vector() && b.type().is_scalar()) {
        b = new Broadcast(b, a.type().width);
    } else {
        assert(a.type().width == b.type().width && "Can't match types of differing widths");
    }

    Type ta = a.type(), tb = b.type();

    if (!ta.is_float() && tb.is_float()) {
        // int(a) * float(b) -> float(b)
        // uint(a) * float(b) -> float(b)        
        a = cast(tb, a);
    } else if (ta.is_float() && !tb.is_float()) {
        b = cast(ta, b);
    } else if (ta.is_float() && tb.is_float()) {    
        // float(a) * float(b) -> float(max(a, b))
        if (ta.bits > tb.bits) b = cast(ta, b);
        else a = cast(tb, a); 
    } else if (!ta.is_float() && !tb.is_float() && is_const(b)) {
        // (u)int(a) * (u)intImm(b) -> int(a)
        b = cast(ta, b); 
    } else if (!tb.is_float() && !ta.is_float() && is_const(a)) {
        a = cast(tb, a); 
    } else if (ta.is_uint() && tb.is_uint()) {
        // uint(a) * uint(b) -> uint(max(a, b))        
        if (ta.bits > tb.bits) b = cast(ta, b);
        else a = cast(tb, a);
    } else if (!ta.is_float() && !tb.is_float()) {
        // int(a) * (u)int(b) -> int(max(a, b))
        int bits = std::max(ta.bits, tb.bits);
        a = cast(Int(bits), a);
        b = cast(Int(bits), b);
    } else {
        std::cerr << "Could not match types: " << ta << ", " << tb << std::endl;
        assert(false && "Failed type coercion");    
    }
}
Esempio n. 12
0
Expr Interval::make_min(Expr a, Expr b) {
    if (a.same_as(b)) return a;

    // Deal with infinities
    if (a.same_as(Interval::pos_inf)) return b;
    if (b.same_as(Interval::pos_inf)) return a;
    if (a.same_as(Interval::neg_inf)) return a;
    if (b.same_as(Interval::neg_inf)) return b;

    // Deep equality
    if (equal(a, b)) return a;

    // Constant fold
    const int64_t *ia = as_const_int(a);
    const int64_t *ib = as_const_int(b);
    const uint64_t *ua = as_const_uint(a);
    const uint64_t *ub = as_const_uint(b);
    const double *fa = as_const_float(a);
    const double *fb = as_const_float(b);
    if (ia && ib) return (*ia > *ib) ? b : a;
    if (ua && ub) return (*ua > *ub) ? b : a;
    if (fa && fb) return (*fa > *fb) ? b : a;

    // Balance trees to the left, with constants pushed rightwards
    const Min *ma = a.as<Min>();
    const Min *mb = b.as<Min>();
    if (mb && !ma && !(is_const(mb->a) && is_const(mb->b))) {
        std::swap(ma, mb);
        std::swap(a, b);
    }
    if (ma && is_const(ma->b) && is_const(b)) {
        return Interval::make_min(ma->a, Interval::make_min(ma->b, b));
    }
    if (ma && (ma->a.same_as(b) || ma->b.same_as(b))) {
        // b is already represented in a
        return a;
    }

    return Min::make(a, b);
}
Esempio n. 13
0
void CodeGen_X86::visit(const Sub *op) {
    vector<Expr> matches;
    if (should_use_pmaddwd(op->a, op->b, matches)) {
        // Negate one of the factors in the second expression
        if (is_const(matches[2])) {
            matches[2] = -matches[2];
        } else {
            matches[3] = -matches[3];
        }
        codegen(Call::make(op->type, "pmaddwd", matches, Call::Extern));
    } else {
        CodeGen_Posix::visit(op);
    }
}
Esempio n. 14
0
// 常量计算
Operand calc_const(IR_Type op, Operand left, Operand right)
{
    assert(left->type == right->type && is_const(left));
    assert(IR_ADD <= op && op <= IR_DIV);

    Operand rst = new_operand(left->type);
    switch (left->type) {
        case OPE_INTEGER: 
        case OPE_CHAR:{
            switch (op) {
                case IR_ADD:
                    rst->integer = left->integer + right->integer;
                    break;
                case IR_SUB:
                    rst->integer = left->integer - right->integer;
                    break;
                case IR_MUL:
                    rst->integer = left->integer * right->integer;
                    break;
                case IR_DIV:
                    rst->integer = left->integer / right->integer;
                    break;
                default: assert(0);
            }
            break;
        }
        case OPE_FLOAT: {
            switch (op) {
                case IR_ADD:
                    rst->real = left->real + right->real;
                    break;
                case IR_SUB:
                    rst->real = left->real - right->real;
                    break;
                case IR_MUL:
                    rst->real = left->real * right->real;
                    break;
                case IR_DIV:
                    rst->real = left->real / right->real;
                    break;
                default: assert(0);
            }
            break;
        }
        default: assert(0);
    }
    return rst;
}
Esempio n. 15
0
static int
fold_unaryop(expr_ty node, PyArena *arena, int optimize)
{
    expr_ty arg = node->v.UnaryOp.operand;

    if (!is_const(arg)) {
        /* Fold not into comparison */
        if (node->v.UnaryOp.op == Not && arg->kind == Compare_kind &&
                asdl_seq_LEN(arg->v.Compare.ops) == 1) {
            /* Eq and NotEq are often implemented in terms of one another, so
               folding not (self == other) into self != other breaks implementation
               of !=. Detecting such cases doesn't seem worthwhile.
               Python uses </> for 'is subset'/'is superset' operations on sets.
               They don't satisfy not folding laws. */
            int op = asdl_seq_GET(arg->v.Compare.ops, 0);
            switch (op) {
            case Is:
                op = IsNot;
                break;
            case IsNot:
                op = Is;
                break;
            case In:
                op = NotIn;
                break;
            case NotIn:
                op = In;
                break;
            default:
                op = 0;
            }
            if (op) {
                asdl_seq_SET(arg->v.Compare.ops, 0, op);
                COPY_NODE(node, arg);
                return 1;
            }
        }
        return 1;
    }

    typedef PyObject *(*unary_op)(PyObject*);
    static const unary_op ops[] = {
        [Invert] = PyNumber_Invert,
        [Not] = unary_not,
        [UAdd] = PyNumber_Positive,
        [USub] = PyNumber_Negative,
    };
Esempio n. 16
0
int pixelview_decode(struct ir_remote *remote,
		     ir_code *prep,ir_code *codep,ir_code *postp,
		     int *repeat_flagp,lirc_t *remaining_gapp)
{
#if 0
	if(remote->pone!=0  ||  remote->sone!=833) return(0);
	if(remote->pzero!=833 || remote->szero!=0) return(0);
#endif

	if(!map_code(remote,prep,codep,postp,
		     10,pre,20,code,0,0))
	{
		return(0);
	}

	gap=0;
	if(start.tv_sec-last.tv_sec>=2) /* >1 sec */
	{
		*repeat_flagp=0;
	}
	else
	{
		gap=(start.tv_sec-last.tv_sec)*1000000+
		start.tv_usec-last.tv_usec;
		
		if(gap<remote->remaining_gap*(100+remote->eps)/100
		   || gap<=remote->remaining_gap+remote->aeps)
			*repeat_flagp=1;
		else
			*repeat_flagp=0;
	}
	
	*remaining_gapp=is_const(remote) ?
	(remote->gap>signal_length ? remote->gap-signal_length:0):
	remote->gap;

	LOGPRINTF(1,"pre: %llx",(unsigned long long) *prep);
	LOGPRINTF(1,"code: %llx",(unsigned long long) *codep);
	LOGPRINTF(1,"repeat_flag: %d",*repeat_flagp);
	LOGPRINTF(1,"gap: %lu",(unsigned long) gap);
	LOGPRINTF(1,"rem: %lu",(unsigned long) remote->remaining_gap);
	LOGPRINTF(1,"signal length: %lu",(unsigned long) signal_length);


	return(1);
}
Esempio n. 17
0
int pinsys_decode(struct ir_remote *remote,
		  ir_code *prep,ir_code *codep,ir_code *postp,
		  int *repeat_flagp,lirc_t *remaining_gapp)
{
	if(!map_code(remote,prep,codep,postp,
		     0,0,8,code&(~REPEAT_FLAG),0,0))
	{
		return(0);
	}
	
	gap=0;
	if(start.tv_sec-last.tv_sec>=2) /* >1 sec */
	{
		*repeat_flagp=0;
	}
	else
	{
		gap=(start.tv_sec-last.tv_sec)*1000000+
			start.tv_usec-last.tv_usec;
		
		if(gap<remote->remaining_gap*(100+remote->eps)/100
		   || gap<=remote->remaining_gap+remote->aeps)
			*repeat_flagp=1;
		else
			*repeat_flagp=0;
		
		/* let's believe the remote */
		if(code&REPEAT_FLAG)
		{
			*repeat_flagp=1;
		}
	}
	
	*remaining_gapp=is_const(remote) ?
		(remote->gap>signal_length ? remote->gap-signal_length:0):
		remote->gap;
	
	LOGPRINTF(1,"code: %llx\n",(unsigned long long) *codep);
	LOGPRINTF(1,"repeat_flag: %d\n",*repeat_flagp);
	LOGPRINTF(1,"gap: %lu\n",(unsigned long) gap);
	LOGPRINTF(1,"rem: %lu\n",(unsigned long) remote->remaining_gap);
	LOGPRINTF(1,"signal length: %lu\n",(unsigned long) signal_length);
	
	return(1);
}
Esempio n. 18
0
Operand get_neg(Operand ope)
{
    if (is_const(ope)) {
        Operand p = new_operand(ope->type);
        if (ope->type == OPE_INTEGER) {
            p->integer = -ope->integer;
        }
        else if (ope->type == OPE_FLOAT) {
            p->real = -ope->real;
        }
        else {
            LOG("Error");
            assert(0);
        }
        return p;
    }
    else {
        LOG("Not const");
        assert(0);
    }
}
Esempio n. 19
0
int mp3anywhere_decode(struct ir_remote *remote,
		  ir_code *prep,ir_code *codep,ir_code *postp,
		  int *repeat_flagp,lirc_t *remaining_gapp)
{
	if(!map_code(remote,prep,codep,postp,
		     24,pre,8,code,0,0))
	{
		return(0);
	}

	gap=0;
	if(start.tv_sec-last.tv_sec>=2) /* >1 sec */
	{
		*repeat_flagp=0;
	}
	else
	{
		gap=(start.tv_sec-last.tv_sec)*1000000+
		start.tv_usec-last.tv_usec;
		
		if(gap<remote->remaining_gap*(100+remote->eps)/100
		   || gap<=remote->remaining_gap+remote->aeps)
			*repeat_flagp=1;
		else
			*repeat_flagp=0;
	}
	
	*remaining_gapp=is_const(remote) ?
	(remote->gap>signal_length ? remote->gap-signal_length:0):
	remote->gap;

	LOGPRINTF(1,"pre: %llx",(unsigned long long) *prep);
	LOGPRINTF(1,"code: %llx",(unsigned long long) *codep);
	LOGPRINTF(1,"repeat_flag: %d",*repeat_flagp);
	LOGPRINTF(1,"gap: %lu",(unsigned long) gap);
	LOGPRINTF(1,"rem: %lu",(unsigned long) remote->remaining_gap);
	LOGPRINTF(1,"signal length: %lu",(unsigned long) signal_length);

	return(1);
}
Esempio n. 20
0
void to_string(Polynomial *poly){
    Term *term;
    for (int i = 0; i < poly->num_terms; i++){
        term = &(poly->terms[i]);
        if (term->coeff.den == 1){
            if (is_const(*term, poly->num_vars)) {
                printf("%+d", term->coeff.num); 
            }
            else if (i == 0 && term->coeff.num != 1) {
                printf("%d", term->coeff.num); 
            }
            else if (i != 0 && term->coeff.num != 1){
                printf("%+d", term->coeff.num);
            }
            else if (i != 0 && term->coeff.num == 1) {
                printf("+"); 
            }
        }
        else if (i != 0){
            printf("%+d/%d", term->coeff.num, term->coeff.den);
        }
        else {
            printf("%d/%d", term->coeff.num, term->coeff.den);
        }   
        for (int j = 0; j < poly->num_vars; j++){
            if (term->pow[j] != 0) {
                if (term->pow[j] == 1) {
                    printf("%c", poly->vars[j]);
                }
                else {
                    printf("%c^%d", poly->vars[j], term->pow[j]); 
                }
            }
        }
        printf(" "); 
    }
    printf("\n"); 
}
Esempio n. 21
0
      static std::string format_parameters(const std::vector<Boxed_Value> &t_parameters,
          bool t_dot_notation,
          const chaiscript::detail::Dispatch_Engine &t_ss)
      {
        std::stringstream ss;
        ss << "(";

        if (!t_parameters.empty())
        {
          std::string paramstr;

          for (auto itr = t_parameters.begin();
               itr != t_parameters.end();
               ++itr)
          {
            paramstr += (itr->is_const()?"const ":"");
            paramstr += t_ss.type_name(*itr);

            if (itr == t_parameters.begin() && t_dot_notation)
            {
              paramstr += ").(";
              if (t_parameters.size() == 1)
              {
                paramstr += ", ";
              }
            } else {
              paramstr += ", ";
            }
          }

          ss << paramstr.substr(0, paramstr.size() - 2);
        }
        ss << ")";

        return ss.str();
      }
Esempio n. 22
0
int receive_decode(struct ir_remote *remote,
		   ir_code *prep,ir_code *codep,ir_code *postp,
		   int *repeat_flagp,lirc_t *remaining_gapp)
{
	ir_code pre,code,post,code_mask=0,post_mask=0;
	lirc_t sync;
	int header;
	struct timeval current;

	sync=0; /* make compiler happy */
	code=pre=post=0;
	header=0;

	if(hw.rec_mode==LIRC_MODE_MODE2 ||
	   hw.rec_mode==LIRC_MODE_PULSE ||
	   hw.rec_mode==LIRC_MODE_RAW)
	{
		rewind_rec_buffer();
		rec_buffer.is_biphase=is_biphase(remote) ? 1:0;
		
		/* we should get a long space first */
		if(!(sync=sync_rec_buffer(remote)))
		{
			LOGPRINTF(1,"failed on sync");
			return(0);
		}

		LOGPRINTF(1,"sync");

		if(has_repeat(remote) && last_remote==remote)
		{
			if(remote->flags&REPEAT_HEADER && has_header(remote))
			{
				if(!get_header(remote))
				{
					LOGPRINTF(1,"failed on repeat "
						  "header");
					return(0);
				}
				LOGPRINTF(1,"repeat header");
			}
			if(get_repeat(remote))
			{
				if(remote->last_code==NULL)
				{
					logprintf(LOG_NOTICE,"repeat code "
						  "without last_code "
						  "received");
					return(0);
				}

				*prep=remote->pre_data;
				*codep=remote->last_code->code;
				*postp=remote->post_data;
				*repeat_flagp=1;

				*remaining_gapp=
				is_const(remote) ? 
				(remote->gap>rec_buffer.sum ?
				 remote->gap-rec_buffer.sum:0):
				(has_repeat_gap(remote) ?
				 remote->repeat_gap:remote->gap);
				return(1);
			}
			else
			{
				LOGPRINTF(1,"no repeat");
				rewind_rec_buffer();
				sync_rec_buffer(remote);
			}

		}

		if(has_header(remote))
		{
			header=1;
			if(!get_header(remote))
			{
				header=0;
				if(!(remote->flags&NO_HEAD_REP && 
				     (sync<=remote->gap+remote->gap*remote->eps/100
				      || sync<=remote->gap+remote->aeps)))
				{
					LOGPRINTF(1,"failed on header");
					return(0);
				}
			}
			LOGPRINTF(1,"header");
		}
	}

	if(is_raw(remote))
	{
		struct ir_ncode *codes,*found;
		int i;

		if(hw.rec_mode==LIRC_MODE_CODE ||
		   hw.rec_mode==LIRC_MODE_LIRCCODE)
			return(0);

		codes=remote->codes;
		found=NULL;
		while(codes->name!=NULL && found==NULL)
		{
			found=codes;
			for(i=0;i<codes->length;)
			{
				if(!expectpulse(remote,codes->signals[i++]))
				{
					found=NULL;
					rewind_rec_buffer();
					sync_rec_buffer(remote);
					break;
				}
				if(i<codes->length &&
				   !expectspace(remote,codes->signals[i++]))
				{
					found=NULL;
					rewind_rec_buffer();
					sync_rec_buffer(remote);
					break;
				}
			}
			codes++;
		}
		if(found!=NULL)
		{
			if(!get_gap(remote,
				    is_const(remote) ? 
				    remote->gap-rec_buffer.sum:
				    remote->gap)) 
				found=NULL;
		}
		if(found==NULL) return(0);
		code=found->code;
	}
	else
	{
		if(hw.rec_mode==LIRC_MODE_CODE ||
		   hw.rec_mode==LIRC_MODE_LIRCCODE)
		{
			int i;
 			lirc_t sum;

#                       ifdef LONG_IR_CODE
			LOGPRINTF(1,"decoded: %llx",rec_buffer.decoded);
#                       else
			LOGPRINTF(1,"decoded: %lx",rec_buffer.decoded);
#                       endif
			if((hw.rec_mode==LIRC_MODE_CODE &&
			    hw.code_length<remote->pre_data_bits
			    +remote->bits+remote->post_data_bits)
			   ||
			   (hw.rec_mode==LIRC_MODE_LIRCCODE && 
			    hw.code_length!=remote->pre_data_bits
			    +remote->bits+remote->post_data_bits))
			{
				return(0);
			}
			
			for(i=0;i<remote->post_data_bits;i++)
			{
				post_mask=(post_mask<<1)+1;
			}
			post=rec_buffer.decoded&post_mask;
			post_mask=0;
			rec_buffer.decoded=
			rec_buffer.decoded>>remote->post_data_bits;
			for(i=0;i<remote->bits;i++)
			{
				code_mask=(code_mask<<1)+1;
			}
			code=rec_buffer.decoded&code_mask;
			code_mask=0;
			pre=rec_buffer.decoded>>remote->bits;
			gettimeofday(&current,NULL);
			sum=remote->phead+remote->shead+
				lirc_t_max(remote->pone+remote->sone,
					   remote->pzero+remote->szero)*
				(remote->bits+
				 remote->pre_data_bits+
				 remote->post_data_bits)+
				remote->plead+
				remote->ptrail+
				remote->pfoot+remote->sfoot+
				remote->pre_p+remote->pre_s+
				remote->post_p+remote->post_s;
			
			rec_buffer.sum=sum>=remote->gap ? remote->gap-1:sum;
			sync=time_elapsed(&remote->last_send,&current)-
 				rec_buffer.sum;
		}
		else
		{
			if(!get_lead(remote))
Esempio n. 23
0
int init_send(struct ir_remote *remote,struct ir_ncode *code)
{
	int i, repeat=0;
	
	if(is_grundig(remote) || 
	   is_goldstar(remote) || is_serial(remote) || is_bo(remote))
	{
		logprintf(LOG_ERR,"sorry, can't send this protocol yet");
		return(0);
	}
	clear_send_buffer();
	if(is_biphase(remote))
	{
		send_buffer.is_biphase=1;
	}
	if(repeat_remote==NULL)
	{
		remote->repeat_countdown=remote->min_repeat;
	}
	else
	{
		repeat = 1;
	}
	
 init_send_loop:
	if(repeat && has_repeat(remote))
	{
		if(remote->flags&REPEAT_HEADER && has_header(remote))
		{
			send_header(remote);
		}
		send_repeat(remote);
	}
	else
	{
		if(!is_raw(remote))
		{
			ir_code next_code;
			
			if(code->transmit_state == NULL)
			{
				next_code = code->code;
			}
			else
			{
				next_code = code->transmit_state->code;
			}
			send_code(remote, next_code, repeat);
			if(has_toggle_mask(remote))
			{
				remote->toggle_mask_state++;
				if(remote->toggle_mask_state==4)
				{
					remote->toggle_mask_state=2;
				}
			}
			send_buffer.data=send_buffer._data;
		}
		else
		{
			if(code->signals==NULL)
			{
				logprintf(LOG_ERR, "no signals for raw send");
				return 0;
			}
			if(send_buffer.wptr>0)
			{
				send_signals(code->signals, code->length);
			}
			else
			{
				send_buffer.data=code->signals;
				send_buffer.wptr=code->length;
				for(i=0; i<code->length; i++)
				{
					send_buffer.sum+=code->signals[i];
				}
			}
		}
	}
	sync_send_buffer();
	if(bad_send_buffer())
	{
		logprintf(LOG_ERR,"buffer too small");
		return(0);
	}
	if(has_repeat_gap(remote) && repeat && has_repeat(remote))
	{
		remote->min_remaining_gap=remote->repeat_gap;
		remote->max_remaining_gap=remote->repeat_gap;
	}
	else if(is_const(remote))
	{
		if(min_gap(remote)>send_buffer.sum)
		{
			remote->min_remaining_gap=min_gap(remote)-send_buffer.sum;
			remote->max_remaining_gap=max_gap(remote)-send_buffer.sum;
		}
		else
		{
			logprintf(LOG_ERR,"too short gap: %u",remote->gap);
			remote->min_remaining_gap=min_gap(remote);
			remote->max_remaining_gap=max_gap(remote);
			return(0);
		}
	}
	else
	{
		remote->min_remaining_gap=min_gap(remote);
		remote->max_remaining_gap=max_gap(remote);
	}
	/* update transmit state */
	if(code->next != NULL)
	{
		if(code->transmit_state == NULL)
		{
			code->transmit_state = code->next;
		}
		else
		{
			code->transmit_state = code->transmit_state->next;
		}
	}
	if((remote->repeat_countdown>0 || code->transmit_state != NULL) &&
	   remote->min_remaining_gap<LIRCD_EXACT_GAP_THRESHOLD)
	{
		if(send_buffer.data!=send_buffer._data)
		{
			lirc_t *signals;
			int n;
			
			LOGPRINTF(1, "unrolling raw signal optimisation");
			signals=send_buffer.data;
			n=send_buffer.wptr;
			send_buffer.data=send_buffer._data;
			send_buffer.wptr=0;
			
			send_signals(signals, n);
		}
		LOGPRINTF(1, "concatenating low gap signals");
		if(code->next == NULL || code->transmit_state == NULL)
		{
			remote->repeat_countdown--;
		}
		send_space(remote->min_remaining_gap);
		flush_send_buffer();
		send_buffer.sum=0;
		
		repeat = 1;
		goto init_send_loop;
	}
	LOGPRINTF(3, "transmit buffer ready");
	return(1);
}
/**
 * Fill `m_prologue_blocks` and return the register that we're "switching" on
 * (even if it's not a real switch statement)
 */
boost::optional<uint16_t> SwitchMethodPartitioning::compute_prologue_blocks(
    cfg::ControlFlowGraph* cfg,
    const cp::intraprocedural::FixpointIterator& fixpoint,
    bool verify_default_case) {

  for (const cfg::Block* b : cfg->blocks()) {
    always_assert_log(!b->is_catch(),
                      "SwitchMethodPartitioning does not support methods with "
                      "catch blocks. %d has a catch block in %s",
                      b->id(), SHOW(*cfg));
  }

  // First, add all the prologue blocks that forma a linear chain before the
  // case block selection blocks (a switch or an if-else tree) begin.
  for (cfg::Block* b = cfg->entry_block(); b != nullptr; b = b->follow_goto()) {
    m_prologue_blocks.push_back(b);
  }

  {
    auto last_prologue_block = m_prologue_blocks.back();
    auto last_prologue_insn_it = last_prologue_block->get_last_insn();
    always_assert(last_prologue_insn_it != last_prologue_block->end());
    auto last_prologue_insn = last_prologue_insn_it->insn;
    // If this method was compiled from a default-case-only switch, there will
    // be no branch opcode -- the method will always throw an
    // IllegalArgumentException.
    auto op = last_prologue_insn->opcode();
    always_assert(!verify_default_case || is_branch(op) || op == OPCODE_THROW);

    if (!is_branch(op)) {
      return boost::none;
    } else if (is_switch(op)) {
      // switch or if-else tree. Not both.
      return last_prologue_insn->src(0);
    }
  }

  // Handle a tree of if statements in the prologue. d8 emits this
  // when it would be smaller than a switch statement. The non-leaf nodes of the
  // tree are prologue blocks. The leaf nodes of the tree are case blocks.
  //
  // For example:
  //   load-param v0
  //   const v1 1
  //   if-eq v0 v1 CASE_1
  //   goto EXIT_BLOCK      ; or return
  //   const v1 2
  //   if-eq v0 v1 CASE_2
  //   goto EXIT_BLOCK      ; or return
  //   ...
  //
  // Traverse the tree in starting at the end of the linear chain of prologue
  // blocks and stopping before we reach a leaf.
  boost::optional<uint16_t> determining_reg;
  std::queue<cfg::Block*> to_visit;
  to_visit.push(m_prologue_blocks.back());
  while (!to_visit.empty()) {
    auto b = to_visit.front();
    to_visit.pop();

    // Leaf nodes have 0 or 1 successors (return or goto the epilogue blocks).
    // Throw edges are disallowed.
    if (b->succs().size() >= 2) {
      // The linear check above and this tree check both account for the
      // top-most node in the tree. Make sure we don't duplicate it
      if (b != m_prologue_blocks.back()) {
        m_prologue_blocks.push_back(b);

        // Verify there aren't extra instructions in here that we may lose track
        // of
        for (const auto& mie : InstructionIterable(b)) {
          auto insn = mie.insn;
          auto op = insn->opcode();
          always_assert_log(is_const(op) || is_conditional_branch(op),
                            "Unexpected instruction in if-else tree %s",
                            SHOW(insn));
        }
      }
      for (auto succ : b->succs()) {
        to_visit.push(succ->target());
      }

      // Make sure all blocks agree on which register is the determiner
      uint16_t candidate_reg = ::find_determining_reg(b, fixpoint);
      if (determining_reg == boost::none) {
        determining_reg = candidate_reg;
      } else {
        always_assert_log(
            *determining_reg == candidate_reg,
            "Conflict: which register are we switching on? %d != %d in %s",
            *determining_reg, candidate_reg, SHOW(*cfg));
      }
    }
  }
  always_assert_log(determining_reg != boost::none,
                    "Couldn't find determining register in %s", SHOW(*cfg));
  return determining_reg;
}
Esempio n. 25
0
void calculate_signal_lengths(struct ir_remote *remote)
{
	if(is_const(remote))
	{
		remote->min_total_signal_length = min_gap(remote);
		remote->max_total_signal_length = max_gap(remote);
	}
	else
	{
		remote->min_gap_length = min_gap(remote);
		remote->max_gap_length = max_gap(remote);
	}

	lirc_t min_signal_length = 0, max_signal_length = 0;
	lirc_t max_pulse = 0, max_space = 0;
	int first_sum = 1;
	struct ir_ncode *c = remote->codes;
	int i;

	while(c->name)
	{
		struct ir_ncode code = *c;
		struct ir_code_node *next = code.next;
		int first = 1;
		int repeat = 0;
		do{
			if(first)
			{
				first = 0;
			}
			else
			{
				code.code = next->code;
				next = next->next;
			}
			for(repeat = 0; repeat < 2; repeat++)
			{
				if(init_sim(remote, &code, repeat))
				{
					lirc_t sum = send_buffer.sum;

					if(sum)
					{
						if(first_sum ||
						   sum < min_signal_length)
						{
							min_signal_length = sum;
						}
						if(first_sum ||
						   sum > max_signal_length)
						{
							max_signal_length = sum;
						}
						first_sum = 0;
					}
					for(i=0; i<send_buffer.wptr; i++)
					{
						if(i&1) /* space */
						{
							if(send_buffer.data[i] > max_space)
							{
								max_space = send_buffer.data[i];
							}
						}
						else /* pulse */
						{
							if(send_buffer.data[i] > max_pulse)
							{
								max_pulse = send_buffer.data[i];
							}
						}
					}
				}
			}
		} while(next);
		c++;
	}
	if(first_sum)
	{
		/* no timing data, so assume gap is the actual total
		   length */
		remote->min_total_signal_length = min_gap(remote);
		remote->max_total_signal_length = max_gap(remote);
		remote->min_gap_length = min_gap(remote);
		remote->max_gap_length = max_gap(remote);
	}
	else if(is_const(remote))
	{
		if(remote->min_total_signal_length > max_signal_length)
		{
			remote->min_gap_length =
				remote->min_total_signal_length
				- max_signal_length;
		}
		else
		{
			logprintf(LOG_WARNING, "min_gap_length is 0 for "
				  "'%s' remote", remote->name);
			remote->min_gap_length = 0;
		}
		if(remote->max_total_signal_length > min_signal_length)
		{
			remote->max_gap_length =
				remote->max_total_signal_length
				- min_signal_length;
		}
		else
		{
			logprintf(LOG_WARNING, "max_gap_length is 0 for "
				  "'%s' remote", remote->name);
			remote->max_gap_length = 0;
		}
	}
	else
	{
		remote->min_total_signal_length = min_signal_length +
			remote->min_gap_length;
		remote->max_total_signal_length = max_signal_length +
			remote->max_gap_length;
	}
	LOGPRINTF(1, "lengths: %lu %lu %lu %lu",
		  remote->min_total_signal_length,
		  remote->max_total_signal_length,
		  remote->min_gap_length,
		  remote->max_gap_length);
}
Esempio n. 26
0
bool optimize_block(GList** instructions, int opt_level) {
    if(opt_level == 0) // no optimization
        return true;
    
	for(GList *inst = *instructions; inst != NULL; inst = inst->next) {
		uint32_t *a = (uint32_t*) DATA(inst)->args;

    	// pattern is LD A,HL+; LD (DE),A; INC DE -> LD DE+, HL+
		if((*a & 0xffffff) == 0x13122a) {
			printf("optimizing block @%#x (3)\n", DATA(*instructions)->address);
			DATA(inst)->op1 = MEM_INC_DE;
			DATA(inst)->cycles = 6;
			DATA(inst)->bytes = 3;
			g_free(inst->next->data);
			*instructions = g_list_delete_link(*instructions, inst->next);
			g_free(inst->next->data);
			*instructions = g_list_delete_link(*instructions, inst->next);
		}

		//pattern f0 41 e6 03 20 fa -> wait for stat mode 3
		if((*a) == 0x03e641f0 && (*(a+1) & 0xffff) == 0xfa20) {
		    printf("optimizing block @%#x (4)\n", DATA(*instructions)->address);
		    DATA(inst)->opcode = HALT;
			DATA(inst)->op1 = WAIT_STAT3;
			DATA(inst)->cycles = 0;
			DATA(inst)->bytes = 6;
			g_free(inst->next->data);
			*instructions = g_list_delete_link(*instructions, inst->next);
			g_free(inst->next->data);
			*instructions = g_list_delete_link(*instructions, inst->next);
		}
		
		//pattern f0 44 fe ?? 20 fa -> wait for ly
		if((*a & 0x00ffffff) == 0xfe44f0 && (*(a+1) & 0xffff) == 0xfa20) {
		    printf("optimizing block @%#x (5)\n", DATA(*instructions)->address);
		    DATA(inst)->opcode = HALT;
			DATA(inst)->op1 = WAIT_LY;
			DATA(inst)->cycles = 0;
			DATA(inst)->bytes = 6;
			g_free(inst->next->data);
			*instructions = g_list_delete_link(*instructions, inst->next);
			g_free(inst->next->data);
			*instructions = g_list_delete_link(*instructions, inst->next);
		}
		
		//pattern f0 00 f0 00 -> repeated read of jopad register
		if((*a) == 0x00f000f0) {
		    printf("optimizing block @%#x (6)\n", DATA(*instructions)->address);
			DATA(inst)->cycles += 3;
			DATA(inst)->bytes += 2;
			DATA(inst)->args = DATA(inst->next)->args;
			g_free(inst->next->data);
			*instructions = g_list_delete_link(*instructions, inst->next);
			if(inst->prev)
			    //apply pattern to this instruction again
			    inst = inst->prev;
		}
	}

	int byte_offset = 0;
	for(GList *inst = *instructions; inst != NULL; inst = inst->next) {
		byte_offset += DATA(inst)->bytes;
		if(is_jump_to_start(DATA(inst), byte_offset)) {
			bool can_optimize1 = true;
			bool can_optimize2 = true;
			for(GList *inst2 = *instructions; inst2 != inst; inst2 = inst2->next) {
				if(!is_const(DATA(inst2), opt_level))
					can_optimize1 = false;

				if(!is_no_mem_access(DATA(inst2), opt_level))
					can_optimize2 = false;
			}

			if(can_optimize1) {
				printf("optimizing block @%#x (1)\n", DATA(*instructions)->address);
				// optimize  2: ... JP <2
				// to        JP >1 2: HALT 1: ... JP <2

				// insert jump target at the position of the old start instruction
				gb_instruction *jp_target = g_new(gb_instruction, 1);
				*jp_target = (gb_instruction){JP_TARGET, TARGET_1, NONE, 0, DATA(*instructions)->address, 0, 0, 0, 0};
				*instructions = g_list_prepend(*instructions, jp_target);
				// prepend halt, as the loop cannot change the break condition
				gb_instruction *halt_inst = g_new(gb_instruction, 1);
				*halt_inst = (gb_instruction){HALT, NONE, NONE, 0, DATA(*instructions)->address, 1, 1, 1, INST_FLAG_ENDS_BLOCK};
				*instructions = g_list_prepend(*instructions, halt_inst);
				// prepend jump target before halt instruction
				gb_instruction *jp_target2 = g_new(gb_instruction, 1);
				*jp_target2 = (gb_instruction){JP_TARGET, TARGET_2, NONE, 0, DATA(*instructions)->address, 0, 0, 0, 0};
				*instructions = g_list_prepend(*instructions, jp_target2);
				// prepend jp, to jump to the old start instruction
				gb_instruction *jp_inst = g_new(gb_instruction, 1);
				*jp_inst = (gb_instruction){JP_FWD, NONE, TARGET_1, 0, DATA(*instructions)->address, 0, 0, 0, 0};
				*instructions = g_list_prepend(*instructions, jp_inst);
				// modify jump to point to the halt instruction
				DATA(inst)->opcode = JP_BWD;
				DATA(inst)->op2 = TARGET_2;
				DATA(inst)->flags &= ~INST_FLAG_ENDS_BLOCK;
				break;
			} else if(can_optimize2) {
				if(DATA(*instructions)->address < 0xff00)
					printf("optimizing block @%#x (2)\n", DATA(*instructions)->address);

				// insert jump target at the position of the old start instruction
				gb_instruction *jp_target = g_new(gb_instruction, 1);
				*jp_target = (gb_instruction){JP_TARGET, TARGET_1, NONE, 0, DATA(*instructions)->address, 0, 0, 0, 0};
				*instructions = g_list_prepend(*instructions, jp_target);

				DATA(inst)->opcode = JP_BWD;
				DATA(inst)->op2 = TARGET_1;							
			} else {
				printf("jp to start detected, could not optimize %#x\n", DATA(*instructions)->address);			
			}
		}
    }

	return true;
}
Esempio n. 27
0
/////////////////////////////////////
// Funkce get_token
/////////////////////////////////////
int get_token(FILE *f, string *str) {
    int c;
    int ret;
    int state = start;
    char hex[] = "00";
    bool must_be_next = false;
    if(del_string(str) == RET_ERR)
        return RET_ERR;

    while((c=fgetc(f)) != EOF) {
        switch(state) {
        case start:
            ////// identifikátor
            if(isalpha(c) || c == '_') {
                state = identificator;
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
            }
            ////// Proměnná
            else if(c == '$') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                state = variable;
                must_be_next = true;
            }
            ////// Řetězcový literál
            else if(c == '"') {
                state = string_literal;
            }
            ////// číslo
            else if(isdigit(c)) {
                state = int_num;
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
            }
            ////////////////////////
            ////// Rovno, nerovno
            ////// jedno nebo tři rovnítka
            else if(c == '=') {
                state = equal;
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
            }
            ////// nerovno
            else if(c == '!') {
                state = not_equal;
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
            }
            ////// konkatenace - další znaky netřeba
            else if(c == '.') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                return concatenate;
            }
            //////////////////
            ////// Logické
            ////// menší || menší nebo rovno
            else if(c == '<') {
                state = less;
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
            }
            ////// větší || větší nebo rovno
            else if(c == '>') {
                state = greater;
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
            }
            //////////////////
            ////// Aritmetické
            ////// pouze znak plus - další znaky netřeba
            else if(c == '+') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                return plus;
            }
            ////// pouze znak plus - další znaky netřeba
            else if(c == '*') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                return multiply;
            }
            ////// pouze znak mínus - další znaky netřeba
            else if(c == '-') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                return minus;
            }
            ////// znak děleno || začátek komentáře
            else if(c == '/') {
                if(first)
                    return SYNT_ERR;
                else {
                    if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                    state = comment;
                }
            }
            //////////////////
            ////// Závorky
            ////// pouze znak ( - další znaky netřeba
            else if(c == '(') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                return left_parent;
            }
            ////// pouze znak ) - další znaky netřeba
            else if(c == ')') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                return right_parent;
            }
            ////// pouze znak { - další znaky netřeba
            else if(c == '{') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                return left_braces;
            }
            ////// pouze znak } - další znaky netřeba
            else if(c == '}') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                return right_braces;
            }
            ////// znak děleno || začátek komentáře
            else if(c == ',') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                return comma;
            }
            ////// pouze středník - další znaky netřeba
            else if(c == ';') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                return semicolon;
            }
            else if(isspace(c)==0) {
                return LEX_ERR;
            }
            else {
                if(first)
                    return SYNT_ERR;
            }
            break;

        //////////////////
        ////// Identifikátor
        case identificator:
            if(isalpha(c) || isdigit(c) || c == '_') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
            }
            else {
                ungetc(c,f);
                int id = 0;
                if((id = is_keyword(str->strg))!=RET_ERR) {
                    return id;
                }
                else if((id = is_type(str->strg))!=RET_ERR) {
                    return id;
                }
                else if((id = is_const(str->strg))!=RET_ERR) {
                    return id;
                }
                else {
                    return identificator;
                }
            }
            break;

        //////////////////
        ////// Proměnná
        case variable:
            if(must_be_next) {
                if(isalpha(c) || c == '_') {
                    if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                    must_be_next = false;
                }
                else
                    return LEX_ERR;
            }
            else {
                if(isalpha(c) || isdigit(c) || c == '_') {
                    if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                }
                else {
                    ungetc(c,f);
                    return variable;
                }
            }
            break;

        //////////////////
        ////// Řetězcový literál
        case string_literal:
            if(c > 31) {
                if(c == '\\') {
                    c=fgetc(f);
                    if(c == '"') {
                        if((ret = add_string(str,'\"')) == RET_ERR) return RET_ERR;
                    }
                    else if(c == 'n') {
                        if((ret = add_string(str,'\n')) == RET_ERR) return RET_ERR;
                    }
                    else if(c == '$') {
                        if((ret = add_string(str,'$')) == RET_ERR) return RET_ERR;
                    }
                    else if(c == 't') {
                        if((ret = add_string(str,'\t')) == RET_ERR) return RET_ERR;
                    }
                    else if(c == '\\') {
                        if((ret = add_string(str,'\\')) == RET_ERR) return RET_ERR;
                    }
                    else if(c == 'x') {
                        hex[0]=fgetc(f);
                        if(hex[0] == EOF)
                            return LEX_ERR;
                        else if(hex[0] == '\"') {
                            if((ret = add_string(str,'\\')) == RET_ERR) return RET_ERR;
                            if((ret = add_string(str,'x')) == RET_ERR) return RET_ERR;
                            return string_literal;
                        }
                        else if(hex[0] > 31) {
                            if(((hex[0]>'f') || (hex[0]<'a')) && ((hex[0]>'F') || (hex[0]<'A')) && ((hex[0]>'9') || (hex[0]<'0'))) {
                                if((ret = add_string(str,'\\')) == RET_ERR) return RET_ERR;
                                if((ret = add_string(str,'x')) == RET_ERR) return RET_ERR;
                                ungetc(hex[0],f);
                            }
                            else {
                                hex[1]=fgetc(f);
                                if(hex[1] == EOF)
                                    return LEX_ERR;
                                else if(hex[1] == '\"') {
                                    if((ret = add_string(str,'\\')) == RET_ERR) return RET_ERR;
                                    if((ret = add_string(str,'x')) == RET_ERR) return RET_ERR;
                                    if((ret = add_string(str,hex[0])) == RET_ERR) return RET_ERR;
                                    return string_literal;
                                }
                                else if(hex[1] > 31) {
                                    if(((hex[1]>'f') || (hex[1]<'a')) && ((hex[1]>'F') || (hex[1]<'A')) && ((hex[1]>'9') || (hex[1]<'0'))) {
                                        if((ret = add_string(str,'\\')) == RET_ERR) return RET_ERR;
                                        if((ret = add_string(str,'x')) == RET_ERR) return RET_ERR;
                                        ungetc(hex[0],f);
                                        ungetc(hex[1],f);

                                    }
                                    else {
                                        char* end = NULL;
                                        int pomoc = strtol(hex,&end,16);
                                        if(pomoc!=0 && *end == '\0') {
                                            if((ret = add_string(str,pomoc)) == RET_ERR) return RET_ERR;
                                        }

                                    }
                                }
                                else {
                                    return LEX_ERR;
                                }
                            }
                        }
                        else {
                            return LEX_ERR;
                        }
                    }
                    else if(c>31) {
                        ungetc(c,f);
                        c='\\';
                        if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                    }
                    else
                        return LEX_ERR;
                }
                else if(c == '"') {
                    return string_literal;
                }
                else if(c == '$') {
                    return LEX_ERR;
                }
                else {
                    if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                }
            }
            else
                return LEX_ERR;
            break;

        //////////////////
        ////// Číslo
        case int_num:
            if(isdigit(c)) {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
            }
            else if(c=='.') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                state = double_num;
                must_be_next = true;
            }
            else if(c=='e'||c=='E') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                must_be_next = true;
                state = double_num_exp;
                c=fgetc(f);
                if(c=='-' || c=='+') {
                    if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                }
                else
                    ungetc(c,f);
            }
            else {
                ungetc(c,f);
                return int_num;
            }
            break;
        ////// desetinné číslo
        case double_num:
            if(must_be_next) {
                if(isdigit(c)) {
                    if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                    must_be_next = false;
                }
                else {
                    return LEX_ERR;
                }
            }
            else {
                if(isdigit(c)) {
                    if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                    must_be_next = false;
                }
                else if(c=='e'||c=='E') {
                    if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                    state = double_num_exp;
                    c=fgetc(f);
                    must_be_next = true;
                    if(c=='-' || c=='+') {
                        if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                    }
                    else
                        ungetc(c,f);
                }
                else {
                    ungetc(c,f);
                    return double_num;
                }
            }
            break;
        ////// desetinné číslo
        case double_num_exp:
            if(must_be_next) {
                if(isdigit(c)) {
                    if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                    must_be_next = false;
                }
                else {
                    return LEX_ERR;
                }
            }
            else {
                if(isdigit(c)) {
                    if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                }
                else {
                    ungetc(c,f);
                    return double_num;
                }
            }
            break;

        //////////////////
        ////// Rovno
        case equal:
            if(c == '=') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                c=fgetc(f);
                if(c == '=') {
                    if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                    return equal;
                }
                else {
                    ungetc(c,f);
                    return LEX_ERR;
                }
            }
            else {
                ungetc(c,f);
                return assign;
            }
            break;

        //////////////////
        ////// Nerovno
        case not_equal:
            if(c == '=') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                c=fgetc(f);
                if(c == '=') {
                    if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                    return not_equal;
                }
                else {
                    ungetc(c,f);
                    return LEX_ERR;
                }
            }
            else {
                ungetc(c,f);
                return LEX_ERR;
            }
            break;

        //////////////////
        ////// Větší či většíRovno
        case greater:

            if(c == '=') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                return greater_equal;
            }
            else {
                ungetc(c,f);
                return greater;
            }
            break;

        //////////////////
        ////// Menší či menšíRovno
        case less:
            if(c == '=') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                return less_equal;
            }
            else if(c == '?') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                state=php_entry;
            }
            else {
                ungetc(c,f);
                return less;
            }
            break;

        case php_entry:
            if(c == 'p') {
                if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                c=fgetc(f);
                if(c == 'h') {
                    if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                    c=fgetc(f);
                    if(c == 'p') {
                        if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                        c=fgetc(f);
                        if(c==EOF) {
                            return php_entry_wrong;
                        }
                        else  if(isspace(c)) {
                            c=fgetc(f);
                            if(c==EOF) {
                                return php_entry_wrong;
                            }
                            ungetc(c,f);
                            if((ret = add_string(str,c)) == RET_ERR) return RET_ERR;
                            first = false;
                            return php_entry;
                        }

                        else {
                            first = false;
                            return php_entry;
                        }
                    }
                    else {
                        return LEX_ERR;
                    }
                }
                else {
                    return LEX_ERR;
                }
            }
            else {
                ungetc(c,f);
                return LEX_ERR;
            }
            break;
        //////////////////
        ////// Komentáře
        case comment:
            if(c == '/') {
                while((c=fgetc(f)) != EOF) {
                    if(c=='\n')
                        break;
                }
                del_string(str);
                state = start;
            }
            else if(c=='*') {
                while((c=fgetc(f)) != EOF) {
                    if(c=='*') {
                        if((c=fgetc(f)) == '/') {
                            state = start;
                            del_string(str);
                            break;
                        }
                        else
                            ungetc(c,f);
                    }
                }
                if(c==EOF && state==comment)
                    return LEX_ERR;

            }
            else {
                ungetc(c,f);
                return divide;
            }
            break;
        }
    }
    return EOF;
}
Esempio n. 28
0
void num_vars(void)
/*  Numeriert Variablen und erzeugt Indexliste  */
{
    unsigned int i,j,done;struct IC *p;struct Var *v,*a[4],*vp;
    unsigned long heapsize=0;
    if(DEBUG&1024) printf("numerating variables loop1\n");
    inr++;
    /*  alle Indizes auf -1 */
    a[0]=vl0;
    a[1]=vl1;
    a[2]=vl2;
    a[3]=vl3;
#if 1
    for(j=0;j<4;j++){
        v=a[j];
        while(v){
            v->index=-1;
            /*  Variablen von inline-Funktionen */
            if(j==0&&v->fi&&v->fi->first_ic){
                for(vp=v->fi->vars;vp;vp=vp->next) vp->index=-1;
            }
            v=v->next;
        }
    }
    /* variables that may be referenced in inter-proc. dflow-info */
    for(p=first_ic;p;p=p->next){
      if(p->code==CALL&&(p->q1.flags&VAR)&&p->q1.v->fi){
	struct function_info *fi=p->q1.v->fi;
	if(fi->flags&ALL_USES){
	  for(i=0;i<fi->use_cnt;i++){
	    if(v=fi->use_list[i].v) fi->use_list[i].v->index=-1;
	  }
	}
	if(fi->flags&ALL_MODS){
	  for(i=0;i<fi->change_cnt;i++){
	    if(v=fi->change_list[i].v) fi->change_list[i].v->index=-1;
	  }
	}
      }
      /* const-lists */
      if((p->q1.flags&VAR))
	if(p->q1.v->clist&&is_const(p->q1.v->vtyp)) num_clist_refs(-1,p->q1.v->vtyp,p->q1.v->clist);
      if((p->q2.flags&VAR))
	if(p->q2.v->clist&&is_const(p->q2.v->vtyp)) num_clist_refs(-1,p->q2.v->vtyp,p->q2.v->clist);
      if((p->z.flags&VAR))
	if(p->z.v->clist&&is_const(p->z.v->vtyp)) num_clist_refs(-1,p->z.v->vtyp,p->z.v->clist);
    }
#endif
    /* Do we need this? */
    for(p=first_ic;p;p=p->next){
      if(p->q1.flags&VAR) {p->q1.v->index=-1;p->q1.v->flags&=~USEDASADR;}
      if(p->q2.flags&VAR) {p->q2.v->index=-1;p->q2.v->flags&=~USEDASADR;}
      if(p->z.flags&VAR) {p->z.v->index=-1;p->z.v->flags&=~USEDASADR;}
    }
    /*  erst alle Variablen, die als DREFOBJ benutzt werden */
    if(DEBUG&1024) printf("numerating variables loop2\n");
    i=0;
    do{
      done=1;
      if(DEBUG&1024) printf("pass\n");
      for(p=first_ic;p;p=p->next){
        if(p->code<LABEL||p->code>BRA){
	  int c=p->code;
	  /* mark variables ad USEDASADR */
	  if(c==ADDRESS) p->q1.v->flags|=USEDASADR;
	  if(p->q1.flags&VARADR) p->q1.v->flags|=USEDASADR;
	  if(p->q2.flags&VARADR) p->q2.v->flags|=USEDASADR;
	  if(p->z.flags&VARADR) p->z.v->flags|=USEDASADR;
	  j=(q1typ(p)&NQ);
	  if((p->q1.flags&(VAR|DREFOBJ))==(VAR|DREFOBJ)){
	    v=p->q1.v;
	    if(!v->vtyp->next||(v->vtyp->next->flags&NQ)!=j) v->flags|=DNOTTYPESAFE;
	    if(v->index<0) {v->index=i++;v->inr=inr;done=0;}
	  }
	  j=(q2typ(p)&NQ);
	  if((p->q2.flags&(VAR|DREFOBJ))==(VAR|DREFOBJ)){
	    v=p->q2.v;
	    if(!v->vtyp->next||(v->vtyp->next->flags&NQ)!=j) v->flags|=DNOTTYPESAFE;
	    if(v->index<0) {v->index=i++;v->inr=inr;done=0;}
	  }
	  j=(ztyp(p)&NQ);
	  if((p->z.flags&(VAR|DREFOBJ))==(VAR|DREFOBJ)){
	    v=p->z.v;
	    if(!v->vtyp->next||(v->vtyp->next->flags&NQ)!=j) v->flags|=DNOTTYPESAFE;
	    if(v->index<0) {v->index=i++;v->inr=inr;done=0;}
	  }
	  /* mark copies from DREFs also as DREFs (necessary?) (check z for !DREFOBJ?) */
	  if((c==ASSIGN||c==ADDI2P||c==SUBIFP)&&(p->q1.flags&VAR)&&p->q1.v->index>=0&&(p->z.flags&VAR)&&p->z.v->index<0){
	    if(!(p->z.flags&VAR)) ierror(0);
	    p->z.v->index=i++;p->z.v->inr=inr;done=0;
	  }
	  /* mark copies to DREFs as DREFs (because of copy-propagation */
	  /* and post-op reordering */
	  if((c==ASSIGN||c==ADDI2P||c==SUBIFP)&&(p->z.flags&VAR)&&p->z.v->index>=0&&(p->q1.flags&VAR)&&p->q1.v->index<0){
	    p->q1.v->index=i++;p->q1.v->inr=inr;done=0;
	  }	  
        }
      }
    }while(!done);
    if(DEBUG&1024) printf("numerating variables loop3\n");
    rcount=i;    /*  Anzahl der DREFOBJ-Variablen    */
    /*  jetzt den Rest  */
    for(p=first_ic;p;p=p->next){
        int c=p->code;
        if(1/*p->code<LABEL||p->code>BRA*/){
            if((p->q1.flags&(VAR|DREFOBJ))==VAR){
	      j=(q1typ(p)&NQ);
	      v=p->q1.v;
	      if((v->vtyp->flags&NQ)!=j) v->flags|=NOTTYPESAFE;
	      if(v->index<0) {v->index=i++;v->inr=inr;}
            }
            if((p->q2.flags&(VAR|DREFOBJ))==VAR){
	      j=(q2typ(p)&NQ);
	      v=p->q2.v;
	      if((v->vtyp->flags&NQ)!=j) v->flags|=NOTTYPESAFE;
	      if(v->index<0) {v->index=i++;v->inr=inr;}
            }
            if((p->z.flags&(VAR|DREFOBJ))==VAR){
	      j=(ztyp(p)&NQ);
	      v=p->z.v;
	      if((v->vtyp->flags&NQ)!=j) v->flags|=NOTTYPESAFE;
	      if(v->index<0) {v->index=i++;v->inr=inr;}
            }
        }
	/* const-lists */
	if((p->q1.flags&VAR))
	  if(p->q1.v->clist&&is_const(p->q1.v->vtyp)) {clcnt=i;num_clist_refs(0,p->q1.v->vtyp,p->q1.v->clist);i=clcnt;}
	if((p->q2.flags&VAR))
	  if(p->q2.v->clist&&is_const(p->q2.v->vtyp)) {clcnt=i;num_clist_refs(0,p->q2.v->vtyp,p->q2.v->clist);i=clcnt;}
	if((p->z.flags&VAR))
	  if(p->z.v->clist&&is_const(p->z.v->vtyp)) {clcnt=i;num_clist_refs(0,p->z.v->vtyp,p->z.v->clist);i=clcnt;}
    }
    if(DEBUG&1024) printf("numerating variables loop4\n");
    vcount=i+rcount; /*  alle benutzten Variablen+Anzahl der DREFOBJs    */
    vilist=mymalloc(vcount*sizeof(struct Var *));
    heapsize+=vcount*sizeof(struct Var *);
#if 0
    for(j=0;j<4;j++){
        int i;
        v=a[j];
        while(v){
            i=v->index;
/*            printf("%s has index %d\n",v->identifier,i);*/
            if(i>=0){
                if(i>=vcount-rcount) ierror(0);
                vilist[i]=v;
                if(i<rcount) vilist[i+vcount-rcount]=v;
            }
            /*  Variablen von inline-Funktionen */
            if(j==0&&v->fi&&v->fi->first_ic){
                for(vp=v->fi->vars;vp;vp=vp->next){
                    i=vp->index;
                    if(i>=0){
                        if(i>=vcount-rcount) ierror(0);
                        vilist[i]=vp;
                        if(i<rcount) vilist[i+vcount-rcount]=vp;
                    }
                }
            }
            v=v->next;
        }
    }
#endif

    for(p=first_ic;p;p=p->next){
      struct Var *v;
      if(p->q1.flags&VAR){
	i=p->q1.v->index;
	vilist[i]=v=p->q1.v;
	if(v->clist&&is_const(v->vtyp)) num_clist_refs(1,v->vtyp,v->clist);
      }
      if(p->q2.flags&VAR){
	i=p->q2.v->index;
	vilist[i]=v=p->q2.v;
	if(v->clist&&is_const(v->vtyp)) num_clist_refs(1,v->vtyp,v->clist);

      }
      if(p->z.flags&VAR){
	i=p->z.v->index;
	vilist[i]=v=p->z.v;
	if(v->clist&&is_const(v->vtyp)) num_clist_refs(1,v->vtyp,v->clist);
      }
    }
    for(i=0;i<rcount;i++)
      vilist[i+vcount-rcount]=vilist[i];

    /*vsize=(vcount+CHAR_BIT-1)/CHAR_BIT;*/
    vsize=BVSIZE(vcount);
    if(DEBUG&(16384|1024)) printf("%lu variables (%lu DREFOBJs), vsize=%lu\n",(unsigned long)vcount,(unsigned long)rcount,(unsigned long)vsize);

    av_drefs=mymalloc(vsize);
    memset(av_drefs,0,vsize);
    /*  alle DREFOBJs   */
    for(i=vcount-rcount;i<vcount;i++) BSET(av_drefs,i);

    /*  av_globals enthaelt alle globalen Variablen und av_address      */
    /*  zusaetzlich noch alle Variablen, deren Adressen genommen wurden */
    av_globals=mymalloc(vsize);
    memset(av_globals,0,vsize);
    av_statics=mymalloc(vsize);
    memset(av_statics,0,vsize);
    av_address=mymalloc(vsize);
    memcpy(av_address,av_globals,vsize);
    heapsize+=4*vsize;
    for(i=0;i<vcount-rcount;i++){
        if(vilist[i]->nesting==0||vilist[i]->storage_class==EXTERN) BSET(av_globals,i);
        if(vilist[i]->flags&USEDASADR) BSET(av_address,i);
        if(vilist[i]->storage_class==STATIC) BSET(av_statics,i);
        if(i<rcount){
/*            if(!ISPOINTER(vilist[i]->vtyp->flags)){ printf("%s(%ld)\n",vilist[i]->identifier,zm2l(vilist[i]->offset));ierror(0);}*/
            BSET(av_address,i+vcount-rcount);
            BSET(av_globals,i+vcount-rcount);
        }
    }
    if(DEBUG&16384) printf("num_vars heapsize=%lu\n",heapsize);
}
Esempio n. 29
0
lirc_t emulation_readdata(lirc_t timeout)
{
	static lirc_t sum = 0;
	lirc_t data = 0;

	if(current_code == NULL)
	{
		data = 1000000;
		if(next_code)
		{
			current_code = next_code;
		}
		else
		{
			current_code = emulation_data->codes;
		}
		current_rep = 0;
		sum = 0;
	}
	else
	{
		if(current_code->name == NULL)
		{
			fprintf(stderr, "%s: %s no data found\n",
				progname, emulation_data->name);
			data = 0;
		}
		if(current_index >= current_code->length)
		{
			if(next_code)
			{
				current_code = next_code;
			}
			else
			{
				current_rep++;
				if(current_rep > 2)
				{
					current_code++;
					current_rep = 0;
					data = 1000000;
				}
			}
			current_index = 0;
			if(current_code->name == NULL)
			{
				current_code = NULL;
				return emulation_readdata(timeout);
			}
			if(data == 0)
			{
				if(is_const(emulation_data))
				{
					data = emulation_data->gap - sum;
				}
				else
				{
					data = emulation_data->gap;
				}
			}

			sum = 0;
		}
		else
		{
			data = current_code->signals[current_index];
			if((current_index % 2) == 0)
			{
				data |= PULSE_BIT;
			}
			current_index++;
			sum += data&PULSE_MASK;
		}
	}
	/*
	printf("delivering: %c%u\n", data&PULSE_BIT ? 'p':'s',
	data&PULSE_MASK);
	*/
	return data;
}
char *get_token(char *lexeme , int mode){
	char *token=(char*)calloc(strlen(lexeme)+50,sizeof(char));
	//printf("Getting token\n");
	if(is_long(lexeme)){
		sprintf(token,"%d",LONG);
	}
	else if(is_static(lexeme)){
		sprintf(token,"%d",STATIC);
	}
	else if(is_union(lexeme)){
		sprintf(token,"%d",UNION);
	}
	else if(is_default(lexeme)){
		sprintf(token,"%d",DEFAULT);
	}
	else if(is_break(lexeme)){
		sprintf(token,"%d",BREAK);
	}
	else if(is_case(lexeme)){
		sprintf(token,"%d",CASE);
	}
	else if(is_continue(lexeme)){
		sprintf(token,"%d",CONTINUE);
	}
	else if(is_goto(lexeme)){
		sprintf(token,"%d",GOTO);
	}
	else if(is_struct(lexeme)){
		sprintf(token,"%d",STRUCT);
	}
	else if(is_const(lexeme)){
		sprintf(token,"%d",CONST);
	}
	else if(is_void(lexeme)){
		sprintf(token,"%d",VOID);
	}
	else if(is_switch(lexeme)){
		sprintf(token,"%d",SWITCH);
	}
	else if(is_for(lexeme)){
		sprintf(token,"%d",FOR);
	}
	else if(is_while(lexeme)){
		sprintf(token,"%d",WHILE);
	}
	else if(is_do(lexeme)){
		sprintf(token,"%d",DO);
	}
	else if(is_return(lexeme)){
		sprintf(token,"%d",RETURN);
	}
	else if(is_bool(lexeme)){
		sprintf(token,"%d",BOOL);
	}
	else if(is_char(lexeme)){
		sprintf(token,"%d",CHAR);
	}
	else if(is_signed(lexeme)){
		sprintf(token,"%d",SIGNED);
	}
	else if(is_unsigned(lexeme)){
		sprintf(token,"%d",UNSIGNED);
	}
	else if(is_short(lexeme)){
		sprintf(token,"%d",SHORT);
	}
	else if(is_int(lexeme)){
		sprintf(token,"%d",INT);
	}
	else if(is_float(lexeme)){
		sprintf(token,"%d",FLOAT);
	}
	else if(is_double(lexeme)){
		sprintf(token,"%d",DOUBLE);
	}
	else if(is_l_square(lexeme)){
		sprintf(token,"%d",L_SQUARE);
	}
	else if(is_r_square(lexeme)){
		sprintf(token,"%d",R_SQUARE);
	}
	else if(is_l_paraen(lexeme)){
		sprintf(token,"%d",L_PARAEN);
	}
	else if(is_r_paraen(lexeme)){
		sprintf(token,"%d",R_PARAEN);
	}
	else if(is_l_cbrace(lexeme)){
		sprintf(token,"%d",L_CBRACE);
	}
	else if(is_r_cbrace(lexeme)){
		sprintf(token,"%d",R_CBRACE);
	}
	else if(is_comma(lexeme)){
		sprintf(token,"%d",COMMA);
	}
	else if(is_semicol(lexeme)){
		sprintf(token,"%d",SEMICOL);
	}
	else if(is_eq_eq(lexeme)){
		sprintf(token,"%d",EQ_EQ);
	}
	else if(is_lesser(lexeme)){
		sprintf(token,"%d",LESSER);
	}
	else if(is_less_eq(lexeme)){
		sprintf(token,"%d",LESS_EQ);
	}
	else if(is_div(lexeme)){
		sprintf(token,"%d",DIV);
	}
	else if(is_greater(lexeme)){
		sprintf(token,"%d",GREATER);
	}
	else if(is_great_eq(lexeme)){
		sprintf(token,"%d",GREAT_EQ);
	}
	else if(is_plus_eq(lexeme)){
		sprintf(token,"%d",PLUS_EQ);
	}
	else if(is_minus_eq(lexeme)){
		sprintf(token,"%d",MINUS_EQ);
	}
	else if(is_div_eq(lexeme)){
		sprintf(token,"%d",DIV_EQ);
	}
	else if(is_mult_eq(lexeme)){
		sprintf(token,"%d",MULT_EQ);
	}
	else if(is_minus_minus(lexeme)){
		sprintf(token,"%d",MINUS_MINUS);
	}
	else if(is_plus_plus(lexeme)){
		sprintf(token,"%d",PLUS_PLUS);
	}
	else if(is_percent(lexeme)){
		sprintf(token,"%d",PERCENT);
	}
	else if(is_div(lexeme)){
		sprintf(token,"%d",DIV);
	}
	else if(is_mult(lexeme)){
		sprintf(token,"%d",MULT);
	}
	else if(is_minus(lexeme)){
		sprintf(token,"%d",MINUS);
	}
	else if(is_plus(lexeme)){
		sprintf(token,"%d",PLUS);
	}
	else if(is_int_const(lexeme)){
		printf("int");
		sprintf(token,"%d\t%s",INT_CONST,lexeme);
	}
	else if(is_flo_const(lexeme)){
		printf("float");
		sprintf(token,"%d\t%s",FLO_CONST,lexeme);
	}
	else if(is_comment_start(lexeme)){
		sprintf(token,"$start");
	}
	else if(is_comment_end(lexeme)){
		sprintf(token,"$end");
	}
	else if(is_identifier(lexeme)){
		printf("Identifier");
		if(mode==1) ht_set( symboltable, lexeme, "1");
		sprintf(token,"%d\t%s",IDNTIFIER,lexeme);
	}
	else sprintf(token,"%d",NOTOK);
	return token;
}