pijul/zstd-seekable - Change GKNZUJV6XUPOHKZEOOPOWMCYRBTMR36WTLOBEIPWZ55DX6SRUAVAC

Removing unecessary unsafe blocks

Created by darleybarreto on July 25, 2021

GKNZUJV6XUPOHKZEOOPOWMCYRBTMR36WTLOBEIPWZ55DX6SRUAVAC

Dependencies

In channels

main

In discussions

#5 Oxidizing C files

Change contents

Replacement in src/lib.rs at line 346 [4.241245]

B:BD[3.6521] → [2.2760:2828]

        let result = self.framelog.write_seek_table(&mut output_)?;

[3.6521]

[2.2828]

        let result = self.framelog.write_seek_table(output, &mut output_.pos)?;

Replacement in src/lib.rs at line 591 [4.241245]

B:BD[3.11482] → [3.11482:11639]

                // FIXME: replace this pointer arithmetic with something safer
                unsafe { (buffer_ptr.add(pos)).copy_to(buffer_ptr, offset) };

[3.11482]

[3.11639]

                self.in_buff.copy_within(offset..offset+to_read,pos);

Replacement in src/lib.rs at line 594 [4.241245]

B:BD[5.476] → [2.4419:4631]

                // FIXME: if pointer arithmetic were to be replaced, this needs to change
                handle
                    .read(unsafe { slice::from_raw_parts_mut(buffer_ptr.add(offset), to_read) })?;

[5.476]

[3.11896]

                handle.read(&mut self.in_buff[offset..offset+to_read])?;

Replacement in src/lib.rs at line 688 [4.241245]

B:BD[3.14615] → [3.14615:14725]

                let mut out_tmp = if self.decompressed_offset < offset {
                    ZSTD_outBuffer {

[3.14615]

[3.14725]

                // here slice_tmp is a [u8] helper so we avoid using unsafe pointer arithmetic later on
                let (mut out_tmp, slice_tmp) = if self.decompressed_offset < offset {
                    (ZSTD_outBuffer {

Replacement in src/lib.rs at line 697 [4.241245]

B:BD[3.15019] → [3.15019:15041]

[3.15019]

[3.15041]

                    }, (&self.out_buff).as_ref())

Replacement in src/lib.rs at line 699 [4.241245]

B:BD[3.15066] → [3.15066:15103]

                    ZSTD_outBuffer {

[3.15066]

[2.5472]

                    (ZSTD_outBuffer {

Replacement in src/lib.rs at line 703 [4.241245]
B:BD[3.15263] → [3.15263:15285]
```
                    }
```
[3.15263]
[3.15285]
```
                    }, &*out)
```

Replacement in src/lib.rs at line 718 [4.241245]

B:BD[3.15672] → [3.15672:16075]

                    // FIXME: replace this pointer arithmetic with something safer
                    let tmp: &[u8] = unsafe {
                        slice::from_raw_parts_mut(
                            (out_tmp.dst as *mut u8).add(prev_out_pos),
                            out_tmp.pos - prev_out_pos,
                        )
                    };
                    self.xxh_state.write(tmp)

[3.15672]

[3.16075]

                    self.xxh_state.write(&slice_tmp[prev_out_pos..prev_out_pos+(out_tmp.pos - prev_out_pos)]);

Replacement in src/lib.rs at line 941 [4.241245]

B:BD[3.22109] → [2.7167:7264]

    pub fn stwrite32(&mut self, output: &mut ZSTD_outBuffer, value: u32, offset: u32) -> usize {

[3.22109]

[2.7264]

    pub fn stwrite32(&mut self, output: &mut [u8], value: u32, offset: u32, pos: &mut usize) -> usize {

Replacement in src/lib.rs at line 944 [4.241245]

B:BD[3.22344] → [3.22344:22386]

                output.size - output.pos,

[3.22344]

[2.7311]

                output.len() - *pos,

Replacement in src/lib.rs at line 948 [4.241245]

B:BD[4.260252] → [3.22461:22557]

B:BD[3.22557] → [2.7373:7525]

            // FIXME: replace this pointer arithmetic with something safer
            unsafe {
                let base = output.dst.add(output.pos) as *mut u8;
                ptr::copy(value.to_ne_bytes().as_ptr(),base,len_write);
            }

[4.260252]

[3.22818]

            output[*pos..*pos+len_write].copy_from_slice(&value.to_ne_bytes());

Replacement in src/lib.rs at line 950 [4.241245]
B:BD[3.22819] → [3.22819:22856]
```
            output.pos += len_write;
```
[3.22819]
[2.7526]
```
            *pos += len_write;
```

Replacement in src/lib.rs at line 970 [4.241245]

B:BD[3.23116] → [3.23116:23182]

        while let Ok(ret) = self.write_seek_table(&mut output_) {

[3.23116]

[3.23182]

        while let Ok(ret) = self.write_seek_table(&mut output, &mut output_.pos) {

Replacement in src/lib.rs at line 983 [4.241245]

B:BD[3.23322] → [3.23322:23416]

    pub fn write_seek_table(&mut self, output: &mut ZSTD_outBuffer) -> Result<usize, Error> {

[3.23322]

[3.23416]

    pub fn write_seek_table(&mut self, output: &mut [u8], pos: &mut usize) -> Result<usize, Error> {

Replacement in src/lib.rs at line 987 [4.241245]

B:BD[3.23541] → [3.23541:23626]

        let mut ret: usize = self.stwrite32(output, MAGIC_SKIPPABLE_START | 0xE, 0);

[3.23541]

[3.23626]

        let mut ret: usize = self.stwrite32(output, MAGIC_SKIPPABLE_START | 0xE, 0, pos);

Replacement in src/lib.rs at line 994 [4.241245]

B:BD[3.23734] → [2.7580:7665]

        ret = self.stwrite32(output, (table_len - SKIPPABLE_HEADER_SIZE) as u32, 4);

[3.23734]

[3.23810]

        ret = self.stwrite32(output, (table_len - SKIPPABLE_HEADER_SIZE) as u32, 4, pos);

Replacement in src/lib.rs at line 1005 [4.241245]

B:BD[3.24080] → [2.7742:7815]

            ret = self.stwrite32(output, self.entries[i].c_size, start);

[3.24080]

[3.24162]

            ret = self.stwrite32(output, self.entries[i].c_size, start, pos);

Replacement in src/lib.rs at line 1010 [4.241245]

B:BD[3.24236] → [2.7816:7893]

            ret = self.stwrite32(output, self.entries[i].d_size, start + 4);

[3.24236]

[3.24322]

            ret = self.stwrite32(output, self.entries[i].d_size, start + 4, pos);

Replacement in src/lib.rs at line 1016 [4.241245]

B:BD[3.24437] → [2.7894:7984]

                ret = self.stwrite32(output, self.entries[i].checksum as u32, start + 8);

[3.24437]

[3.24529]

                ret = self.stwrite32(output, self.entries[i].checksum as u32, start + 8, pos);

Insertion in src/lib.rs at line 1032 [4.241245]
[2.8081]
[3.24878]
```
            pos
```
Replacement in src/lib.rs at line 1038 [4.241245]
B:BD[3.24951] → [3.24951:24993]
```
        if output.size - output.pos < 1 {
```
[3.24951]
[3.24993]
```
        if output.len() - *pos < 1 {
```

Replacement in src/lib.rs at line 1044 [4.241245]

B:BD[3.25180] → [3.25180:25279]

B:BD[3.25279] → [2.8145:8182]

∅:D[2.8182] → [3.25444:25473]

B:BD[3.25444] → [3.25444:25473]

            let array = unsafe { slice::from_raw_parts_mut(output.dst as *mut u8, output.size) };
            array[output.pos] = sfd;
            output.pos += 1;

[3.25180]

[2.8183]

            output[*pos] = sfd;
            *pos += 1;

Replacement in src/lib.rs at line 1049 [4.241245]

B:BD[3.25484] → [2.8222:8307]

        ret = self.stwrite32(output, SEEKABLE_MAGIC_NUMBER, (table_len - 4) as u32);

[3.25484]

[3.25560]

        ret = self.stwrite32(output, SEEKABLE_MAGIC_NUMBER, (table_len - 4) as u32, pos);

Replacement in src/lib.rs at line 1121 [4.241245]

B:BD[4.263818] → [2.8725:10350]

// #[test]
// fn test() {
//     let mut cstream = SeekableCStream::new(10, 256).unwrap();
//     let input = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut diam ante, sollicitudin a dolor et, volutpat elementum nulla. Etiam nec efficitur nibh, quis rutrum risus. Maecenas quis lorem malesuada, aliquet mi vel, viverra nunc. Donec et nulla sed velit sagittis varius. Suspendisse vestibulum, neque lobortis ornare vestibulum, orci turpis vulputate nisi, ut sodales neque purus eget magna. Nunc condimentum, diam eu consequat venenatis, est nisl semper lorem, et lobortis velit justo sed nulla. Nunc sit amet tempor nunc, vel posuere ipsum. Cras erat tortor, pulvinar ac pretium eu, auctor ac nibh. Duis iaculis porta magna, eu lobortis elit. Duis vitae massa eros. Nulla non magna accumsan, egestas quam sit amet, laoreet lectus.";
//     let mut input_pos = 0;
//     let mut output = vec![0; input.len()];
//     let mut output_pos = 0;
//     while input_pos < input.len() {
//         let (a, b) = cstream
//             .compress(&mut output[output_pos..], &input[input_pos..])
//             .unwrap();
//         output_pos += a;
//         input_pos += b;
//     }
//     while let Ok(n) = cstream.end_stream(&mut output[output_pos..]) {
//         if n == 0 {
//             break;
//         }
//         output_pos += n;
//     }
//     output.truncate(output_pos);
//     {
//         use std::io::Write;
//         let mut file = std::fs::File::create("test").unwrap();
//         file.write_all(&output).unwrap();
//     }
//     println!("input len = {:?}, pos = {:?}", input.len(), output_pos);

[4.263818]

[6.265]

#[test]
fn test() {
    let mut cstream = SeekableCStream::new(10, 256).unwrap();
    let input = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut diam ante, sollicitudin a dolor et, volutpat elementum nulla. Etiam nec efficitur nibh, quis rutrum risus. Maecenas quis lorem malesuada, aliquet mi vel, viverra nunc. Donec et nulla sed velit sagittis varius. Suspendisse vestibulum, neque lobortis ornare vestibulum, orci turpis vulputate nisi, ut sodales neque purus eget magna. Nunc condimentum, diam eu consequat venenatis, est nisl semper lorem, et lobortis velit justo sed nulla. Nunc sit amet tempor nunc, vel posuere ipsum. Cras erat tortor, pulvinar ac pretium eu, auctor ac nibh. Duis iaculis porta magna, eu lobortis elit. Duis vitae massa eros. Nulla non magna accumsan, egestas quam sit amet, laoreet lectus.";
    let mut input_pos = 0;
    let mut output = vec![0; input.len()];
    let mut output_pos = 0;
    while input_pos < input.len() {
        let (a, b) = cstream
            .compress(&mut output[output_pos..], &input[input_pos..])
            .unwrap();
        output_pos += a;
        input_pos += b;
    }
    while let Ok(n) = cstream.end_stream(&mut output[output_pos..]) {
        if n == 0 {
            break;
        }
        output_pos += n;
    }
    output.truncate(output_pos);
    {
        use std::io::Write;
        let mut file = std::fs::File::create("test").unwrap();
        file.write_all(&output).unwrap();
    }
    println!("input len = {:?}, pos = {:?}", input.len(), output_pos);

Replacement in src/lib.rs at line 1149 [4.241245]

B:BD[6.266] → [2.10351:10932]

//     let mut decomp = Vec::new();
//     let mut s = { Seekable::init_buf(&mut output).unwrap() };
//     for frame in 0..s.get_num_frames() {
//         let size = s.get_frame_decompressed_size(frame).unwrap();
//         println!("{:?} {:?}", size, s.get_frame_decompressed_offset(frame).unwrap());
//         let n = decomp.len();
//         decomp.extend(std::iter::repeat(0).take(size));
//         s.decompress_frame(&mut decomp[n..], frame).unwrap();
//     }
//     println!("{:?}", std::str::from_utf8(&decomp).unwrap());
//     assert_eq!(&input[..], &decomp[..])
// }

[6.266]

    let mut decomp = Vec::new();
    let mut s = { Seekable::init_buf(&mut output).unwrap() };
    for frame in 0..s.get_num_frames() {
        let size = s.get_frame_decompressed_size(frame).unwrap();
        println!("{:?} {:?}", size, s.get_frame_decompressed_offset(frame).unwrap());
        let n = decomp.len();
        decomp.extend(std::iter::repeat(0).take(size));
        s.decompress_frame(&mut decomp[n..], frame).unwrap();
    }
    println!("{:?}", std::str::from_utf8(&decomp).unwrap());
    assert_eq!(&input[..], &decomp[..])
}