From f1b8b764d2da0b4a1de7fee1e3cfa70125e13ddc Mon Sep 17 00:00:00 2001 From: oaken-source Date: Mon, 18 Nov 2019 01:12:58 +0100 Subject: libre/icedove: updated to 68.2.2 --- libre/icedove/PKGBUILD | 32 +- libre/icedove/libre-searchengines.patch | 700 +++++++++++++++++++++++++++--- libre/icedove/thunderbird-rust-1.39.patch | 170 ++++++++ 3 files changed, 822 insertions(+), 80 deletions(-) create mode 100644 libre/icedove/thunderbird-rust-1.39.patch diff --git a/libre/icedove/PKGBUILD b/libre/icedove/PKGBUILD index 8d5afb25c..3e9963888 100644 --- a/libre/icedove/PKGBUILD +++ b/libre/icedove/PKGBUILD @@ -19,17 +19,16 @@ _pkgname=thunderbird pkgname=icedove replaces=("$_pkgname") -pkgver=68.1.0 -pkgrel=1 +pkgver=68.2.2 +pkgrel=2 pkgrel+=.parabola1 -_brandingver=60.5 +_brandingver=68.2 _brandingrel=1 -pkgdesc="Libre standalone mail and news reader based on Mozilla Thunderbird" +pkgdesc='Standalone mail and news reader based on Mozilla Thunderbird' url="https://wiki.parabola.nu/$pkgname" arch=(x86_64) arch+=(i686 armv7h) license=(MPL GPL LGPL) - depends=(gtk3 mozilla-common libxt startup-notification mime-types dbus-glib alsa-lib nss hunspell sqlite ttf-font icu) # libvpx makedepends=(unzip zip diffutils python python2 yasm nasm mesa imake libpulse inetutils xorg-server-xvfb @@ -39,20 +38,26 @@ optdepends=('libcanberra: sound support') options=(!emptydirs !makeflags) source=(https://ftp.mozilla.org/pub/mozilla.org/thunderbird/releases/$pkgver/source/thunderbird-$pkgver.source.tar.xz{,.asc} $pkgname.desktop - https://repo.parabola.nu/other/icedove/${pkgname}_$_brandingver-$_brandingrel.branding.tar.xz{,.sig} - libre-searchengines.patch) -sha256sums=('de0e5c7d1d5576f451e386e4779f155b7af97621a4e22caac0c6dee3c9d76eef' + thunderbird-rust-1.39.patch) +source+=( + https://repo.parabola.nu/other/icedove/${pkgname}_$_brandingver-$_brandingrel.branding.tar.xz{,.sig} + libre-searchengines.patch) +sha256sums=('c17edbcde0e9e7599cda16b69b130039f69113b498ea394057cedfae153f0dd3' 'SKIP' 'af8199a12ebe09189d143458bd1e2d0071aff3410ed121dc2329a448a56632f0' - '590862b39ba7baf60e47240e33de5839a8e85b6831c839ea57481968c9020241' + '08834ef1c2dd685edd40dea20dfa9d4b889f5c387385ac329a162eeff6cf90be' + 'b36792a6fcbe68841bc842723222c88ecf1f54f7f75bd634b216b61f3ae422f2' 'SKIP' - '9ef9dd18ac1f76ccc3d5d2ace866bb40199fd00a1192da83aef376c585be2ec3') + '072bba9d9ef4cfcb03b3776a15e52020e05c685add38329bd041f680026f5898') validpgpkeys=(14F26682D0916CDD81E37B6D61B7B526D98F0353) # Mozilla Software Releases validpgpkeys+=(BFA8008A8265677063B11BF47171986E4B745536) # Andreas Grapentin prepare() { cd $_pkgname-$pkgver + patch -p1 -i ../thunderbird-rust-1.39.patch # Fix build with rust 1.39 (Gentoo) + + cat >.mozconfig < Option { +- use self::HasVtableResult::*; +- +- match (*self, *rhs) { +- (x, y) if x == y => Some(cmp::Ordering::Equal), +- (BaseHasVtable, _) => Some(cmp::Ordering::Greater), +- (_, BaseHasVtable) => Some(cmp::Ordering::Less), +- (SelfHasVtable, _) => Some(cmp::Ordering::Greater), +- (_, SelfHasVtable) => Some(cmp::Ordering::Less), +- _ => unreachable!(), +- } +- } +-} +- + impl HasVtableResult { + /// Take the least upper bound of `self` and `rhs`. + pub fn join(self, rhs: Self) -> Self { +--- a/third_party/rust/bindgen/src/ir/analysis/sizedness.rs ++++ b/third_party/rust/bindgen/src/ir/analysis/sizedness.rs +@@ -22,13 +22,14 @@ use {HashMap, Entry}; + /// + /// We initially assume that all types are `ZeroSized` and then update our + /// understanding as we learn more about each type. +-#[derive(Copy, Clone, Debug, PartialEq, Eq, Ord)] ++#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] + pub enum SizednessResult { +- /// Has some size that is known to be greater than zero. That doesn't mean +- /// it has a static size, but it is not zero sized for sure. In other words, +- /// it might contain an incomplete array or some other dynamically sized +- /// type. +- NonZeroSized, ++ /// The type is zero-sized. ++ /// ++ /// This means that if it is a C++ type, and is not being used as a base ++ /// member, then we must add an `_address` byte to enforce the ++ /// unique-address-per-distinct-object-instance rule. ++ ZeroSized, + + /// Whether this type is zero-sized or not depends on whether a type + /// parameter is zero-sized or not. +@@ -52,12 +53,11 @@ pub enum SizednessResult { + /// https://github.com/rust-lang-nursery/rust-bindgen/issues/586 + DependsOnTypeParam, + +- /// The type is zero-sized. +- /// +- /// This means that if it is a C++ type, and is not being used as a base +- /// member, then we must add an `_address` byte to enforce the +- /// unique-address-per-distinct-object-instance rule. +- ZeroSized, ++ /// Has some size that is known to be greater than zero. That doesn't mean ++ /// it has a static size, but it is not zero sized for sure. In other words, ++ /// it might contain an incomplete array or some other dynamically sized ++ /// type. ++ NonZeroSized, + } + + impl Default for SizednessResult { +@@ -66,21 +66,6 @@ impl Default for SizednessResult { + } + } + +-impl cmp::PartialOrd for SizednessResult { +- fn partial_cmp(&self, rhs: &Self) -> Option { +- use self::SizednessResult::*; +- +- match (*self, *rhs) { +- (x, y) if x == y => Some(cmp::Ordering::Equal), +- (NonZeroSized, _) => Some(cmp::Ordering::Greater), +- (_, NonZeroSized) => Some(cmp::Ordering::Less), +- (DependsOnTypeParam, _) => Some(cmp::Ordering::Greater), +- (_, DependsOnTypeParam) => Some(cmp::Ordering::Less), +- _ => unreachable!(), +- } +- } +-} +- + impl SizednessResult { + /// Take the least upper bound of `self` and `rhs`. + pub fn join(self, rhs: Self) -> Self { +--- a/third_party/rust/bindgen/src/ir/derive.rs ++++ b/third_party/rust/bindgen/src/ir/derive.rs +@@ -92,10 +92,10 @@ pub trait CanDeriveOrd { + /// + /// Initially we assume that we can derive trait for all types and then + /// update our understanding as we learn more about each type. +-#[derive(Debug, Copy, Clone, PartialEq, Eq, Ord)] ++#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)] + pub enum CanDerive { +- /// No, we cannot. +- No, ++ /// Yes, we can derive automatically. ++ Yes, + + /// The only thing that stops us from automatically deriving is that + /// array with more than maximum number of elements is used. +@@ -103,8 +103,8 @@ pub enum CanDerive { + /// This means we probably can "manually" implement such trait. + Manually, + +- /// Yes, we can derive automatically. +- Yes, ++ /// No, we cannot. ++ No, + } + + impl Default for CanDerive { +@@ -113,22 +113,6 @@ impl Default for CanDerive { + } + } + +-impl cmp::PartialOrd for CanDerive { +- fn partial_cmp(&self, rhs: &Self) -> Option { +- use self::CanDerive::*; +- +- let ordering = match (*self, *rhs) { +- (x, y) if x == y => cmp::Ordering::Equal, +- (No, _) => cmp::Ordering::Greater, +- (_, No) => cmp::Ordering::Less, +- (Manually, _) => cmp::Ordering::Greater, +- (_, Manually) => cmp::Ordering::Less, +- _ => unreachable!() +- }; +- Some(ordering) +- } +-} +- + impl CanDerive { + /// Take the least upper bound of `self` and `rhs`. + pub fn join(self, rhs: Self) -> Self { -- cgit v1.2.3