Merge staging into closure-size

The most complex problems were from dealing with switches reverted in
the meantime (gcc5, gmp6, ncurses6).
It's likely that darwin is (still) broken nontrivially.

4 files changed, 299 insertions, 21 deletions

diff --git a/pkgs/development/compilers/openjdk/004_add-fontconfig.patch b/pkgs/development/compilers/openjdk/004_add-fontconfig.patch
new file mode 100644
index 000000000000..8172bc821905
--- /dev/null
+++ b/pkgs/development/compilers/openjdk/004_add-fontconfig.patch
@@ -0,0 +1,14 @@
+This patch was downloaded from https://aur.archlinux.org/cgit/aur.git/tree/?h=java8-openjdk
+More info can be found at http://www.infinality.net/forum/viewtopic.php?f=2&t=275
+diff -ur a/jdk/make/lib/Awt2dLibraries.gmk b/jdk/make/lib/Awt2dLibraries.gmk
+--- a/jdk/make/lib/Awt2dLibraries.gmk	2015-07-13 20:50:59.000000000 +0300
++++ b/jdk/make/lib/Awt2dLibraries.gmk	2015-08-24 12:12:22.930330643 +0300
+@@ -824,7 +824,7 @@
+     LDFLAGS := $(subst -Xlinker -z -Xlinker defs,,$(LDFLAGS_JDKLIB)) $(LDFLAGS_CXX_JDK) \
+         $(call SET_SHARED_LIBRARY_ORIGIN), \
+     LDFLAGS_SUFFIX := $(BUILD_LIBFONTMANAGER_FONTLIB), \
+-    LDFLAGS_SUFFIX_linux := -lawt $(LIBM) $(LIBCXX) -ljava -ljvm -lc, \
++    LDFLAGS_SUFFIX_linux := -lfontconfig -lawt $(LIBM) $(LIBCXX) -ljava -ljvm -lc, \
+     LDFLAGS_SUFFIX_solaris := -lawt -lawt_headless -lc $(LIBM) $(LIBCXX) -ljava -ljvm, \
+     LDFLAGS_SUFFIX_aix := -lawt -lawt_headless $(LIBM) $(LIBCXX) -ljava -ljvm,\
+     LDFLAGS_SUFFIX_macosx := -lawt $(LIBM) $(LIBCXX) -undefined dynamic_lookup \
diff --git a/pkgs/development/compilers/openjdk/005_enable-infinality.patch b/pkgs/development/compilers/openjdk/005_enable-infinality.patch
new file mode 100644
index 000000000000..f8de96989967
--- /dev/null
+++ b/pkgs/development/compilers/openjdk/005_enable-infinality.patch
@@ -0,0 +1,261 @@
+This patch was downloaded from https://aur.archlinux.org/cgit/aur.git/tree/?h=java8-openjdk
+More info can be found at http://www.infinality.net/forum/viewtopic.php?f=2&t=275
+diff -ur a/jdk/src/share/native/sun/font/freetypeScaler.c b/jdk/src/share/native/sun/font/freetypeScaler.c
+--- a/jdk/src/share/native/sun/font/freetypeScaler.c	2014-09-14 16:28:06.108295959 +0200
++++ b/jdk/src/share/native/sun/font/freetypeScaler.c	2014-09-14 16:28:45.569693174 +0200
+@@ -23,6 +23,9 @@
+  * questions.
+  */
+ 
++/* Use Infinality patches as default */
++#define INFINALITY
++
+ #include "jni.h"
+ #include "jni_util.h"
+ #include "jlong.h"
+@@ -38,6 +41,10 @@
+ #include FT_SIZES_H
+ #include FT_OUTLINE_H
+ #include FT_SYNTHESIS_H
++#ifdef INFINALITY
++#include FT_LCD_FILTER_H
++#include <fontconfig/fontconfig.h>
++#endif
+ 
+ #include "fontscaler.h"
+ 
+@@ -676,6 +683,147 @@ static void CopyFTSubpixelVToSubpixel(co
+     }
+ }
+ 
++#ifdef INFINALITY
++typedef struct {
++    FT_Render_Mode ftRenderMode;
++    int ftLoadFlags;
++    FT_LcdFilter ftLcdFilter;
++} RenderingProperties;
++
++static FcPattern* matchedPattern(const FcChar8* family, double ptSize) {
++    /*
++      we will create pattern to find our family and size in
++      fontconfig configuration, and then will return it's
++      properties:
++    */
++    FcPattern* fcPattern = 0;
++    fcPattern = FcPatternCreate();
++    FcValue fcValue;
++    fcValue.type = FcTypeString;
++    fcValue.u.s = family;
++    FcPatternAdd(fcPattern, FC_FAMILY, fcValue, FcTrue);
++    FcPatternAddBool(fcPattern, FC_SCALABLE, FcTrue);
++    FcPatternAddDouble(fcPattern, FC_SIZE, ptSize);
++    // TODO FcPatternAddInteger(pattern, FC_WEIGHT, weight_value);
++    // TODO FcPatternAddInteger(pattern, FC_SLANT, slant_value);
++    // TODO FcPatternAddDouble(pattern, FC_PIXEL_SIZE, size_value);
++    // TODO FcPatternAddInteger(pattern, FC_WIDTH, stretch); 100 in most cases
++    FcConfigSubstitute(0, fcPattern, FcMatchPattern);
++    FcConfigSubstitute(0, fcPattern, FcMatchFont);
++    FcDefaultSubstitute(fcPattern);
++    FcResult res;
++
++    FcPattern *pattern = 0;
++    pattern = FcFontMatch(0, fcPattern, &res);
++    FcPatternDestroy(fcPattern);
++    return pattern;
++}
++
++static void readFontconfig(const FcChar8* family, double ptSize, jint aaType, RenderingProperties* rp) {
++
++    FcPattern *pattern = matchedPattern(family, ptSize);
++
++    int ftLoadFalgs = FT_LOAD_DEFAULT;
++    FT_Render_Mode ftRenderMode;
++    FT_LcdFilter ftLcdFilter;
++    char horizontal = 1;
++    FcBool b;
++
++    // subpixel order:
++    if (aaType == TEXT_AA_ON)
++        ftRenderMode = FT_RENDER_MODE_NORMAL;
++    else if (aaType == TEXT_AA_OFF)
++        ftRenderMode = FT_RENDER_MODE_MONO;
++    else if (FcPatternGetBool(pattern, FC_ANTIALIAS, 0, &b) == FcResultMatch)
++        if (b) {
++            int subpixel = FC_RGBA_UNKNOWN;
++            FcPatternGetInteger(pattern, FC_RGBA, 0, &subpixel);
++            if (subpixel == FC_RGBA_UNKNOWN)
++                subpixel = FC_RGBA_NONE;
++                switch (subpixel) {
++                case FC_RGBA_NONE:
++                    ftRenderMode = FT_RENDER_MODE_NORMAL;
++                    break;
++                case FC_RGBA_RGB:
++                case FC_RGBA_BGR:
++                    ftRenderMode = FT_RENDER_MODE_LCD;
++                    horizontal = 1;
++                    break;
++                case FC_RGBA_VRGB:
++                case FC_RGBA_VBGR:
++                    ftRenderMode = FT_RENDER_MODE_LCD_V;
++                    horizontal = 0;
++                    break;
++                default:
++                    break;
++                }
++            } else {
++                ftRenderMode = FT_RENDER_MODE_NORMAL;
++            }
++
++    // loading mode:
++    if (aaType == TEXT_AA_OFF)
++        ftLoadFalgs |= FT_LOAD_TARGET_MONO;
++    else {
++        int hint_style = FC_HINT_NONE;
++        FcPatternGetInteger(pattern, FC_HINT_STYLE, 0, &hint_style);
++        switch (hint_style) {
++        case FC_HINT_NONE:
++            ftLoadFalgs |= FT_LOAD_NO_HINTING;
++            break;
++        case FC_HINT_SLIGHT:
++            ftLoadFalgs |= FT_LOAD_TARGET_LIGHT;
++            break;
++        case FC_HINT_MEDIUM:
++            ftLoadFalgs |= FT_LOAD_TARGET_NORMAL;
++            break;
++        case FC_HINT_FULL:
++            if (aaType == TEXT_AA_ON)
++                ftLoadFalgs |= FT_LOAD_TARGET_NORMAL;
++            else
++                ftLoadFalgs |= horizontal ? FT_LOAD_TARGET_LCD : FT_LOAD_TARGET_LCD_V;
++            break;
++        default:
++            // what else to use as default?
++            ftLoadFalgs |= FT_LOAD_TARGET_NORMAL;
++            break;
++        }
++    }
++
++    // autohinting:
++    if (FcPatternGetBool(pattern, FC_AUTOHINT, 0, &b) == FcResultMatch)
++        if (b)
++            ftLoadFalgs |= FT_LOAD_FORCE_AUTOHINT;
++
++    // LCD filter:
++    int filter = FC_LCD_DEFAULT;
++    FcPatternGetInteger(pattern, FC_LCD_FILTER, 0, &filter);
++    switch (filter) {
++    case FC_LCD_NONE:
++        ftLcdFilter = FT_LCD_FILTER_NONE;
++        break;
++    case FC_LCD_DEFAULT:
++        ftLcdFilter = FT_LCD_FILTER_DEFAULT;
++        break;
++    case FC_LCD_LIGHT:
++        ftLcdFilter = FT_LCD_FILTER_LIGHT;
++        break;
++    case FC_LCD_LEGACY:
++        ftLcdFilter = FT_LCD_FILTER_LEGACY;
++        break;
++    default:
++        // new unknown lcd filter type?! will use default one:
++        ftLcdFilter = FT_LCD_FILTER_DEFAULT;
++        break;
++    }
++
++    FcPatternDestroy(pattern);
++
++    rp->ftRenderMode = ftRenderMode;
++    rp->ftLoadFlags = ftLoadFalgs;
++    rp->ftLcdFilter = ftLcdFilter;
++}
++#endif
+ 
+ /*
+  * Class:     sun_font_FreetypeFontScaler
+@@ -691,7 +839,9 @@ Java_sun_font_FreetypeFontScaler_getGlyp
+     UInt16 width, height;
+     GlyphInfo *glyphInfo;
+     int glyph_index;
++#ifndef INFINALITY
+     int renderFlags = FT_LOAD_RENDER, target;
++#endif
+     FT_GlyphSlot ftglyph;
+ 
+     FTScalerContext* context =
+@@ -709,6 +859,11 @@ Java_sun_font_FreetypeFontScaler_getGlyp
+         return ptr_to_jlong(getNullGlyphImage());
+     }
+ 
++#ifdef INFINALITY
++    RenderingProperties renderingProperties;
++    readFontconfig((const FcChar8 *) scalerInfo->face->family_name,
++                   context->ptsz, context->aaType, &renderingProperties);
++#else
+     /* if algorithmic styling is required then we do not request bitmap */
+     if (context->doBold || context->doItalize) {
+         renderFlags =  FT_LOAD_DEFAULT;
+@@ -731,10 +886,17 @@ Java_sun_font_FreetypeFontScaler_getGlyp
+         target = FT_LOAD_TARGET_LCD_V;
+     }
+     renderFlags |= target;
++#endif
+ 
+     glyph_index = FT_Get_Char_Index(scalerInfo->face, glyphCode);
+ 
++#ifdef INFINALITY
++    FT_Library_SetLcdFilter(scalerInfo->library, renderingProperties.ftLcdFilter);
++    error = FT_Load_Glyph(scalerInfo->face, glyphCode, renderingProperties.ftLoadFlags);
++#else
+     error = FT_Load_Glyph(scalerInfo->face, glyphCode, renderFlags);
++#endif
++
+     if (error) {
+         //do not destroy scaler yet.
+         //this can be problem of particular context (e.g. with bad transform)
+@@ -753,9 +915,13 @@ Java_sun_font_FreetypeFontScaler_getGlyp
+ 
+     /* generate bitmap if it is not done yet
+      e.g. if algorithmic styling is performed and style was added to outline */
++#ifdef INFINALITY
++    FT_Render_Glyph(ftglyph, renderingProperties.ftRenderMode);
++#else
+     if (ftglyph->format == FT_GLYPH_FORMAT_OUTLINE) {
+         FT_Render_Glyph(ftglyph, FT_LOAD_TARGET_MODE(target));
+     }
++#endif
+ 
+     width  = (UInt16) ftglyph->bitmap.width;
+     height = (UInt16) ftglyph->bitmap.rows;
+@@ -969,7 +1135,9 @@ Java_sun_font_FreetypeFontScaler_getGlyp
+ static FT_Outline* getFTOutline(JNIEnv* env, jobject font2D,
+         FTScalerContext *context, FTScalerInfo* scalerInfo,
+         jint glyphCode, jfloat xpos, jfloat ypos) {
++#ifndef INFINALITY
+     int renderFlags;
++#endif
+     int glyph_index;
+     FT_Error error;
+     FT_GlyphSlot ftglyph;
+@@ -984,11 +1152,22 @@ static FT_Outline* getFTOutline(JNIEnv*
+         return NULL;
+     }
+ 
++#ifdef INFINALITY
++    RenderingProperties renderingProperties;
++    readFontconfig((const FcChar8 *) scalerInfo->face->family_name,
++                   context->ptsz, context->aaType, &renderingProperties);
++#else
+     renderFlags = FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP;
++#endif
+ 
+     glyph_index = FT_Get_Char_Index(scalerInfo->face, glyphCode);
+ 
++#ifdef INFINALITY
++    error = FT_Load_Glyph(scalerInfo->face, glyphCode, renderingProperties.ftLoadFlags);
++#else
+     error = FT_Load_Glyph(scalerInfo->face, glyphCode, renderFlags);
++#endif
++
+     if (error) {
+         return NULL;
+     }
diff --git a/pkgs/development/compilers/openjdk/7.nix b/pkgs/development/compilers/openjdk/7.nix
index 12d32a134c8e..de803a5d90c5 100644
--- a/pkgs/development/compilers/openjdk/7.nix
+++ b/pkgs/development/compilers/openjdk/7.nix
@@ -17,9 +17,9 @@ let
     else
       throw "openjdk requires i686-linux or x86_64 linux";
 
-  update = "80";
+  update = "91";
 
-  build = "32";
+  build = "01";
 
   # On x86 for heap sizes over 700MB disable SEGMEXEC and PAGEEXEC as well.
   paxflags = if stdenv.isi686 then "msp" else "m";
@@ -33,31 +33,31 @@ let
   repover = "jdk7u${update}-b${build}";
   jdk7 = fetchurl {
     url = "${baseurl}/archive/${repover}.tar.gz";
-    sha256 = "1r8xnn87nmqaq2f8i3cp3i9ngq66k0c0wgkdq5cf59lkgs8wkcdi";
+    sha256 = "08f7cbayyrryim3xbrs12cr12i1mczcikyc9rdlsyih0r4xvll28";
   };
   langtools = fetchurl {
     url = "${baseurl}/langtools/archive/${repover}.tar.gz";
-    sha256 = "01alj6pfrjqyf4irll9wg34h4w9nmb3973lvbacs528qm1nxgh9r";
+    sha256 = "0rmlzrgsacn60blpg1sp30k6p0sgzsml8wb41yc998km1bsnjxnh";
   };
   hotspot = fetchurl {
     url = "${baseurl}/hotspot/archive/${repover}.tar.gz";
-    sha256 = "14zla8axmg5344zf45i4cj7yyli0kmdjsh9yalmzqaphpkqjqpf2";
+    sha256 = "1w1n81y9jcvjzssl4049yzfc0gdfnh73ki6wg1d8pg22zlyhrrwv";
   };
   corba = fetchurl {
     url = "${baseurl}/corba/archive/${repover}.tar.gz";
-    sha256 = "19z3ay3f2q7r2ra03c6wy8b5rbdbrkq5g2dzhrqcg0n4iydd3c40";
+    sha256 = "086yr927bxnlgljx7mw2cg6f6aip57hi4qpn1h35n6fsyvb4n67h";
   };
   jdk = fetchurl {
     url = "${baseurl}/jdk/archive/${repover}.tar.gz";
-    sha256 = "1q0r2l9bz2cyx4fq79x6cb2f5xycw83hl5cn1d1mazgsckp590lb";
+    sha256 = "14r39ylj3qa63arpqxl0h84baah1kjgnyp3v9d7d4vd0yagpn66b";
   };
   jaxws = fetchurl {
     url = "${baseurl}/jaxws/archive/${repover}.tar.gz";
-    sha256 = "1lp0mww2x3b6xavb7idrzckh6iw8jd6s1fvqgfvzs853z4ifksqj";
+    sha256 = "1p1739gb5gx9m4sm3i4javfk9lk41wnz92k6gis6sq99dd1bj1l5";
   };
   jaxp = fetchurl {
     url = "${baseurl}/jaxp/archive/${repover}.tar.gz";
-    sha256 = "0pd874dkgxkb7frxg4n9py61kkhhck4x33dcynynwb3vl6k6iy79";
+    sha256 = "1nl3kmbwqhhymcp25rnmf5mr3dn87lgdxvz9wgng7if6yqxlyakq";
   };
   openjdk = stdenv.mkDerivation rec {
     name = "openjdk-7u${update}b${build}";
@@ -100,7 +100,6 @@ let
       ./paxctl.patch
       ./read-truststore-from-env.patch
       ./currency-date-range.patch
-      ./linux-4.0.patch
     ];
 
     NIX_NO_SELF_RPATH = true;
diff --git a/pkgs/development/compilers/openjdk/8.nix b/pkgs/development/compilers/openjdk/8.nix
index 1a280b1d542d..48d7dd5dffbf 100644
--- a/pkgs/development/compilers/openjdk/8.nix
+++ b/pkgs/development/compilers/openjdk/8.nix
@@ -2,6 +2,7 @@
 , alsaLib, bootjdk, cacert, perl, liberation_ttf, fontconfig, zlib
 , setJavaClassPath
 , minimal ? false
+, enableInfinality ? true # font rendering patch
 }:
 
 let
@@ -17,42 +18,42 @@ let
     else
       throw "openjdk requires i686-linux or x86_64 linux";
 
-  update = "60";
-  build = "24";
+  update = "76";
+  build = "00";
   baseurl = "http://hg.openjdk.java.net/jdk8u/jdk8u";
   repover = "jdk8u${update}-b${build}";
   paxflags = if stdenv.isi686 then "msp" else "m";
   jdk8 = fetchurl {
              url = "${baseurl}/archive/${repover}.tar.gz";
-             sha256 = "1gxfyz5kdl3xgfmn6gr65hj66zh5p67y1g0hxdbps1h8gcc6iqwp";
+             sha256 = "1bzwrm18vdd531xxin7pzsc5dx2ybkdgdxz6jp2ki19ka6pmk1l7";
           };
   langtools = fetchurl {
              url = "${baseurl}/langtools/archive/${repover}.tar.gz";
-             sha256 = "0a8kmfcnw92hvhivmpa9g22k1lvcr64zjw7x1gjj1j6zx7r579ck";
+             sha256 = "044gyb7hgrahlr78vah9r3wfv6w569ihqzwqplwzr6m0l1s52994";
           };
   hotspot = fetchurl {
              url = "${baseurl}/hotspot/archive/${repover}.tar.gz";
-             sha256 = "0k68wqwg5fz8i2za9dg2zfx4db5zcbls31vk2abrqrwp31ik0y4y";
+             sha256 = "1if70s9wjsvmrdj92ky88ngpmigi9c5gfpkilpydzdibs38f05f8";
           };
   corba = fetchurl {
              url = "${baseurl}/corba/archive/${repover}.tar.gz";
-             sha256 = "0rc8m5jrwjzrbxnzbhxjm265z23ky6v11g8sgcb6flr0l636fwvn";
+             sha256 = "0fl852x25cjzz3lrhjnhj59qbb4m3ywwc2f9vbj6mqdnpzl7cg83";
           };
   jdk = fetchurl {
              url = "${baseurl}/jdk/archive/${repover}.tar.gz";
-             sha256 = "11c90zz728p30zc6zas9ip67n9sd09i0v6afxs608k9s451057wr";
+             sha256 = "11ql3p5fsizrn1fiylfkgrw0lgf6snwyich18hggsmd00bhvv3ah";
           };
   jaxws = fetchurl {
              url = "${baseurl}/jaxws/archive/${repover}.tar.gz";
-             sha256 = "15pzczqwrr47qv51bsisjylilhljban8938n1436hsjd5k1dhhwn";
+             sha256 = "1d2q4bbvlz557caqciwpd5ms9f14bjk8jl5zlfflqnww9b097qy4";
           };
   jaxp = fetchurl {
              url = "${baseurl}/jaxp/archive/${repover}.tar.gz";
-             sha256 = "0gcc7pb07yl76drcynpz5gjjv3y6s1c0k4kfp9fayha5f624k1fb";
+             sha256 = "0nrd4c77ggxkyv2271k30afbjjcp0kybc8gcypmhy8by54w4ap0j";
           };
   nashorn = fetchurl {
              url = "${baseurl}/nashorn/archive/${repover}.tar.gz";
-             sha256 = "00g849wwqxljqpml6r7rv3pscj0ma0jaamyvxsxlfxbqvwid93ai";
+             sha256 = "11idvkzk4nqhhw4xq5pl03g4gwnaiq021xxj2yx54rixr59zl0q6";
           };
   openjdk8 = stdenv.mkDerivation {
     name = "openjdk-8u${update}b${build}";
@@ -81,7 +82,10 @@ let
       ./fix-java-home-jdk8.patch
       ./read-truststore-from-env-jdk8.patch
       ./currency-date-range-jdk8.patch
-    ];
+    ] ++ (if enableInfinality then [
+      ./004_add-fontconfig.patch
+      ./005_enable-infinality.patch
+    ] else []);
 
     preConfigure = ''
       chmod +x configure