#38096

Committed 09 Jun 2025 04:48AM UTC coverage: 25.686% (-0.002%) from 25.688%

Build # #38096

Build Type

push

local

Committed by

web-flow

Commit Message

Adjust applescript workaround (#58673)

It turns out that there are two path types in applescript, and I had
mixed two of them in my previous patch. Annoyingly, things seemed to
work when editing locally, unsure why.

Run Details

12812 of 49879 relevant lines covered (25.69%)

710782.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

52.0

/stdlib/CompilerSupportLibraries_jll/src/CompilerSupportLibraries_jll.jl

# This file is a part of Julia. License is MIT: https://julialang.org/license

## dummy stub for https://github.com/JuliaBinaryWrappers/CompilerSupportLibraries_jll.jl

baremodule CompilerSupportLibraries_jll
using Base, Libdl, Base.BinaryPlatforms

export libgfortran, libstdcxx, libgomp, libatomic, libgcc_s

# These get calculated in __init__()
const PATH = Ref("")
const PATH_list = String[]
const LIBPATH = Ref("")
const LIBPATH_list = String[]
artifact_dir::String = ""

libatomic_path::String = ""
const libatomic = LazyLibrary(
    if Sys.iswindows()
        BundledLazyLibraryPath("libatomic-1.dll")
    elseif Sys.isapple()
        BundledLazyLibraryPath("libatomic.1.dylib")
    elseif Sys.isfreebsd()
        BundledLazyLibraryPath("libatomic.so.3")
    elseif Sys.islinux()
        BundledLazyLibraryPath("libatomic.so.1")
    else
        error("CompilerSupportLibraries_jll: Library 'libatomic' is not available for $(Sys.KERNEL)")
    end
)

if Sys.iswindows() || Sys.isapple() || arch(HostPlatform()) ∈ ("x86_64", "i686")
    global libquadmath_path::String = ""
    const libquadmath = LazyLibrary(
        if Sys.iswindows()
            BundledLazyLibraryPath("libquadmath-0.dll")
        elseif Sys.isapple()
            BundledLazyLibraryPath("libquadmath.0.dylib")
        elseif (Sys.islinux() || Sys.isfreebsd()) && arch(HostPlatform()) ∈ ("x86_64", "i686")
            BundledLazyLibraryPath("libquadmath.so.0")
        else
            error("CompilerSupportLibraries_jll: Library 'libquadmath' is not available for $(Sys.KERNEL)")
        end
    )
end

libgcc_s_path::String = ""
const libgcc_s = LazyLibrary(
    if Sys.iswindows()
        if arch(HostPlatform()) == "x86_64"
            BundledLazyLibraryPath("libgcc_s_seh-1.dll")
        else
            BundledLazyLibraryPath("libgcc_s_sjlj-1.dll")
        end
    elseif Sys.isapple()
        if arch(HostPlatform()) == "aarch64" || libgfortran_version(HostPlatform()) == v"5"
            BundledLazyLibraryPath("libgcc_s.1.1.dylib")
        else
            BundledLazyLibraryPath("libgcc_s.1.dylib")
        end
    elseif Sys.islinux() || Sys.isfreebsd()
        BundledLazyLibraryPath("libgcc_s.so.1")
    else
        error("CompilerSupportLibraries_jll: Library 'libgcc_s' is not available for $(Sys.KERNEL)")
    end
)

libgfortran_path::String = ""
const libgfortran = LazyLibrary(
    if Sys.iswindows()
        BundledLazyLibraryPath(string("libgfortran-", libgfortran_version(HostPlatform()).major, ".dll"))
    elseif Sys.isapple()
        BundledLazyLibraryPath(string("libgfortran.", libgfortran_version(HostPlatform()).major, ".dylib"))
    elseif Sys.islinux() || Sys.isfreebsd()
        BundledLazyLibraryPath(string("libgfortran.so.", libgfortran_version(HostPlatform()).major))
    else
        error("CompilerSupportLibraries_jll: Library 'libgfortran' is not available for $(Sys.KERNEL)")
    end;
    dependencies = @static if @isdefined(libquadmath)
        LazyLibrary[libgcc_s, libquadmath]
    else
        LazyLibrary[libgcc_s]
    end
)

libstdcxx_path::String = ""
const libstdcxx = LazyLibrary(
    if Sys.iswindows()
        BundledLazyLibraryPath("libstdc++-6.dll")
    elseif Sys.isapple()
        BundledLazyLibraryPath("libstdc++.6.dylib")
    elseif Sys.islinux() || Sys.isfreebsd()
        BundledLazyLibraryPath("libstdc++.so.6")
    else
        error("CompilerSupportLibraries_jll: Library 'libstdcxx' is not available for $(Sys.KERNEL)")
    end;
    dependencies = LazyLibrary[libgcc_s]
)

libgomp_path::String = ""
const libgomp = LazyLibrary(
    if Sys.iswindows()
        BundledLazyLibraryPath("libgomp-1.dll")
    elseif Sys.isapple()
        BundledLazyLibraryPath("libgomp.1.dylib")
    elseif Sys.islinux() || Sys.isfreebsd()
        BundledLazyLibraryPath("libgomp.so.1")
    else
        error("CompilerSupportLibraries_jll: Library 'libgomp' is not available for $(Sys.KERNEL)")
    end;
    dependencies = if Sys.iswindows()
        LazyLibrary[libgcc_s]
    else
        LazyLibrary[]
    end
)

# only define if isfile
let
    if Sys.iswindows() || Sys.isapple() || libc(HostPlatform()) != "musl"
        _libssp_path = if Sys.iswindows()
            BundledLazyLibraryPath("libssp-0.dll")
        elseif Sys.isapple()
            BundledLazyLibraryPath("libssp.0.dylib")
        elseif Sys.islinux() && libc(HostPlatform()) != "musl"
            BundledLazyLibraryPath("libssp.so.0")
        end
        if isfile(string(_libssp_path))
            global libssp_path::String = ""
            @eval const libssp = LazyLibrary($(_libssp_path))
        end
    end
end

# Conform to LazyJLLWrappers API
function eager_mode()
    if @isdefined(libatomic)
        dlopen(libatomic)
    end
    dlopen(libgcc_s)
    dlopen(libgomp)
    if @isdefined libquadmath
        dlopen(libquadmath)
    end
    if @isdefined libssp
        dlopen(libssp)
    end
    dlopen(libgfortran)
    dlopen(libstdcxx)
end
is_available() = true

function __init__()
    global libatomic_path = string(libatomic.path)
    global libgcc_s_path = string(libgcc_s.path)
    global libgomp_path = string(libgomp.path)
    if @isdefined libquadmath_path
        global libquadmath_path = string(libquadmath.path)
    end
    if @isdefined libssp_path
        global libssp_path = string(libssp.path)
    end
    global libgfortran_path = string(libgfortran.path)
    global libstdcxx_path = string(libstdcxx.path)
    global artifact_dir = dirname(Sys.BINDIR)
    LIBPATH[] = dirname(libgcc_s_path)
    push!(LIBPATH_list, LIBPATH[])
end

if Base.generating_output()
    precompile(eager_mode, ())
    precompile(is_available, ())
end

end  # module CompilerSupportLibraries_jll

1	# This file is a part of Julia. License is MIT: https://julialang.org/license
2
3	## dummy stub for https://github.com/JuliaBinaryWrappers/CompilerSupportLibraries_jll.jl
4
5	baremodule CompilerSupportLibraries_jll
6	using Base, Libdl, Base.BinaryPlatforms
7
8	export libgfortran, libstdcxx, libgomp, libatomic, libgcc_s
9
10	# These get calculated in __init__()
11	const PATH = Ref("")
12	const PATH_list = String[]
13	const LIBPATH = Ref("")
14	const LIBPATH_list = String[]
15	artifact_dir::String = ""
16
17	libatomic_path::String = ""
18	const libatomic = LazyLibrary(
19	if Sys.iswindows()
20	BundledLazyLibraryPath("libatomic-1.dll")
21	elseif Sys.isapple()
22	BundledLazyLibraryPath("libatomic.1.dylib")
23	elseif Sys.isfreebsd()
24	BundledLazyLibraryPath("libatomic.so.3")
25	elseif Sys.islinux()
26	BundledLazyLibraryPath("libatomic.so.1")
27	else
28	error("CompilerSupportLibraries_jll: Library 'libatomic' is not available for $(Sys.KERNEL)")
29	end
30	)
31
32	if Sys.iswindows() \|\| Sys.isapple() \|\| arch(HostPlatform()) ∈ ("x86_64", "i686")
33	global libquadmath_path::String = ""
34	const libquadmath = LazyLibrary(
35	if Sys.iswindows()
36	BundledLazyLibraryPath("libquadmath-0.dll")
37	elseif Sys.isapple()
38	BundledLazyLibraryPath("libquadmath.0.dylib")
39	elseif (Sys.islinux() \|\| Sys.isfreebsd()) && arch(HostPlatform()) ∈ ("x86_64", "i686")
40	BundledLazyLibraryPath("libquadmath.so.0")
41	else
42	error("CompilerSupportLibraries_jll: Library 'libquadmath' is not available for $(Sys.KERNEL)")
43	end
44	)
45	end
46
47	libgcc_s_path::String = ""
48	const libgcc_s = LazyLibrary(
49	if Sys.iswindows()
50	if arch(HostPlatform()) == "x86_64"
51	BundledLazyLibraryPath("libgcc_s_seh-1.dll")
52	else
53	BundledLazyLibraryPath("libgcc_s_sjlj-1.dll")
54	end
55	elseif Sys.isapple()
56	if arch(HostPlatform()) == "aarch64" \|\| libgfortran_version(HostPlatform()) == v"5"
57	BundledLazyLibraryPath("libgcc_s.1.1.dylib")
58	else
59	BundledLazyLibraryPath("libgcc_s.1.dylib")
60	end
61	elseif Sys.islinux() \|\| Sys.isfreebsd()
62	BundledLazyLibraryPath("libgcc_s.so.1")
63	else
64	error("CompilerSupportLibraries_jll: Library 'libgcc_s' is not available for $(Sys.KERNEL)")
65	end
66	)
67
68	libgfortran_path::String = ""
69	const libgfortran = LazyLibrary(
70	if Sys.iswindows()
71	BundledLazyLibraryPath(string("libgfortran-", libgfortran_version(HostPlatform()).major, ".dll"))
72	elseif Sys.isapple()
73	BundledLazyLibraryPath(string("libgfortran.", libgfortran_version(HostPlatform()).major, ".dylib"))
74	elseif Sys.islinux() \|\| Sys.isfreebsd()
75	BundledLazyLibraryPath(string("libgfortran.so.", libgfortran_version(HostPlatform()).major))
76	else
77	error("CompilerSupportLibraries_jll: Library 'libgfortran' is not available for $(Sys.KERNEL)")
78	end;
79	dependencies = @static if @isdefined(libquadmath)
80	LazyLibrary[libgcc_s, libquadmath]
81	else
82	LazyLibrary[libgcc_s]
83	end
84	)
85
86	libstdcxx_path::String = ""
87	const libstdcxx = LazyLibrary(
88	if Sys.iswindows()
89	BundledLazyLibraryPath("libstdc++-6.dll")
90	elseif Sys.isapple()
91	BundledLazyLibraryPath("libstdc++.6.dylib")
92	elseif Sys.islinux() \|\| Sys.isfreebsd()
93	BundledLazyLibraryPath("libstdc++.so.6")
94	else
95	error("CompilerSupportLibraries_jll: Library 'libstdcxx' is not available for $(Sys.KERNEL)")
96	end;
97	dependencies = LazyLibrary[libgcc_s]
98	)
99
100	libgomp_path::String = ""
101	const libgomp = LazyLibrary(
102	if Sys.iswindows()
103	BundledLazyLibraryPath("libgomp-1.dll")
104	elseif Sys.isapple()
105	BundledLazyLibraryPath("libgomp.1.dylib")
106	elseif Sys.islinux() \|\| Sys.isfreebsd()
107	BundledLazyLibraryPath("libgomp.so.1")
108	else
109	error("CompilerSupportLibraries_jll: Library 'libgomp' is not available for $(Sys.KERNEL)")
110	end;
111	dependencies = if Sys.iswindows()
112	LazyLibrary[libgcc_s]
113	else
114	LazyLibrary[]
115	end
116	)
117
118	# only define if isfile
119	let
120	if Sys.iswindows() \|\| Sys.isapple() \|\| libc(HostPlatform()) != "musl"
121	_libssp_path = if Sys.iswindows()
122	BundledLazyLibraryPath("libssp-0.dll")
123	elseif Sys.isapple()
124	BundledLazyLibraryPath("libssp.0.dylib")
125	elseif Sys.islinux() && libc(HostPlatform()) != "musl"
126	BundledLazyLibraryPath("libssp.so.0")
127	end
128	if isfile(string(_libssp_path))
129	global libssp_path::String = ""
130	@eval const libssp = LazyLibrary($(_libssp_path))
131	end
132	end
133	end
134
135	# Conform to LazyJLLWrappers API
136	function eager_mode()	×
137	if @isdefined(libatomic)	×
138	dlopen(libatomic)	×
139	end
140	dlopen(libgcc_s)	×
141	dlopen(libgomp)	×
142	if @isdefined libquadmath	×
143	dlopen(libquadmath)	×
144	end
145	if @isdefined libssp	×
146	dlopen(libssp)	×
147	end
148	dlopen(libgfortran)	×
149	dlopen(libstdcxx)	×
150	end
151	is_available() = true	×
152
153	function __init__()	2✔
154	global libatomic_path = string(libatomic.path)	4✔
155	global libgcc_s_path = string(libgcc_s.path)	4✔
156	global libgomp_path = string(libgomp.path)	4✔
157	if @isdefined libquadmath_path	2✔
158	global libquadmath_path = string(libquadmath.path)	4✔
159	end
160	if @isdefined libssp_path	2✔
161	global libssp_path = string(libssp.path)	4✔
162	end
163	global libgfortran_path = string(libgfortran.path)	4✔
164	global libstdcxx_path = string(libstdcxx.path)	4✔
165	global artifact_dir = dirname(Sys.BINDIR)	2✔
166	LIBPATH[] = dirname(libgcc_s_path)	2✔
167	push!(LIBPATH_list, LIBPATH[])	2✔
168	end
169
170	if Base.generating_output()
171	precompile(eager_mode, ())
172	precompile(is_available, ())
173	end
174
175	end # module CompilerSupportLibraries_jll

JuliaLang / julia / #38096

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous