Beispiel #1
0
range type_name() {
    // TODO: support other compilers etc.
    char const *name = typeid(T).name();
    if (*name == 'N') {
        ++name;
        int length;
        do {
            length = *name - '0';

            ++name;
            while (*name >= '0' && *name <= '9') {
                length *= 10;
                length += *name - '0';
                ++name;
            }

            name += length;
        } while (*name != 'E');

        return range(name - length, name);
    }
    else {
        while (*name >= '0' && *name <= '9') ++name;
        return to_range(name);
    }
}
Beispiel #2
0
			void new_buffer_(){
				if (map_dest){
					wview = map_dest->view_wr(ext_heap::handle(zstream.total_out, zstream.total_out + K_CompressedViewSize));
					if (wview.get<io::write_view>().address().size() != K_CompressedViewSize)
						AIO_THROW(deflate_exception)("Failed to request write view");

					auto addr  = wview.get<io::write_view>().address();
					zstream.next_out = (Bytef*)addr.begin();
					zstream.avail_out = uInt(addr.size());
				}
				else{
					crc = crc32(to_range(buf), crc);
					stream_dest->write(to_range(buf));
					buf.resize(K_CompressedViewSize);
					zstream.next_out = (Bytef*)buf.begin();
					zstream.avail_out = uInt(buf.size());
				}
			}
Beispiel #3
0
	uint32_t crc32(io::reader& src, uint32_t crc /* = crc32_init()*/){
		buffer<byte> bin;
		bin.resize(K_BufferSize);
		while (src.readable()){
			auto rest = src.read(to_range(bin));
			crc =  ::crc32(crc, (const Bytef*)bin.begin(), (uInt)(bin.size() - rest.size()));
		}
		return crc;
	}
Beispiel #4
0
static void		set_material_values(t_env *e, char *pt1, char *pt2)
{
	t_split_string	values;

	values = ft_nstrsplit(pt2, ' ');
	if (!ft_strcmp(pt1, "NAME"))
	{
		ft_strdel(&e->material[e->materials]->name);
		e->material[e->materials]->name = ft_strdup(values.strings[0]);
	}
	else if (!ft_strcmp(pt1, "DIFFUSE"))
		e->material[e->materials]->diff = get_colour(e, values);
	else if (!ft_strcmp(pt1, "SPECULAR"))
		e->material[e->materials]->spec = get_colour(e, values);
	else if (!ft_strcmp(pt1, "REFLECT"))
		e->material[e->materials]->reflect =
			to_range(ft_atod(values.strings[0]), 0.0, 1.0);
	else if (!ft_strcmp(pt1, "REFRACT"))
		e->material[e->materials]->refract =
			to_range(ft_atod(values.strings[0]), 0.0, 1.0);
	else if (!ft_strcmp(pt1, "IOR"))
		e->material[e->materials]->ior = ft_atod(values.strings[0]);
	ft_free_split(&values);
}
Beispiel #5
0
			void new_input_(){
				if (map_src){
					long_size_t rest_in_size = map_src->size() - zstream.total_in;
					if (rest_in_size > 0){
						typedef ext_heap::handle handle;
						handle hin(zstream.total_in,  zstream.total_in + std::min(K_UncompressedViewSize, rest_in_size));
						rview = map_src->view_rd(hin);
						auto bin = rview.get<io::read_view>().address();
						zstream.avail_in = uInt(bin.size());
						zstream.next_in = (Bytef*)bin.begin();
						crc = crc32(bin, crc);
					}
				}
				else if(stream_src->readable()){
					buf.resize(K_UncompressedViewSize);
					auto res = stream_src->read(to_range(buf));
					buf.resize(buf.size() - res.size());
					zstream.avail_in = uInt(buf.size());
					zstream.next_in = (Bytef*)buf.begin();
				}
			}
Beispiel #6
0
	void reader_writer::sync(){
		AIO_PRE_CONDITION(valid());

		if (!m_imp->dirty)
			return;

		bool zip64_enabled = false;
		long_size_t cd_size = 0;
		for (auto & i : m_imp->items){
			file_header& h = i;
			cd_size += K_fix_part_of_central_header 
				+ h.name.str().size() 
				+ h.comments.size();
			auto need_zip64 = h.compressed_size >= uint32_t(-1)
					|| h.uncompressed_size >= uint32_t(-1)
					|| h.relative_offset_ >= uint32_t(-1);
			zip64_enabled = zip64_enabled || need_zip64;
			if (need_zip64)
				cd_size += h.extra.size();
		}
		if (m_imp->items.size() >= uint16_t(-1) 
				|| cd_size >= uint32_t(-1)
				|| m_imp->end_of_last >= uint32_t(-1))
			zip64_enabled = true;
		uint16_t num_entries = m_imp->items.size() >= uint16_t(-1) ? uint16_t(-1) :  uint16_t(m_imp->items.size());

		auto cd_and_end_size = cd_size +  K_sizeof_cd_end;
		if (zip64_enabled)
			cd_and_end_size += K_sizeof_zip64_end_cd + K_sizeof_zip64_locator;
		auto view = m_imp->archive.get<io::write_map>().view_wr(ext_heap::handle(m_imp->end_of_last, m_imp->end_of_last + cd_and_end_size));
		auto address = view.get<io::write_view>().address();
		io::fixed_buffer_io bout(address);
		auto saver = io::exchange::as_sink(bout);
		for (auto & i : m_imp->items){
			file_header& h = i;
			auto need_zip64 = h.compressed_size >= uint32_t(-1)
					|| h.uncompressed_size >= uint32_t(-1)
					|| h.relative_offset_ >= uint32_t(-1);

			saver & K_sig_central_file_header
				& h.creator_version
				& h.reader_version
				& h.flags
				& h.method
				& h.modified_time

				& h.modified_date
				& h.crc32;
			if (need_zip64)
				saver & uint32_t(-1) & uint32_t(-1);
			else
				saver & uint32_t(h.compressed_size) & uint32_t(h.uncompressed_size);

			saver & uint16_t(h.name.str().size())
				& uint16_t(need_zip64 ? h.extra.size() : 0)
				& uint16_t(h.comments.size())
				& uint16_t(0)	//disk number start
				& uint16_t(0)	//internal file attributes
				& h.external_attrs;
			if (need_zip64)
				saver & uint32_t(-1);
			else
				saver & uint32_t(h.relative_offset_);
			bout.write(make_range(reinterpret_cast<const byte*>(h.name.str().begin())
						, reinterpret_cast<const byte*>(h.name.str().end())));
			if (need_zip64)
				bout.write(to_range(h.extra));
			bout.write(make_range(reinterpret_cast<const byte*>(h.comments.begin())
						, reinterpret_cast<const byte*>(h.comments.end())));
		}
		if (zip64_enabled){
			saver & K_sig_zip64_end_cd
				& uint64_t(cd_size)
				& uint16_t(20) //version made by
				& uint16_t(20) //version needed to extract
				& uint32_t(0) //number of this disk
				& uint32_t(0) //number of the disk with the start of the central directory
				& uint64_t(m_imp->items.size()) //total number of entries in the central directory on this disk
				& uint64_t(m_imp->items.size()) //total number of entries in the central directory
				& uint64_t(cd_size) //size of the central directory
				& uint64_t(m_imp->end_of_last); //offset of start of central directory with respect to the starting disk number

			saver & K_sig_zip64_end_of_cd_locator
				& uint32_t(0)	//number of the disk with the start of the zip64 end of central directory
				& uint64_t(cd_size + m_imp->end_of_last)	//relative offset of the zip64 end of central directory record
				& uint32_t(1);		//total number of disks

		}


		saver & K_sig_end_central_dir_signature
			& uint16_t(0)	//number of this disk
			& uint16_t(0)	//number of the disk with the start of the central directory
			& num_entries 	//total number of entries in the central directory on this disk
			& num_entries 	//total number of entries in the central directory
			& (cd_size >= uint32_t(-1)? uint32_t(-1) : uint32_t(cd_size))	//size of the central directory
			& (m_imp->end_of_last >= uint32_t(-1)? uint32_t(-1) : uint32_t(m_imp->end_of_last))	//offset of start of central directory with respect to the starting disk number
			& uint16_t(0);	//.ZIP file comment length


		m_imp->archive.get<io::write_map>().sync();
		m_imp->dirty = false;

	}
Beispiel #7
0
	const file_header* append_(IoType& ar, const file_header& h_, file_type type, zip_package_writer_imp * m_imp){
		file_header h = h_;
		AIO_PRE_CONDITION(m_imp);
		AIO_PRE_CONDITION(h.method == cm_deflate || h.method == cm_store);
		AIO_PRE_CONDITION(h.name.str().size() < uint16_t(-1) );
		AIO_PRE_CONDITION(h.comments.size() < uint16_t(-1) );
		if (m_imp->exist_(h.name)) return 0;

		auto header_size = K_fix_part_of_local_header + h.name.str().size() + K_sizeof_zip64_extra_field;
		auto dest_map = io::decorate<io::tail_archive
			, io::tail_read_map_p
			, io::tail_write_map_p
			>(m_imp->archive, m_imp->end_of_last + header_size);
		m_imp->dirty = true;
		if (h.method == cm_deflate){
			if (type == ft_raw){
				deflate_writer d_writer(dest_map);
				iref<io::writer> dest(d_writer);
				io::copy_data(ar, dest.get<io::writer>());
				d_writer.finish();

				h.uncompressed_size = d_writer.uncompressed_size();
				h.compressed_size = d_writer.size();
				h.crc32 = d_writer.crc32();
			}
			else {// type == ft_defalted
				io::copy_data(ar, dest_map);
			}
		}
		else {	// == cm_store
			auto size = io::copy_data(ar, dest_map);
			h.uncompressed_size = size;
			h.compressed_size = size;
			h.crc32 = crc32(dest_map);
		}
		setDateTime(h);
		h.relative_offset_ = m_imp->end_of_last;
		bool zip64_enabled = (h.uncompressed_size >= uint32_t(-1)
				|| h.compressed_size >= uint32_t(-1)
				|| h.relative_offset_ >= uint32_t(-1)
		   );
		{	// fill extra data for zip64
			io::buffer_out bout(h.extra);
			auto saver = io::exchange::as_sink(bout);
			save(saver, uint16_t(K_z64_extra_id)); //
			save(saver, uint16_t(28));		//sizeof extra data
			save(saver, uint64_t(h.uncompressed_size));
			save(saver, uint64_t(h.compressed_size));
			save(saver, uint64_t(h.relative_offset_));
			save(saver, uint32_t(0));		//Disk Start Number
		}
		auto hview = m_imp->archive.get<io::write_map>().view_wr(ext_heap::handle(m_imp->end_of_last
					, m_imp->end_of_last + header_size));
		io::fixed_buffer_io bout(hview.get<io::write_view>().address());
		auto saver = io::exchange::as_sink(bout);
		saver & K_sig_local_eader;
		saver & h.reader_version
			& h.flags
			& h.method
			& h.modified_time
			& h.modified_date
			& h.crc32;
		if (zip64_enabled)
			saver & uint32_t(-1) & uint32_t(-1);
		else
			saver & uint32_t(h.compressed_size) & uint32_t(h.uncompressed_size);
		saver & uint16_t(h.name.str().size()) & uint16_t(h.extra.size());
		bout.write(make_range(reinterpret_cast<const byte*>(h.name.str().begin())
					, reinterpret_cast<const byte*>(h.name.str().end())));
		bout.write(to_range(h.extra));

		h.local_header_size_ = header_size;
		m_imp->items.push_back(h);
		m_imp->end_of_last += header_size + h.compressed_size;

		return &m_imp->items.back();
	}