예제 #1
0
//Finds the set of all types that are subtypes of a and b.
//Note that this version assumes we have the transitive closure
polytype intersect_types(polytype a, polytype b) {
    polytype_dynarray result = polytype_dynarray_make(1);

    //Handle special cases where either a or b are "Any"
    if (is_any(a)) {
        return b;
    }
    if (is_any(b)) {
        return a;
    }

    //Is A possibly a subtype of B?
    if (Type_graph_possiblesubtype(UniverseGraph, a, b)) {
        //it is. Check if A __is__ B (trivially -- is it exactly the same?)
        if (polytype_trivial_eq(a, b)) {
            //Great, they're both the same. Add one to the result and return
            return a;
        }
        else {
            //Since A is possibly a subtype of B, but A is not B,
            //we should be able to find A somewhere under B. 
            //To do so, instantiate B's subtypes in the lattice and recurse
            //by restricting the set of B's subtypes by A.
            typeslot_dynarray b_subtypes = polytype_get_subtypes(b);
            //TODO: Eliminate the instantiation going on here
            return restrict_type(typeslot_dynarray_instantiate(b_subtypes), a);
        }
    }
    //A cannot subtype B
    //Check if A's children do so instead.
    //TODO: Remove instantiation going on here
    return restrict_type(typeslot_dynarray_instantiate(polytype_get_subtypes(a)), b);
}
예제 #2
0
	void get_available_address_v4(io_service& ios,std::set<address>& addrs)
	{
		addrs.clear();

		error_code ec;
		std::vector<ip_interface>  interfaces=enum_net_interfaces(ios,ec);
		address realBindAddr;
		for(std::size_t i=0;i<interfaces.size();++i)
		{
			if(is_loopback(interfaces[i].interface_address)
				||is_any(interfaces[i].interface_address)
				||interfaces[i].interface_address.is_v6()
				)
			{
				continue;
			}
			//test can we bind this port
			endpoint edp(interfaces[i].interface_address,0);
			boost::asio::ip::tcp::socket tcpSocket(ios);
			tcpSocket.open(boost::asio::ip::tcp::v4(),ec);
			tcpSocket.bind(edp,ec);
			if (!ec&&!is_any(realBindAddr=tcpSocket.local_endpoint(ec).address()))
			{
				addrs.insert(realBindAddr);
			}
			else
			{
				addrs.erase(realBindAddr);
			}
			tcpSocket.close(ec);
		}
	}
예제 #3
0
파일: anal_riscv.c 프로젝트: bydo/radare2
static int riscv_op(RAnal *anal, RAnalOp *op, ut64 addr, const ut8 *data, int len)
{
    const int no_alias = 1;
    struct riscv_opcode *o = NULL;
    insn_t word = 0;
    int xlen = anal->bits;

    op->size = 4;
    op->addr = addr;
    op->type = R_ANAL_OP_TYPE_UNK;

    memcpy (&word, data, 4);
    o = get_opcode (word);
    if (o == NULL) {
        return op->size;
    }

    for(; o < &riscv_opcodes[NUMOPCODES]; o++) {
        if ( !(o->match_func)(o, word) ) continue;
        if ( no_alias && (o->pinfo & INSN_ALIAS) ) continue;
        if ( isdigit (o->subset[0]) && atoi (o->subset) != xlen) continue;
        else break;
    }
#define is_any(...) _is_any(NARGS(__VA_ARGS__), o->name, __VA_ARGS__)

// branch/jumps/calls/rets
    if (is_any ("jal")) {
        // decide wether it's ret or call
        int rd = (word >> OP_SH_RD) & OP_MASK_RD;
        op->type = (rd == 0) ? R_ANAL_OP_TYPE_RET : R_ANAL_OP_TYPE_CALL;
        op->jump = EXTRACT_UJTYPE_IMM (word) + addr;
        op->fail = addr + 4;
    } else if(is_any ("jr")) {
예제 #4
0
/** \brief Return true if the ip_addr_t is said 'fully_qualified'
 */
bool	ip_addr_t::is_fully_qualified()	const throw()
{
	if( is_null() )		return false;
	if( is_any() )		return false;
	if( is_multicast() )	return false;
	if( is_broadcast() )	return false;
	return true;
}
예제 #5
0
파일: var.hpp 프로젝트: chinnurtb/eixx
 bool subst(eterm<Alloc>& out, const varbind<Alloc>* binding) const
     throw (err_unbound_variable) {
     if (is_any()) throw err_unbound_variable(c_str());
     const eterm<Alloc>* term = binding ? binding->find(c_str()) : NULL;
     if (!term) throw err_unbound_variable(c_str());
     out = *term;
     return true;
 }
예제 #6
0
	tcp::endpoint utp_socket_manager::local_endpoint(address const& remote, error_code& ec) const
	{
		tcp::endpoint socket_ep = m_sock.local_endpoint(ec);

		// first enumerate the routes in the routing table
		if (time_now() - m_last_route_update > seconds(60))
		{
			m_last_route_update = time_now();
			error_code ec;
			m_routes = enum_routes(m_sock.get_io_service(), ec);
			if (ec) return socket_ep;
		}

		if (m_routes.empty()) return socket_ep;
		// then find the best match
		ip_route* best = &m_routes[0];
		for (std::vector<ip_route>::iterator i = m_routes.begin()
			, end(m_routes.end()); i != end; ++i)
		{
			if (is_any(i->destination) && i->destination.is_v4() == remote.is_v4())
			{
				best = &*i;
				continue;
			}

			if (match_addr_mask(remote, i->destination, i->netmask))
			{
				best = &*i;
				continue;
			}
		}

		// best now tells us which interface we would send over
		// for this target. Now figure out what the local address
		// is for that interface

		if (time_now() - m_last_if_update > seconds(60))
		{
			m_last_if_update = time_now();
			error_code ec;
			m_interfaces = enum_net_interfaces(m_sock.get_io_service(), ec);
			if (ec) return socket_ep;
		}

		for (std::vector<ip_interface>::iterator i = m_interfaces.begin()
			, end(m_interfaces.end()); i != end; ++i)
		{
			if (i->interface_address.is_v4() != remote.is_v4())
				continue;

			if (strcmp(best->name, i->name) == 0)
				return tcp::endpoint(i->interface_address, socket_ep.port());
		}
		return socket_ep;
	}
예제 #7
0
파일: var.hpp 프로젝트: chinnurtb/eixx
 bool match(const eterm<Alloc>& pattern, varbind<Alloc>* binding) const
     throw (err_unbound_variable) {
     if (is_any()) return true;
     const eterm<Alloc>* value = binding ? binding->find(c_str()) : NULL;
     if (value)
         return value->match(pattern, binding);
     if (binding != NULL) {
         // Bind the variable
         eterm<Alloc> et;
         binding->bind(name(), pattern.subst(et, binding) ? et : pattern);
     }
     return true; 
 }
예제 #8
0
파일: var.hpp 프로젝트: fredrikelinder/eixx
 bool match(const eterm<Alloc>& pattern, varbind<Alloc>* binding) const
     throw (err_unbound_variable)
 {
     if (is_any()) return true;
     if (!binding) return false;
     const eterm<Alloc>* value = binding->find(name());
     if (value)
         return check_type(value->type()) ? value->match(pattern, binding) : false;
     if (!check_type(pattern.type()))
         return false;
     // Bind the variable
     eterm<Alloc> et;
     binding->bind(name(), pattern.subst(et, binding) ? et : pattern);
     return true; 
 }
예제 #9
0
bool Type::compatible(const Type& type) const {
	if (_types.size() == 0 or type._types.size() == 0) {
		return true;
	}
	if (is_any()) {
		return true;
	}
	if (this->is_primitive() && type.is_polymorphic()) {
		return false;
	}
	if (this->temporary and not type.temporary) {
		return false; // type not compatible with type&&
	}
	if (not this->constant and type.constant) {
		return false; // 'const type' not compatible with 'type'
	}
	if ((is_array() && type.is_array()) || (is_set() && type.is_set()) || (is_map() && type.is_map()) || (is_function() && type.is_function())) {
		return _types[0]->compatible(type._types[0].get());
	}
	if (_types[0] != type._types[0]) {
		// 'Integer' is compatible with 'Float'
		if (this->is_real() and type.is_integer()) {
			return true;
		}
		// 'Boolean' is compatible with 'Integer'
		if (this->is_integer() and type.is_bool()) {
			return true;
		}
		// 'Integer' is compatible with 'Long'
		if (this->is_long() and type.is_integer()) {
			return true;
		}
		// All numbers types are compatible with the base 'Number' type
		if (dynamic_cast<const Number_type*>(_types[0].get()) and (type.is_integer() or type.is_long() or type.is_real())) {
			return true;
		}
		return false;
	}
	return true;
}
예제 #10
0
Type Type::operator * (const Type& t2) const {
	if (_types.size() == 0) {
		return t2;
	}
	if (t2._types.size() == 0) {
		return *this;
	}
	if (*this == t2) {
		return *this;
	}
	if (is_polymorphic() and t2.is_primitive()) {
		return Type::any();
	}
	if (t2.is_polymorphic() and is_primitive()) {
		return Type::any();
	}
	if (is_any()) {
		return t2;
	}
	if (t2.is_any()) {
		return *this;
	}
	// Temporary, to be removed when compatible() is removed
	if ((is_bool() and t2.is_integer()) or (is_integer() and t2.is_bool())) {
		return any();
	}
	if (t2.compatible(*this)) {
		return t2;
	}
	if (compatible(t2)) {
		return *this;
	}
	if (is_array() and t2.is_array()) {
		if (element().is_polymorphic() and t2.element().is_polymorphic()) {
			return array(any());
		}
	}
	return Type::any();
}
예제 #11
0
/* TODO make skip_chars byte* or u8*? */
int read_char(FILE* input, char* skip_chars, int complement, int clear_line)
{
	int c, ret;
	byte tmp;
	c_array skip;
	char* tmp_skip = (skip_chars) ? skip_chars : (char*)"";

	SET_C_ARRAY(skip, (byte*)skip_chars, 1, strlen(tmp_skip));

	do {
		ret = getc(input);
		if (ret == EOF)
			return ret;
		tmp = ret;
		c = is_any(&skip, &tmp, are_equal_uchar);
	} while (!complement && c || complement && !c);

	if (clear_line && ret != '\n')
		do { c = getc(input); } while (c != '\n' && c != EOF);

	return ret;
}
예제 #12
0
static int riscv_op(RAnal *anal, RAnalOp *op, ut64 addr, const ut8 *data, int len) {
	const int no_alias = 1;
	struct riscv_opcode *o = NULL;
	ut64 word = 0;
	int xlen = anal->bits;

	op->size = 4;
	op->addr = addr;
	op->type = R_ANAL_OP_TYPE_UNK;

	word = (len >= sizeof (ut64))? r_read_ble64 (data, anal->big_endian): r_read_ble16 (data, anal->big_endian);

	o = get_opcode (word);
	if (word == UT64_MAX) {
		op->type = R_ANAL_OP_TYPE_ILL;
		return -1;
	}
	if (!o || !o->name) return op->size;

	for (; o < &riscv_opcodes[NUMOPCODES]; o++) {
		// XXX ASAN segfault if ( !(o->match_func)(o, word) ) continue;
		if ( no_alias && (o->pinfo & INSN_ALIAS) ) continue;
		if ( isdigit ((int)(o->subset[0])) && atoi (o->subset) != xlen) continue;
		else {
			break;
		}
	}

	if (!o || !o->name) {
		return -1;
	}
// branch/jumps/calls/rets
	if (is_any ("jal")) {
		// decide wether it's ret or call
		int rd = (word >> OP_SH_RD) & OP_MASK_RD;
		op->type = (rd == 0) ? R_ANAL_OP_TYPE_RET: R_ANAL_OP_TYPE_CALL;
		op->jump = EXTRACT_UJTYPE_IMM (word) + addr;
		op->fail = addr + 4;
	} else if (is_any ("jr")) {
예제 #13
0
char* read_string(FILE* file, char* skip_chars, int delim, size_t max_len)
{
	int tmp;
	byte tmp2;
	char* str = NULL;
	c_array skip;
	str = (skip_chars) ? skip_chars : (char*)"";

	SET_C_ARRAY(skip, (byte*)skip_chars, 1, strlen(str));

	do {
		tmp = getc(file);
		if (tmp == EOF)
			return NULL;
		tmp2 = tmp;
	} while (is_any(&skip, &tmp2, are_equal_uchar));
	ungetc(tmp, file);
	do {
		str = freadstring(file, delim, max_len);
	} while (!str);

	return str;
}
예제 #14
0
	bool ip_voter::cast_vote(address const& ip
		, int source_type, address const& source)
	{
		if (is_any(ip)) return false;
		if (is_local(ip)) return false;
		if (is_loopback(ip)) return false;

		// don't trust source that aren't connected to us
		// on a different address family than the external
		// IP they claim we have
		if (ip.is_v4() != source.is_v4()) return false;

		// this is the key to use for the bloom filters
		// it represents the identity of the voter
		sha1_hash k;
		hash_address(source, k);

		// do we already have an entry for this external IP?
		std::vector<external_ip_t>::iterator i = std::find_if(m_external_addresses.begin()
			, m_external_addresses.end(), boost::bind(&external_ip_t::addr, _1) == ip);

		if (i == m_external_addresses.end())
		{
			// each IP only gets to add a new IP once
			if (m_external_address_voters.find(k)) return maybe_rotate();
		
			if (m_external_addresses.size() > 40)
			{
				if (random() % 100 < 50)
					return maybe_rotate();

				// use stable sort here to maintain the fifo-order
				// of the entries with the same number of votes
				// this will sort in ascending order, i.e. the lowest
				// votes first. Also, the oldest are first, so this
				// is a sort of weighted LRU.
				std::stable_sort(m_external_addresses.begin(), m_external_addresses.end());

				// erase the last element, since it is one of the
				// ones with the fewest votes
				m_external_addresses.erase(m_external_addresses.end() - 1);
			}
			m_external_addresses.push_back(external_ip_t());
			i = m_external_addresses.end() - 1;
			i->addr = ip;
		}
		// add one more vote to this external IP
		if (!i->add_vote(k, source_type)) return maybe_rotate();
		++m_total_votes;
		
		if (m_valid_external) return maybe_rotate();

		i = std::min_element(m_external_addresses.begin(), m_external_addresses.end());
		TORRENT_ASSERT(i != m_external_addresses.end());

		if (i->addr == m_external_address) return maybe_rotate();

		if (m_external_address != address_v4())
		{
			// we have a temporary external address. As soon as we have
			// more than 25 votes, consider deciding which one to settle for
			return (m_total_votes >= 25) ? maybe_rotate() : false;
		}

		m_external_address = i->addr;

		return true;
	}
예제 #15
0
파일: Type.cpp 프로젝트: mfichman/jogo
bool Type::is_alt() const {
    return is_union() || is_any();
}
예제 #16
0
bool Type::can_be_container() const {
	return is_any() or is_placeholder() or std::any_of(begin(_types), end(_types), [](auto& type) {
		return type->is_container();
	});
}
예제 #17
0
	bool is_7bit() const
		{ return is_any() && !is_14bit(); }
예제 #18
0
파일: var.hpp 프로젝트: fredrikelinder/eixx
 bool check_type(eterm_type t) const {
     return is_any() || m_type == UNDEFINED || t == m_type;
 }
예제 #19
0
bool Type::can_be_numeric() const {
	return is_any() or can_be_bool() or can_be_number();
}
예제 #20
0
bool Type::can_be_callable() const {
	return is_any() or (_types.size() and some([&](std::shared_ptr<const Base_type> t) {
		return t->callable();
	}));
}
예제 #21
0
void bBoard::process(bFpsTimer * fps)
{
    guard(bBoard::process);
    
    BASSERT( fps != NULL );
    
    for( int i=0; i<ball_size; ++i ) {
        ball[i]->process( fps->factor() );
    }
    
    // find and mark balls with collisions
    for( int i=0; i<ball_size; ++i ) {
        for( int k=0; k<band_size; ++k ) {
            bBand::band_piece bp;
            if( (bp = band[k]->is_within( ball[i]->pos, ball[i]->radius )) != bBand::bNone ) {
                if( bp == bBand::bSide ) {
                    luband.set( i, k, 1);
                } else {
                    luband.set( i, k, bp==bBand::bEdge1?2:3);
                }
            }
        }
        for( int j=0; j<i; ++j ) {
            if( ball[i]->collides( ball[j] ) ) {
                luball.set( i, j, 1 );
            }
        }
    }
    
    // move backwards balls with collision(s)
    for( int i=0; i<ball_size; ++i ) {
        if( is_any(i) ) {
            ball[i]->unprocess( fps->factor() );
        }
    }
    
   
    Profiler.begin( "ball_mgr::reflections" );
    
    // calculate new velocity vectors 
    // (but no commit - one change changes next calculation result!)
    commit_reflections();
    
    Profiler.end( "ball_mgr::reflections" );
    
    luball.clear();
    luband.clear();
    
    for( int i=0; i<ball_size; ++i ) {
        // apply velocity vector changes
        ball[i]->commit_v();
/*        ball[i]->process( fps->factor() );
        for( int k=0; k<band_size; ++k ) {
        if( band[k]->is_within( ball[i]->pos, ball[i]->radius ) != bBand::bNone ) {
        ball[i]->unprocess( fps->factor() );
    }
    }
        for( int j=0; j<i; ++j ) {
        if( ball[i]->collides( ball[j] ) ) {
        ball[i]->unprocess( fps->factor() );
    }
    }*/
    }
    
    unguard;
}
예제 #22
0
파일: var.hpp 프로젝트: chinnurtb/eixx
 std::ostream& dump(std::ostream& out, const varbind<Alloc>* binding = NULL) const {
     if (is_any()) { return out << c_str(); }
     const eterm<Alloc>* term = binding ? binding->find(name()) : NULL;
     return out << (term ? term->to_string(std::string::npos, binding) : *this);
 }
예제 #23
0
파일: var.hpp 프로젝트: chinnurtb/eixx
 const eterm<Alloc>*
 find_unbound(const varbind<Alloc>* binding = NULL) const {
     if (is_any()) return NULL;
     return binding ? binding->find(c_str()) : NULL;
 }