parsers.rs
140 lines
| 4.2 KiB
| application/rls-services+xml
|
RustLexer
|
r42617 | // Copyright 2019 Raphaël Gomès <rgomes@octobus.net> | ||
// | ||||
// This software may be used and distributed according to the terms of the | ||||
// GNU General Public License version 2 or any later version. | ||||
|
r47168 | use crate::errors::HgError; | ||
|
r47894 | use crate::utils::hg_path::HgPath; | ||
|
r48882 | use crate::{dirstate::EntryState, DirstateEntry, DirstateParents}; | ||
|
r47336 | use byteorder::{BigEndian, WriteBytesExt}; | ||
|
r48830 | use bytes_cast::{unaligned, BytesCast}; | ||
|
r45028 | use micro_timer::timed; | ||
|
r48882 | use std::convert::TryFrom; | ||
|
r42617 | |||
/// Parents are stored in the dirstate as byte hashes. | ||||
|
r42993 | pub const PARENT_SIZE: usize = 20; | ||
|
r42617 | /// Dirstate entries have a static part of 8 + 32 + 32 + 32 + 32 bits. | ||
const MIN_ENTRY_SIZE: usize = 17; | ||||
|
r45916 | type ParseResult<'a> = ( | ||
|
r47336 | &'a DirstateParents, | ||
|
r45916 | Vec<(&'a HgPath, DirstateEntry)>, | ||
Vec<(&'a HgPath, &'a HgPath)>, | ||||
); | ||||
|
r42993 | |||
|
r47343 | pub fn parse_dirstate_parents( | ||
contents: &[u8], | ||||
) -> Result<&DirstateParents, HgError> { | ||||
let (parents, _rest) = DirstateParents::from_bytes(contents) | ||||
.map_err(|_| HgError::corrupted("Too little data for dirstate."))?; | ||||
Ok(parents) | ||||
} | ||||
|
r45028 | #[timed] | ||
|
r47867 | pub fn parse_dirstate(contents: &[u8]) -> Result<ParseResult, HgError> { | ||
|
r47336 | let mut copies = Vec::new(); | ||
let mut entries = Vec::new(); | ||||
|
r47867 | let parents = | ||
parse_dirstate_entries(contents, |path, entry, copy_source| { | ||||
if let Some(source) = copy_source { | ||||
copies.push((path, source)); | ||||
} | ||||
entries.push((path, *entry)); | ||||
|
r48126 | Ok(()) | ||
|
r47867 | })?; | ||
Ok((parents, entries, copies)) | ||||
} | ||||
|
r42617 | |||
|
r48830 | #[derive(BytesCast)] | ||
#[repr(C)] | ||||
|
r48834 | struct RawEntry { | ||
|
r48830 | state: u8, | ||
mode: unaligned::I32Be, | ||||
size: unaligned::I32Be, | ||||
mtime: unaligned::I32Be, | ||||
length: unaligned::I32Be, | ||||
} | ||||
|
r47867 | pub fn parse_dirstate_entries<'a>( | ||
mut contents: &'a [u8], | ||||
|
r48126 | mut each_entry: impl FnMut( | ||
&'a HgPath, | ||||
&DirstateEntry, | ||||
Option<&'a HgPath>, | ||||
) -> Result<(), HgError>, | ||||
|
r47867 | ) -> Result<&'a DirstateParents, HgError> { | ||
|
r47336 | let (parents, rest) = DirstateParents::from_bytes(contents) | ||
.map_err(|_| HgError::corrupted("Too little data for dirstate."))?; | ||||
contents = rest; | ||||
while !contents.is_empty() { | ||||
let (raw_entry, rest) = RawEntry::from_bytes(contents) | ||||
.map_err(|_| HgError::corrupted("Overflow in dirstate."))?; | ||||
|
r42617 | |||
|
r48834 | let entry = DirstateEntry::from_v1_data( | ||
EntryState::try_from(raw_entry.state)?, | ||||
raw_entry.mode.get(), | ||||
raw_entry.size.get(), | ||||
raw_entry.mtime.get(), | ||||
); | ||||
|
r47336 | let (paths, rest) = | ||
u8::slice_from_bytes(rest, raw_entry.length.get() as usize) | ||||
.map_err(|_| HgError::corrupted("Overflow in dirstate."))?; | ||||
|
r42617 | |||
|
r47336 | // `paths` is either a single path, or two paths separated by a NULL | ||
// byte | ||||
let mut iter = paths.splitn(2, |&byte| byte == b'\0'); | ||||
let path = HgPath::new( | ||||
iter.next().expect("splitn always yields at least one item"), | ||||
); | ||||
|
r47867 | let copy_source = iter.next().map(HgPath::new); | ||
|
r48126 | each_entry(path, &entry, copy_source)?; | ||
|
r42617 | |||
|
r47336 | contents = rest; | ||
|
r42617 | } | ||
|
r47867 | Ok(parents) | ||
|
r42617 | } | ||
|
r47872 | fn packed_filename_and_copy_source_size( | ||
|
r47894 | filename: &HgPath, | ||
copy_source: Option<&HgPath>, | ||||
|
r47872 | ) -> usize { | ||
filename.len() | ||||
+ if let Some(source) = copy_source { | ||||
b"\0".len() + source.len() | ||||
} else { | ||||
0 | ||||
} | ||||
} | ||||
pub fn packed_entry_size( | ||||
|
r47894 | filename: &HgPath, | ||
copy_source: Option<&HgPath>, | ||||
|
r47872 | ) -> usize { | ||
MIN_ENTRY_SIZE | ||||
+ packed_filename_and_copy_source_size(filename, copy_source) | ||||
} | ||||
pub fn pack_entry( | ||||
|
r47894 | filename: &HgPath, | ||
|
r47872 | entry: &DirstateEntry, | ||
|
r47894 | copy_source: Option<&HgPath>, | ||
|
r47872 | packed: &mut Vec<u8>, | ||
) { | ||||
let length = packed_filename_and_copy_source_size(filename, copy_source); | ||||
|
r48834 | let (state, mode, size, mtime) = entry.v1_data(); | ||
|
r47872 | |||
// Unwrapping because `impl std::io::Write for Vec<u8>` never errors | ||||
|
r48834 | packed.write_u8(state).unwrap(); | ||
packed.write_i32::<BigEndian>(mode).unwrap(); | ||||
packed.write_i32::<BigEndian>(size).unwrap(); | ||||
packed.write_i32::<BigEndian>(mtime).unwrap(); | ||||
|
r47872 | packed.write_i32::<BigEndian>(length as i32).unwrap(); | ||
packed.extend(filename.as_bytes()); | ||||
if let Some(source) = copy_source { | ||||
packed.push(b'\0'); | ||||
packed.extend(source.as_bytes()); | ||||
} | ||||
} | ||||
|
r47871 | /// Seconds since the Unix epoch | ||
|
r48140 | pub struct Timestamp(pub i64); | ||