Merge pull request #12742 from phobon/init_exceptions

Follow up changes for InitError

Author: JeffBezanson

base/gmp.jl

@@ -53,19 +53,24 @@ _gmp_clear_func = C_NULL
 _mpfr_clear_func = C_NULL
 
 function __init__()
-    if gmp_version().major != GMP_VERSION.major || gmp_bits_per_limb() != GMP_BITS_PER_LIMB
-        error(string("The dynamically loaded GMP library (version $(gmp_version()) with __gmp_bits_per_limb == $(gmp_bits_per_limb()))\n",
-                     "does not correspond to the compile time version (version $GMP_VERSION with __gmp_bits_per_limb == $GMP_BITS_PER_LIMB).\n",
-                     "Please rebuild Julia."))
-    end
+    try
+        if gmp_version().major != GMP_VERSION.major || gmp_bits_per_limb() != GMP_BITS_PER_LIMB
+            error(string("The dynamically loaded GMP library (version $(gmp_version()) with __gmp_bits_per_limb == $(gmp_bits_per_limb()))\n",
+                         "does not correspond to the compile time version (version $GMP_VERSION with __gmp_bits_per_limb == $GMP_BITS_PER_LIMB).\n",
+                         "Please rebuild Julia."))
+        end
 
-    global _gmp_clear_func = cglobal((:__gmpz_clear, :libgmp))
-    global _mpfr_clear_func = cglobal((:mpfr_clear, :libmpfr))
-    ccall((:__gmp_set_memory_functions, :libgmp), Void,
-          (Ptr{Void},Ptr{Void},Ptr{Void}),
-          cglobal(:jl_gc_counted_malloc),
-          cglobal(:jl_gc_counted_realloc_with_old_size),
-          cglobal(:jl_gc_counted_free))
+        global _gmp_clear_func = cglobal((:__gmpz_clear, :libgmp))
+        global _mpfr_clear_func = cglobal((:mpfr_clear, :libmpfr))
+        ccall((:__gmp_set_memory_functions, :libgmp), Void,
+              (Ptr{Void},Ptr{Void},Ptr{Void}),
+              cglobal(:jl_gc_counted_malloc),
+              cglobal(:jl_gc_counted_realloc_with_old_size),
+              cglobal(:jl_gc_counted_free))
+    catch ex
+        Base.showerror_nostdio(ex,
+            "WARNING: Error during initialization of module GMP")
+    end
 end
 
 widen(::Type{Int128})  = BigInt

base/linalg.jl

@@ -236,9 +236,14 @@ include("linalg/arpack.jl")
 include("linalg/arnoldi.jl")
 
 function __init__()
-    Base.check_blas()
-    if Base.blas_vendor() == :mkl
-        ccall((:MKL_Set_Interface_Layer, Base.libblas_name), Void, (Cint,), USE_BLAS64 ? 1 : 0)
+    try
+        Base.check_blas()
+        if Base.blas_vendor() == :mkl
+            ccall((:MKL_Set_Interface_Layer, Base.libblas_name), Void, (Cint,), USE_BLAS64 ? 1 : 0)
+        end
+    catch ex
+        Base.showerror_nostdio(ex,
+            "WARNING: Error during initialization of module LinAlg")
     end
 end
 

base/mpfr.jl

@@ -30,9 +30,14 @@ import Base.GMP: ClongMax, CulongMax, CdoubleMax
 import Base.Math.lgamma_r
 
 function __init__()
-    # set exponent to full range by default
-    set_emin!(get_emin_min())
-    set_emax!(get_emax_max())
+    try
+        # set exponent to full range by default
+        set_emin!(get_emin_min())
+        set_emax!(get_emax_max())
+    catch ex
+        Base.showerror_nostdio(ex,
+            "WARNING: Error during initialization of module MPFR")
+    end
 end
 
 const ROUNDING_MODE = Cint[0]

base/pcre.jl

@@ -12,15 +12,20 @@ global JIT_STACK = C_NULL
 global MATCH_CONTEXT = C_NULL
 
 function __init__()
-    JIT_STACK_START_SIZE = 32768
-    JIT_STACK_MAX_SIZE = 1048576
-    global JIT_STACK = ccall((:pcre2_jit_stack_create_8, PCRE_LIB), Ptr{Void},
-                             (Cint, Cint, Ptr{Void}),
-                             JIT_STACK_START_SIZE, JIT_STACK_MAX_SIZE, C_NULL)
-    global MATCH_CONTEXT = ccall((:pcre2_match_context_create_8, PCRE_LIB),
-                                 Ptr{Void}, (Ptr{Void},), C_NULL)
-    ccall((:pcre2_jit_stack_assign_8, PCRE_LIB), Void,
-          (Ptr{Void}, Ptr{Void}, Ptr{Void}), MATCH_CONTEXT, C_NULL, JIT_STACK)
+    try
+        JIT_STACK_START_SIZE = 32768
+        JIT_STACK_MAX_SIZE = 1048576
+        global JIT_STACK = ccall((:pcre2_jit_stack_create_8, PCRE_LIB), Ptr{Void},
+                                 (Cint, Cint, Ptr{Void}),
+                                 JIT_STACK_START_SIZE, JIT_STACK_MAX_SIZE, C_NULL)
+        global MATCH_CONTEXT = ccall((:pcre2_match_context_create_8, PCRE_LIB),
+                                     Ptr{Void}, (Ptr{Void},), C_NULL)
+        ccall((:pcre2_jit_stack_assign_8, PCRE_LIB), Void,
+              (Ptr{Void}, Ptr{Void}, Ptr{Void}), MATCH_CONTEXT, C_NULL, JIT_STACK)
+    catch ex
+        Base.showerror_nostdio(ex,
+            "WARNING: Error during initialization of module PCRE")
+    end
 end
 
 # supported options for different use cases

base/random.jl

@@ -128,7 +128,14 @@ randjump(r::MersenneTwister, jumps::Integer) = randjump(r, jumps, dSFMT.JPOLY1e2
 
 ## initialization
 
-__init__() = srand()
+function __init__()
+    try
+        srand()
+    catch ex
+        Base.showerror_nostdio(ex,
+            "WARNING: Error during initialization of module Random")
+    end
+end
 
 
 ## make_seed()

base/replutil.jl

@@ -191,6 +191,17 @@ function showerror(io::IO, ex::MethodError)
     show_method_candidates(io, ex)
 end
 
+#Show an error by directly calling jl_printf.
+#Useful in Base submodule __init__ functions where STDERR isn't defined yet.
+function showerror_nostdio(err, msg::AbstractString)
+    stderr_stream = ccall(:jl_stderr_stream, Ptr{Void}, ())
+    ccall(:jl_printf, UInt, (Ptr{Void},Cstring), stderr_stream, msg)
+    ccall(:jl_printf, UInt, (Ptr{Void},Cstring), stderr_stream, ":\n")
+    ccall(:jl_static_show, UInt, (Ptr{Void},Ptr{Void}), stderr_stream,
+          pointer_from_objref(err))
+    ccall(:jl_printf, UInt, (Ptr{Void},Cstring), stderr_stream, "\n")
+end
+
 const UNSHOWN_METHODS = ObjectIdDict(
     which(call, Tuple{Type, Vararg{Any}}) => true
 )

base/sparse/cholmod.jl

@@ -63,94 +63,106 @@ end
 const version = VersionNumber(version_array...)
 
 function __init__()
-    ### Check if the linked library is compatible with the Julia code
-    if Libdl.dlsym(Libdl.dlopen("libcholmod"), :cholmod_version) == C_NULL
-        hasversion = false
-        warn("""
-
-            CHOLMOD version incompatibility
-
-            Julia was compiled with CHOLMOD version $version. It is
-            currently linked with a version older than 2.1.0. This
-            might cause Julia to terminate when working with sparse
-            matrix factorizations, e.g. solving systems of equations
-            with \\.
-
-            It is recommended that you use Julia with a recent version
-            of CHOLMOD, or download the OS X or generic Linux binaries
-            from www.julialang.org, which ship with the correct
-            versions of all dependencies.
-        """)
-    else
-        hasversion = true
-        tmp = Array(Cint, 3)
-        ccall((:cholmod_version, :libcholmod), Cint, (Ptr{Cint},), version_array)
-        ccall((:jl_cholmod_version, :libsuitesparse_wrapper), Cint, (Ptr{Cint},), tmp)
-        if tmp != version_array
+    try
+        ### Check if the linked library is compatible with the Julia code
+        if Libdl.dlsym(Libdl.dlopen("libcholmod"), :cholmod_version) == C_NULL
+            hasversion = false
             warn("""
 
-                 CHOLMOD version incompatibility
+                CHOLMOD version incompatibility
 
-                 Julia was compiled with CHOLMOD version $version. It
-                 is currently linked with a version older than
-                 $(VersionNumber(tmp...)). This might cause Julia to
-                 terminate when working with sparse matrix
-                 factorizations, e.g. solving systems of equations
-                 with \\.
+                Julia was compiled with CHOLMOD version $version. It is
+                currently linked with a version older than 2.1.0. This
+                might cause Julia to terminate when working with sparse
+                matrix factorizations, e.g. solving systems of equations
+                with \\.
 
-                 It is recommended that you use Julia with a recent
-                 version of CHOLMOD, or download the OS X or generic
-                 Linux binary from www.julialang.org, which ship with
-                 the correct versions of all dependencies.
+                It is recommended that you use Julia with a recent version
+                of CHOLMOD, or download the OS X or generic Linux binaries
+                from www.julialang.org, which ship with the correct
+                versions of all dependencies.
             """)
+        else
+            hasversion = true
+            tmp = Array(Cint, 3)
+            ccall((:cholmod_version, :libcholmod), Cint, (Ptr{Cint},), version_array)
+            ccall((:jl_cholmod_version, :libsuitesparse_wrapper), Cint, (Ptr{Cint},), tmp)
+            if tmp != version_array
+                warn("""
+
+                     CHOLMOD version incompatibility
+
+                     Julia was compiled with CHOLMOD version $version. It
+                     is currently linked with a version older than
+                     $(VersionNumber(tmp...)). This might cause Julia to
+                     terminate when working with sparse matrix
+                     factorizations, e.g. solving systems of equations
+                     with \\.
+
+                     It is recommended that you use Julia with a recent
+                     version of CHOLMOD, or download the OS X or generic
+                     Linux binary from www.julialang.org, which ship with
+                     the correct versions of all dependencies.
+                """)
+            end
         end
-    end
 
-    intsize = Int(ccall((:jl_cholmod_sizeof_long,:libsuitesparse_wrapper),Csize_t,()))
-    if intsize != 4length(IndexTypes)
-        warn("""
+        intsize = Int(ccall((:jl_cholmod_sizeof_long,:libsuitesparse_wrapper),Csize_t,()))
+        if intsize != 4length(IndexTypes)
+            warn("""
 
-             CHOLMOD integer size incompatibility
+                 CHOLMOD integer size incompatibility
 
-             Julia was compiled with a version of CHOLMOD that
-             supported $(32length(IndexTypes)) bit integers. It is
-             currently linked with version that supports $(8intsize)
-             integers. This might cause Julia to terminate when
-             working with sparse matrix factorizations, e.g. solving
-             systems of equations with \\.
+                 Julia was compiled with a version of CHOLMOD that
+                 supported $(32length(IndexTypes)) bit integers. It is
+                 currently linked with version that supports $(8intsize)
+                 integers. This might cause Julia to terminate when
+                 working with sparse matrix factorizations, e.g. solving
+                 systems of equations with \\.
 
-             This problem can be fixed by modifying the Julia build
-             configuration or by downloading the OS X or generic
-             Linux binary from www.julialang.org, which include
-             the correct versions of all dependencies.
-         """)
-    end
+                 This problem can be fixed by modifying the Julia build
+                 configuration or by downloading the OS X or generic
+                 Linux binary from www.julialang.org, which include
+                 the correct versions of all dependencies.
+             """)
+        end
 
-    ### Initiate CHOLMOD
-    ### The common struct. Controls the type of factorization and keeps pointers
-    ### to temporary memory.
-    global const commonStruct = fill(0xff, common_size)
-
-    global const common_supernodal = convert(Ptr{Cint}, pointer(commonStruct, cholmod_com_offsets[4] + 1))
-    global const common_final_ll = convert(Ptr{Cint}, pointer(commonStruct, cholmod_com_offsets[7] + 1))
-    global const common_print = convert(Ptr{Cint}, pointer(commonStruct, cholmod_com_offsets[13] + 1))
-    global const common_itype = convert(Ptr{Cint}, pointer(commonStruct, cholmod_com_offsets[18] + 1))
-    global const common_dtype = convert(Ptr{Cint}, pointer(commonStruct, cholmod_com_offsets[19] + 1))
-    global const common_nmethods = convert(Ptr{Cint}, pointer(commonStruct, cholmod_com_offsets[15] + 1))
-    global const common_postorder = convert(Ptr{Cint}, pointer(commonStruct, cholmod_com_offsets[17] + 1))
-
-    start(commonStruct)              # initializes CHOLMOD
-    set_print_level(commonStruct, 0) # no printing from CHOLMOD by default
-
-    # Register gc tracked allocator if CHOLMOD is new enough
-    if hasversion && version >= v"3.0.0"
-        cnfg = cglobal((:SuiteSparse_config, :libsuitesparseconfig), Ptr{Void})
-        unsafe_store!(cnfg, cglobal(:jl_malloc, Ptr{Void}), 1)
-        unsafe_store!(cnfg, cglobal(:jl_calloc, Ptr{Void}), 2)
-        unsafe_store!(cnfg, cglobal(:jl_realloc, Ptr{Void}), 3)
-        unsafe_store!(cnfg, cglobal(:jl_free, Ptr{Void}), 4)
-    end
+        ### Initiate CHOLMOD
+        ### The common struct. Controls the type of factorization and keeps pointers
+        ### to temporary memory.
+        global const commonStruct = fill(0xff, common_size)
+
+        global const common_supernodal =
+            convert(Ptr{Cint}, pointer(commonStruct, cholmod_com_offsets[4] + 1))
+        global const common_final_ll =
+            convert(Ptr{Cint}, pointer(commonStruct, cholmod_com_offsets[7] + 1))
+        global const common_print =
+            convert(Ptr{Cint}, pointer(commonStruct, cholmod_com_offsets[13] + 1))
+        global const common_itype =
+            convert(Ptr{Cint}, pointer(commonStruct, cholmod_com_offsets[18] + 1))
+        global const common_dtype =
+            convert(Ptr{Cint}, pointer(commonStruct, cholmod_com_offsets[19] + 1))
+        global const common_nmethods =
+            convert(Ptr{Cint}, pointer(commonStruct, cholmod_com_offsets[15] + 1))
+        global const common_postorder =
+            convert(Ptr{Cint}, pointer(commonStruct, cholmod_com_offsets[17] + 1))
+
+        start(commonStruct)              # initializes CHOLMOD
+        set_print_level(commonStruct, 0) # no printing from CHOLMOD by default
+
+        # Register gc tracked allocator if CHOLMOD is new enough
+        if hasversion && version >= v"3.0.0"
+            cnfg = cglobal((:SuiteSparse_config, :libsuitesparseconfig), Ptr{Void})
+            unsafe_store!(cnfg, cglobal(:jl_malloc, Ptr{Void}), 1)
+            unsafe_store!(cnfg, cglobal(:jl_calloc, Ptr{Void}), 2)
+            unsafe_store!(cnfg, cglobal(:jl_realloc, Ptr{Void}), 3)
+            unsafe_store!(cnfg, cglobal(:jl_free, Ptr{Void}), 4)
+        end
 
+    catch ex
+        Base.showerror_nostdio(ex,
+            "WARNING: Error during initialization of module CHOLMOD")
+    end
 end
 
 function set_print_level(cm::Array{UInt8}, lev::Integer)

src/toplevel.c

@@ -587,13 +587,8 @@ jl_value_t *jl_parse_eval_all(const char *fname, size_t len)
             jl_rethrow();
         }
         else {
-            if(jl_typeis(jl_exception_in_transit, jl_initerror_type)) {
-                jl_rethrow();
-            }
-            else {
-                jl_rethrow_other(jl_new_struct(jl_loaderror_type, fn, ln,
-                                               jl_exception_in_transit));
-            }
+            jl_rethrow_other(jl_new_struct(jl_loaderror_type, fn, ln,
+                                           jl_exception_in_transit));
         }
     }
     jl_stop_parsing();

test/core.jl

@@ -692,12 +692,22 @@ end
 @test names(Module(:anonymous, false), true, true) == [:anonymous]
 
 # exception from __init__()
-@test_throws InitError include_string(
-    """
-    module TestInitError
-        __init__() = error()
+let didthrow =
+    try
+        include_string(
+            """
+            module TestInitError
+                __init__() = error()
+            end
+            """)
+        false
+    catch ex
+        @test isa(ex, LoadError)
+        @test isa(ex.error, InitError)
+        true
     end
-    """)
+    @test didthrow
+end
 
 # issue #7307
 function test7307(a, ret)