##// END OF EJS Templates
upstream » mercurial-mirror
RSS

Clone from https://www.mercurial-scm.org/repo/hg-all

pyoxidizer: support producing MSI installers...
pyoxidizer: support producing MSI installers Newer versions of PyOxidizer have support for building WiX MSI installers "natively." Essentially, you can script the definition of your WiX installer via Starlark and PyOxidizer can invoke WiX tools to produce the installer. This commit teaches our PyOxidizer config file to produce MSI installers similarly to how `contrib/packaging/packging.py wix` would do it. We had to make a very minor change to `mercurial.wxs` to reflect different paths depending on who builds. This is because when PyOxidizer builds WiX installers, it does so from an isolated directory, not Mercurial's source directory. We simply copy the files into the build environment so they are accessible. After this change, running `pyoxidizer build msi` produces a nearly identical install layout to what the previous method produces. When I applied this series on top of the 5.8 tag, here is the list of differences and explanations: * docs/*.html files are missing from the new installer because the Python build environment doesn't have docutils. * .pyd and .exe files differ, likely because I'm using a different Visual Studio toolchain on my local computer than the official build environment. * Various .dist-info/ directories have different names. This is because older versions of PyOxidizer had buggy behavior and weren't properly normalizing package names in .dist-info/ directories. e.g. we went from `cached-property-1.5.2.dist-info` to `cached_property-1.5.2.dist-info`. * Translations (.mo files) may be missing if gettext isn't in %Path%. This is because the packaging.py code installs gettext and ensures it can be found. * Some *.dist-info/RECORD files vary due to SHA-256 content digest divergence due to build environment differences. (This should be harmless.) * The new install layout ships a python3.dll because newer versions of PyOxidizer ship this file. * The new install layout has a different vcruntime140.dll and also a vcruntime140_1.dll because newer versions of PyOxidizer ship a newer version of the Visual C++ Redistributable Runtime. The new PyOxidizer functionality is not yet integrated with packaging.py. This will come in a subsequent commit. So for now, the new functionality introduced here is unused. Differential Revision: https://phab.mercurial-scm.org/D10683
Antoine Cezar - - Load All Authors

File last commit:

r46110:aebc976f default
r47976:603efb38 default
Show More
path_encode.rs
653 lines | 20.8 KiB | application/rls-services+xml | RustLexer
/ rust / hg-core / src / revlog / path_encode.rs
History | Annotation | Raw |Copy content |Copy permalink
use crypto::digest::Digest;
use crypto::sha1::Sha1;
#[derive(PartialEq, Debug)]
#[allow(non_camel_case_types)]
enum path_state {
START, /* first byte of a path component */
A, /* "AUX" */
AU,
THIRD, /* third of a 3-byte sequence, e.g. "AUX", "NUL" */
C, /* "CON" or "COMn" */
CO,
COMLPT, /* "COM" or "LPT" */
COMLPTn,
L,
LP,
N,
NU,
P, /* "PRN" */
PR,
LDOT, /* leading '.' */
DOT, /* '.' in a non-leading position */
H, /* ".h" */
HGDI, /* ".hg", ".d", or ".i" */
SPACE,
DEFAULT, /* byte of a path component after the first */
}
/* state machine for dir-encoding */
#[allow(non_camel_case_types)]
enum dir_state {
DDOT,
DH,
DHGDI,
DDEFAULT,
}
fn inset(bitset: &[u32; 8], c: u8) -> bool {
bitset[(c as usize) >> 5] & (1 << (c & 31)) != 0
}
fn charcopy(dest: Option<&mut [u8]>, destlen: &mut usize, c: u8) {
if let Some(slice) = dest {
slice[*destlen] = c
}
*destlen += 1
}
fn memcopy(dest: Option<&mut [u8]>, destlen: &mut usize, src: &[u8]) {
if let Some(slice) = dest {
slice[*destlen..*destlen + src.len()].copy_from_slice(src)
}
*destlen += src.len();
}
fn rewrap_option<'a, 'b: 'a>(
x: &'a mut Option<&'b mut [u8]>,
) -> Option<&'a mut [u8]> {
match x {
None => None,
Some(y) => Some(y),
}
}
fn hexencode<'a>(mut dest: Option<&'a mut [u8]>, destlen: &mut usize, c: u8) {
let hexdigit = b"0123456789abcdef";
charcopy(
rewrap_option(&mut dest),
destlen,
hexdigit[(c as usize) >> 4],
);
charcopy(dest, destlen, hexdigit[(c as usize) & 15]);
}
/* 3-byte escape: tilde followed by two hex digits */
fn escape3(mut dest: Option<&mut [u8]>, destlen: &mut usize, c: u8) {
charcopy(rewrap_option(&mut dest), destlen, b'~');
hexencode(dest, destlen, c);
}
fn encode_dir(mut dest: Option<&mut [u8]>, src: &[u8]) -> usize {
let mut state = dir_state::DDEFAULT;
let mut i = 0;
let mut destlen = 0;
while i < src.len() {
match state {
dir_state::DDOT => match src[i] {
b'd' | b'i' => {
state = dir_state::DHGDI;
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
}
b'h' => {
state = dir_state::DH;
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
}
_ => {
state = dir_state::DDEFAULT;
}
},
dir_state::DH => {
if src[i] == b'g' {
state = dir_state::DHGDI;
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
} else {
state = dir_state::DDEFAULT;
}
}
dir_state::DHGDI => {
if src[i] == b'/' {
memcopy(rewrap_option(&mut dest), &mut destlen, b".hg");
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
}
state = dir_state::DDEFAULT;
}
dir_state::DDEFAULT => {
if src[i] == b'.' {
state = dir_state::DDOT
}
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
}
}
}
destlen
}
fn _encode(
twobytes: &[u32; 8],
onebyte: &[u32; 8],
mut dest: Option<&mut [u8]>,
src: &[u8],
encodedir: bool,
) -> usize {
let mut state = path_state::START;
let mut i = 0;
let mut destlen = 0;
let len = src.len();
while i < len {
match state {
path_state::START => match src[i] {
b'/' => {
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
}
b'.' => {
state = path_state::LDOT;
escape3(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
}
b' ' => {
state = path_state::DEFAULT;
escape3(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
}
b'a' => {
state = path_state::A;
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
}
b'c' => {
state = path_state::C;
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
}
b'l' => {
state = path_state::L;
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
}
b'n' => {
state = path_state::N;
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
}
b'p' => {
state = path_state::P;
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
}
_ => {
state = path_state::DEFAULT;
}
},
path_state::A => {
if src[i] == b'u' {
state = path_state::AU;
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
} else {
state = path_state::DEFAULT;
}
}
path_state::AU => {
if src[i] == b'x' {
state = path_state::THIRD;
i += 1;
} else {
state = path_state::DEFAULT;
}
}
path_state::THIRD => {
state = path_state::DEFAULT;
match src[i] {
b'.' | b'/' | b'\0' => escape3(
rewrap_option(&mut dest),
&mut destlen,
src[i - 1],
),
_ => i -= 1,
}
}
path_state::C => {
if src[i] == b'o' {
state = path_state::CO;
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
} else {
state = path_state::DEFAULT;
}
}
path_state::CO => {
if src[i] == b'm' {
state = path_state::COMLPT;
i += 1;
} else if src[i] == b'n' {
state = path_state::THIRD;
i += 1;
} else {
state = path_state::DEFAULT;
}
}
path_state::COMLPT => {
if src[i] >= b'1' && src[i] <= b'9' {
state = path_state::COMLPTn;
i += 1;
} else {
state = path_state::DEFAULT;
charcopy(
rewrap_option(&mut dest),
&mut destlen,
src[i - 1],
);
}
}
path_state::COMLPTn => {
state = path_state::DEFAULT;
match src[i] {
b'.' | b'/' | b'\0' => {
escape3(
rewrap_option(&mut dest),
&mut destlen,
src[i - 2],
);
charcopy(
rewrap_option(&mut dest),
&mut destlen,
src[i - 1],
);
}
_ => {
memcopy(
rewrap_option(&mut dest),
&mut destlen,
&src[i - 2..i],
);
}
}
}
path_state::L => {
if src[i] == b'p' {
state = path_state::LP;
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
} else {
state = path_state::DEFAULT;
}
}
path_state::LP => {
if src[i] == b't' {
state = path_state::COMLPT;
i += 1;
} else {
state = path_state::DEFAULT;
}
}
path_state::N => {
if src[i] == b'u' {
state = path_state::NU;
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
} else {
state = path_state::DEFAULT;
}
}
path_state::NU => {
if src[i] == b'l' {
state = path_state::THIRD;
i += 1;
} else {
state = path_state::DEFAULT;
}
}
path_state::P => {
if src[i] == b'r' {
state = path_state::PR;
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
} else {
state = path_state::DEFAULT;
}
}
path_state::PR => {
if src[i] == b'n' {
state = path_state::THIRD;
i += 1;
} else {
state = path_state::DEFAULT;
}
}
path_state::LDOT => match src[i] {
b'd' | b'i' => {
state = path_state::HGDI;
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
}
b'h' => {
state = path_state::H;
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
}
_ => {
state = path_state::DEFAULT;
}
},
path_state::DOT => match src[i] {
b'/' | b'\0' => {
state = path_state::START;
memcopy(rewrap_option(&mut dest), &mut destlen, b"~2e");
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
}
b'd' | b'i' => {
state = path_state::HGDI;
charcopy(rewrap_option(&mut dest), &mut destlen, b'.');
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
}
b'h' => {
state = path_state::H;
memcopy(rewrap_option(&mut dest), &mut destlen, b".h");
i += 1;
}
_ => {
state = path_state::DEFAULT;
charcopy(rewrap_option(&mut dest), &mut destlen, b'.');
}
},
path_state::H => {
if src[i] == b'g' {
state = path_state::HGDI;
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
} else {
state = path_state::DEFAULT;
}
}
path_state::HGDI => {
if src[i] == b'/' {
state = path_state::START;
if encodedir {
memcopy(
rewrap_option(&mut dest),
&mut destlen,
b".hg",
);
}
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1
} else {
state = path_state::DEFAULT;
}
}
path_state::SPACE => match src[i] {
b'/' | b'\0' => {
state = path_state::START;
memcopy(rewrap_option(&mut dest), &mut destlen, b"~20");
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
}
_ => {
state = path_state::DEFAULT;
charcopy(rewrap_option(&mut dest), &mut destlen, b' ');
}
},
path_state::DEFAULT => {
while i != len && inset(onebyte, src[i]) {
charcopy(rewrap_option(&mut dest), &mut destlen, src[i]);
i += 1;
}
if i == len {
break;
}
match src[i] {
b'.' => {
state = path_state::DOT;
i += 1
}
b' ' => {
state = path_state::SPACE;
i += 1
}
b'/' => {
state = path_state::START;
charcopy(rewrap_option(&mut dest), &mut destlen, b'/');
i += 1;
}
_ => {
if inset(onebyte, src[i]) {
loop {
charcopy(
rewrap_option(&mut dest),
&mut destlen,
src[i],
);
i += 1;
if !(i < len && inset(onebyte, src[i])) {
break;
}
}
} else if inset(twobytes, src[i]) {
let c = src[i];
i += 1;
charcopy(
rewrap_option(&mut dest),
&mut destlen,
b'_',
);
charcopy(
rewrap_option(&mut dest),
&mut destlen,
if c == b'_' { b'_' } else { c + 32 },
);
} else {
escape3(
rewrap_option(&mut dest),
&mut destlen,
src[i],
);
i += 1;
}
}
}
}
}
}
match state {
path_state::START => (),
path_state::A => (),
path_state::AU => (),
path_state::THIRD => {
escape3(rewrap_option(&mut dest), &mut destlen, src[i - 1])
}
path_state::C => (),
path_state::CO => (),
path_state::COMLPT => {
charcopy(rewrap_option(&mut dest), &mut destlen, src[i - 1])
}
path_state::COMLPTn => {
escape3(rewrap_option(&mut dest), &mut destlen, src[i - 2]);
charcopy(rewrap_option(&mut dest), &mut destlen, src[i - 1]);
}
path_state::L => (),
path_state::LP => (),
path_state::N => (),
path_state::NU => (),
path_state::P => (),
path_state::PR => (),
path_state::LDOT => (),
path_state::DOT => {
memcopy(rewrap_option(&mut dest), &mut destlen, b"~2e");
}
path_state::H => (),
path_state::HGDI => (),
path_state::SPACE => {
memcopy(rewrap_option(&mut dest), &mut destlen, b"~20");
}
path_state::DEFAULT => (),
};
destlen
}
fn basic_encode(dest: Option<&mut [u8]>, src: &[u8]) -> usize {
let twobytes: [u32; 8] = [0, 0, 0x87ff_fffe, 0, 0, 0, 0, 0];
let onebyte: [u32; 8] =
[1, 0x2bff_3bfa, 0x6800_0001, 0x2fff_ffff, 0, 0, 0, 0];
_encode(&twobytes, &onebyte, dest, src, true)
}
const MAXSTOREPATHLEN: usize = 120;
fn lower_encode(mut dest: Option<&mut [u8]>, src: &[u8]) -> usize {
let onebyte: [u32; 8] =
[1, 0x2bff_fbfb, 0xe800_0001, 0x2fff_ffff, 0, 0, 0, 0];
let lower: [u32; 8] = [0, 0, 0x07ff_fffe, 0, 0, 0, 0, 0];
let mut destlen = 0;
for c in src {
if inset(&onebyte, *c) {
charcopy(rewrap_option(&mut dest), &mut destlen, *c)
} else if inset(&lower, *c) {
charcopy(rewrap_option(&mut dest), &mut destlen, *c + 32)
} else {
escape3(rewrap_option(&mut dest), &mut destlen, *c)
}
}
destlen
}
fn aux_encode(dest: Option<&mut [u8]>, src: &[u8]) -> usize {
let twobytes = [0; 8];
let onebyte: [u32; 8] = [!0, 0xffff_3ffe, !0, !0, !0, !0, !0, !0];
_encode(&twobytes, &onebyte, dest, src, false)
}
fn hash_mangle(src: &[u8], sha: &[u8]) -> Vec<u8> {
let dirprefixlen = 8;
let maxshortdirslen = 68;
let mut destlen = 0;
let last_slash = src.iter().rposition(|b| *b == b'/');
let last_dot: Option<usize> = {
let s = last_slash.unwrap_or(0);
src[s..]
.iter()
.rposition(|b| *b == b'.')
.and_then(|i| Some(i + s))
};
let mut dest = vec![0; MAXSTOREPATHLEN];
memcopy(Some(&mut dest), &mut destlen, b"dh/");
{
let mut first = true;
for slice in src[..last_slash.unwrap_or_else(|| src.len())]
.split(|b| *b == b'/')
{
let slice = &slice[..std::cmp::min(slice.len(), dirprefixlen)];
if destlen + (slice.len() + if first { 0 } else { 1 })
> maxshortdirslen + 3
{
break;
} else {
if !first {
charcopy(Some(&mut dest), &mut destlen, b'/')
};
memcopy(Some(&mut dest), &mut destlen, slice);
if dest[destlen - 1] == b'.' || dest[destlen - 1] == b' ' {
dest[destlen - 1] = b'_'
}
}
first = false;
}
if !first {
charcopy(Some(&mut dest), &mut destlen, b'/');
}
}
let used = destlen + 40 + {
if let Some(l) = last_dot {
src.len() - l
} else {
0
}
};
if MAXSTOREPATHLEN > used {
let slop = MAXSTOREPATHLEN - used;
let basenamelen = match last_slash {
Some(l) => src.len() - l - 1,
None => src.len(),
};
let basenamelen = std::cmp::min(basenamelen, slop);
if basenamelen > 0 {
let start = match last_slash {
Some(l) => l + 1,
None => 0,
};
memcopy(
Some(&mut dest),
&mut destlen,
&src[start..][..basenamelen],
)
}
}
for c in sha {
hexencode(Some(&mut dest), &mut destlen, *c);
}
if let Some(l) = last_dot {
memcopy(Some(&mut dest), &mut destlen, &src[l..]);
}
if destlen == dest.len() {
dest
} else {
// sometimes the path are shorter than MAXSTOREPATHLEN
dest[..destlen].to_vec()
}
}
const MAXENCODE: usize = 4096 * 4;
fn hash_encode(src: &[u8]) -> Vec<u8> {
let dired = &mut [0; MAXENCODE];
let lowered = &mut [0; MAXENCODE];
let auxed = &mut [0; MAXENCODE];
let baselen = (src.len() - 5) * 3;
if baselen >= MAXENCODE {
panic!("path_encode::hash_encore: string too long: {}", baselen)
};
let dirlen = encode_dir(Some(&mut dired[..]), src);
let sha = {
let mut hasher = Sha1::new();
hasher.input(&dired[..dirlen]);
let mut hash = vec![0; 20];
hasher.result(&mut hash);
hash
};
let lowerlen = lower_encode(Some(&mut lowered[..]), &dired[..dirlen][5..]);
let auxlen = aux_encode(Some(&mut auxed[..]), &lowered[..lowerlen]);
hash_mangle(&auxed[..auxlen], &sha)
}
pub fn path_encode(path: &[u8]) -> Vec<u8> {
let newlen = if path.len() <= MAXSTOREPATHLEN {
basic_encode(None, path)
} else {
MAXSTOREPATHLEN + 1
};
if newlen <= MAXSTOREPATHLEN {
if newlen == path.len() {
path.to_vec()
} else {
let mut res = vec![0; newlen];
basic_encode(Some(&mut res), path);
res
}
} else {
hash_encode(&path)
}
}