Ejemplo n.º 1
0
Archivo: util.cpp Proyecto: cpehle/lean
void get_rec_args(environment const & env, name const & n, buffer<buffer<bool>> & r) {
    lean_assert(inductive::is_inductive_decl(env, n));
    type_checker tc(env);
    name_generator ngen;
    declaration ind_decl   = env.get(n);
    declaration rec_decl   = env.get(inductive::get_elim_name(n));
    unsigned nparams       = *inductive::get_num_params(env, n);
    unsigned nminors       = *inductive::get_num_minor_premises(env, n);
    unsigned ntypeformers  = *inductive::get_num_type_formers(env, n);
    buffer<expr> rec_args;
    to_telescope(ngen, rec_decl.get_type(), rec_args);
    buffer<name> typeformer_names;
    for (unsigned i = nparams; i < nparams + ntypeformers; i++) {
        typeformer_names.push_back(mlocal_name(rec_args[i]));
    }
    lean_assert(typeformer_names.size() == ntypeformers);
    r.clear();
    // add minor premises
    for (unsigned i = nparams + ntypeformers; i < nparams + ntypeformers + nminors; i++) {
        r.push_back(buffer<bool>());
        buffer<bool> & bv = r.back();
        expr minor_type = mlocal_type(rec_args[i]);
        buffer<expr> minor_args;
        to_telescope(ngen, minor_type, minor_args);
        for (expr & minor_arg : minor_args) {
            buffer<expr> minor_arg_args;
            expr minor_arg_type = to_telescope(tc, mlocal_type(minor_arg), minor_arg_args);
            bv.push_back(is_typeformer_app(typeformer_names, minor_arg_type));
        }
    }
}
Ejemplo n.º 2
0
	bool LoadDataFromFile(buffer& buff, const TCHAR* filename, bool text)
	{
		bool ret = false;
		FILE* file = nullptr;
		size_t size = 0;
		std::string fullpath;

		CHECK(filename);

		buff.clear();

		_tfopen_s(&file, filename, text ? _T("r") : _T("rb"));
		CHECK(file);

		fseek(file, 0L, SEEK_SET);
		fseek(file, 0L, SEEK_END);
		size = ftell(file);

		buff.resize(text ? size + sizeof(char) : size);

		fseek(file, 0L, SEEK_SET);
		size = fread(buff.ptr(), 1, size, file);

		if (text)
			buff.ptr()[size] = 0;

		ret = true;
	Exit0:
		if (file)
			fclose(file);
		return ret;
	}
Ejemplo n.º 3
0
Archivo: name.cpp Proyecto: syohex/lean
 friend void copy_limbs(imp * p, buffer<name::imp *> & limbs) {
     limbs.clear();
     while (p != nullptr) {
         limbs.push_back(p);
         p = p->m_prefix;
     }
     std::reverse(limbs.begin(), limbs.end());
 }
Ejemplo n.º 4
0
stream::state_t
socks5_proxy::recv( std::vector< buffer > &in_recv_bufs, buffer &out_send_buf, std::vector< buffer > &out_recv_bufs )
{
	switch ( m_state5 )
	{
		case waiting_for_opening_response:
		{
			std::size_t bytes_available = in_recv_bufs[ 0 ].size();
			std::size_t handshake_left	= 2 - m_recv_handshake.size();
	
			m_recv_handshake.append( in_recv_bufs[ 0 ].data(), std::min( handshake_left, bytes_available ) );
			
			if ( m_recv_handshake.size() < 2 )
			{
				in_recv_bufs[ 0 ].rotate( 0, std::min( handshake_left, bytes_available ), in_recv_bufs[ 0 ].size() );
			}
			else
			{
				if ( m_recv_handshake[ 0 ] == 0x05 )
				{
					if ( m_recv_handshake[ 1 ] == 0x00 )
					{
						out_send_buf	= make_connect_buffer();
						out_recv_bufs.clear();
						
						m_state5 = waiting_for_connect_response;
					}
					else if ( m_recv_handshake[ 1 ] == 0x02 )
					{
						out_send_buf	= make_auth_buffer();
						out_recv_bufs.clear();
	
						m_state5 = waiting_for_authentication_response;
					}
					else
					{
						m_state = stream::state_t::error;
					}
				}
				else
				{
					m_state = stream::state_t::error;
				}
					
				m_recv_handshake.clear();
			}
		}
		break;
		
		case waiting_for_authentication_response:
		{
			std::size_t bytes_available = in_recv_bufs[ 0 ].size();
			std::size_t handshake_left	= 2 - m_recv_handshake.size();
	
			m_recv_handshake.append( in_recv_bufs[ 0 ].data(), std::min( handshake_left, bytes_available ) );
			
			if ( m_recv_handshake.size() < 2 )
			{
				in_recv_bufs[ 0 ].rotate( 0, std::min( handshake_left, bytes_available ), in_recv_bufs[ 0 ].size() );
			}
			else
			{
				if ( ( m_recv_handshake[ 0 ] == 0x01 ) && ( m_recv_handshake[ 1 ] == 0x00 ) )
				{
					out_send_buf = make_connect_buffer();
					out_recv_bufs.clear();
					
					m_state5 = waiting_for_connect_response;
				}
				else
				{
					m_state = stream::state_t::error;
				}
				
				m_recv_handshake.clear();
			}
		}
		break;
				
		case waiting_for_connect_response:
		{
			std::size_t bytes_available = in_recv_bufs[ 0 ].size();
			std::size_t handshake_left	= 4 - m_recv_handshake.size();
	
			m_recv_handshake.append( in_recv_bufs[ 0 ].data(), std::min( handshake_left, bytes_available ) );
			
			if ( m_recv_handshake.size() < 4 )
			{
				in_recv_bufs[ 0 ].rotate( 0, std::min( handshake_left, bytes_available ), in_recv_bufs[ 0 ].size() );
			}
			else if ( ( m_recv_handshake[ 0 ] == 0x05 ) && ( m_recv_handshake[ 1 ] == 0x00 ) )
			{
				switch ( m_recv_handshake[ 3 ] )
				{
					case 0x01:
					{
						in_recv_bufs[ 0 ].rotate( 0, 6, in_recv_bufs[ 0 ].size() );
						
						out_send_buf = std::move( m_send_queue );
						
						m_state5 = connected;
						m_state = stream::state_t::connected;
					}
					break;
							
					case 0x03:
					{
						auto len = in_recv_bufs[ 0 ][ 0 ];
							
						in_recv_bufs[ 0 ].rotate( 0, len + 1, in_recv_bufs[ 0 ].size() );
						
						out_send_buf = std::move( m_send_queue );
							
						m_state5 = connected;
						m_state = stream::state_t::connected;
					}
					break;
								
					case 0x04:
					{
						in_recv_bufs[ 0 ].rotate( 0, 18, in_recv_bufs[ 0 ].size() );
						
						out_send_buf = std::move( m_send_queue );
						
						m_state5 = connected;
						m_state = stream::state_t::connected;
					}
					break;
						
					default:
					{
						m_state = stream::state_t::error;
					}
				}
			}
		}
		break;
		
		default:
		{
			out_recv_bufs = std::move( in_recv_bufs );
		}
	}
	
	return m_state;
}