@ccall library.function_name(argvalue1::argtype1, ...)::returntype
@ccall function_name(argvalue1::argtype1, ...)::returntype
@ccall $function_pointer(argvalue1::argtype1, ...)::returntype

C tarafından dışa aktarılan bir paylaşımlı kütüphanede, library.function_name ile belirtilen bir fonksiyonu çağırın; burada library bir dize sabiti veya literaldir. Kütüphane atlanabilir; bu durumda function_name mevcut süreçte çözülür. Alternatif olarak, @ccall, dlsym tarafından döndürülen bir fonksiyon işaretçisi $function_pointer çağırmak için de kullanılabilir.

Her argvalue, @ccall için otomatik olarak unsafe_convert(argtype, cconvert(argtype, argvalue)) çağrıları eklenerek karşılık gelen argtype'e dönüştürülür. (Daha fazla ayrıntı için unsafe_convert ve cconvert belgelerine de bakın.) Çoğu durumda, bu basitçe convert(argtype, argvalue) çağrısına yol açar.

Örnekler

@ccall strlen(s::Cstring)::Csize_t

Bu, C standart kütüphane fonksiyonunu çağırır:

size_t strlen(char *)

S adında bir Julia değişkeni ile. Ayrıca ccall'a da bakın.

Varargs, aşağıdaki kural ile desteklenir:

@ccall printf("%s = %d"::Cstring ; "foo"::Cstring, foo::Cint)::Cint

Noktalı virgül, en az bir tane olması gereken zorunlu argümanları değişken argümanlardan ayırmak için kullanılır.

Bir dış kütüphane kullanarak örnek:

# g_uri_escape_string'in C imzası:
# char *g_uri_escape_string(const char *unescaped, const char *reserved_chars_allowed, gboolean allow_utf8);

const glib = "libglib-2.0"
@ccall glib.g_uri_escape_string(my_uri::Cstring, ":/"::Cstring, true::Cint)::Cstring

Dize literali, istenirse fonksiyon adından önce doğrudan da kullanılabilir "libglib-2.0".g_uri_escape_string(...

ccall((function_name, library), returntype, (argtype1, ...), argvalue1, ...)
ccall(function_name, returntype, (argtype1, ...), argvalue1, ...)
ccall(function_pointer, returntype, (argtype1, ...), argvalue1, ...)

C'den dışa aktarılan bir paylaşımlı kütüphanedeki bir işlevi çağırın; bu, (function_name, library) demetinde belirtilmiştir; her bir bileşen ya bir dize ya da bir semboldür. Bir kütüphane belirtmek yerine, mevcut süreçte çözümlenen bir function_name sembolü veya dizesi de kullanılabilir. Alternatif olarak, ccall, dlsym ile döndürülen bir işlev işaretçisi function_pointer çağırmak için de kullanılabilir.

Argüman türü demetinin bir literal demet olması gerektiğini ve bir demet-değerli değişken veya ifade olmaması gerektiğini unutmayın.

ccall'a verilen her argvalue, otomatik olarak unsafe_convert(argtype, cconvert(argtype, argvalue)) çağrıları eklenerek karşılık gelen argtype'a dönüştürülecektir. (Daha fazla ayrıntı için unsafe_convert ve cconvert belgelerine de bakın.) Çoğu durumda, bu basitçe convert(argtype, argvalue) çağrısına yol açar.

cglobal((symbol, library) [, type=Cvoid])

C'den dışa aktarılan bir paylaşımlı kütüphanedeki bir global değişkenin işaretçisini elde edin, tam olarak ccall olarak belirtildiği gibi. Bir Ptr{Type} döner, eğer Type argümanı sağlanmazsa varsayılan olarak Ptr{Cvoid} kullanılır. Değerler unsafe_load veya unsafe_store! ile sırasıyla okunabilir veya yazılabilir.

@cfunction(callable, ReturnType, (ArgumentTypes...,)) -> Ptr{Cvoid}
@cfunction($callable, ReturnType, (ArgumentTypes...,)) -> CFunction

Julia fonksiyonu callable'dan verilen tür imzası için C çağrılabilir bir fonksiyon işaretçisi oluşturun. Dönüş değerini bir ccall'e iletmek için, imzada Ptr{Cvoid} argüman türünü kullanın.

Argüman türü demetinin bir literal demet olması gerektiğini ve bir demet-değerli değişken veya ifade olmaması gerektiğini unutmayın (ancak bir splat ifadesi içerebilir). Ve bu argümanlar derleme zamanında global kapsamda değerlendirilecektir (çalışma zamanında ertelenmeyecek). Fonksiyon argümanının önüne bir '$' eklemek, bunun yerine yerel değişken callable üzerinde bir çalışma zamanı kapanışı oluşturur (bu tüm mimarilerde desteklenmez).

ccall ve cfunction kullanımı hakkında kılavuz bölümü bölümüne bakın.

Örnekler

julia> function foo(x::Int, y::Int)
           return x + y
       end

julia> @cfunction(foo, Int, (Int, Int))
Ptr{Cvoid} @0x000000001b82fcd0

CFunction yapısı

@cfunction ile dönen değerin çöp toplama işlemi için '$' ile işaretlenmiş ilk argüman kullanıldığında. Tüm cfunction tutucuları gibi, ccall'e Ptr{Cvoid} olarak geçirilmelidir ve çağrı noktasında otomatik olarak uygun türe dönüştürülecektir.

@cfunction bakınız.

unsafe_convert(T, x)

x'i T türünde bir C argümanına dönüştürün; burada giriş x, cconvert(T, ...)'in döndürdüğü değer olmalıdır.

convert bir Julia nesnesini Ptr'ye dönüştürmesi gerektiğinde, bu işlev o dönüşümü tanımlamak ve gerçekleştirmek için kullanılmalıdır.

Bu işlevin sonucunun kullanılacağı süre boyunca x'e bir Julia referansının var olduğundan emin olun. Bu nedenle, bu işlevin argümanı x asla bir ifade olmamalıdır, yalnızca bir değişken adı veya alan referansı olmalıdır. Örneğin, x=a.b.c kabul edilebilir, ancak x=[a,b,c] kabul edilemez.

Bu işlevdeki unsafe ön eki, bu işlevin x argümanının program için artık erişilebilir olmadığı bir durumda bu işlevin sonucunu kullanmanın tanımsız davranışa, program bozulmasına veya segfault'lara neden olabileceğini belirtir.

Ayrıca cconvert bakınız.

cconvert(T,x)

x'i T türünde C koduna geçilecek bir değere dönüştür. Genellikle convert(T, x) çağrısı yaparak gerçekleştirilir.

x'in T'ye güvenli bir şekilde dönüştürülemeyeceği durumlarda, convert ile karşılaştırıldığında, cconvert T'den farklı bir türde bir nesne döndürebilir; ancak bu nesne unsafe_convert tarafından işlenmek için uygundur. Bu fonksiyonun sonucu, unsafe_convert sonucuna ihtiyaç duyulmadığı sürece geçerli (GC için) tutulmalıdır. Bu, ccall tarafından erişilecek belleği tahsis etmek için kullanılabilir. Birden fazla nesne tahsis edilmesi gerekiyorsa, nesnelerin bir demeti döndürme değeri olarak kullanılabilir.

Ne convert ne de cconvert, bir Julia nesnesini Ptr'ye dönüştürmelidir.

unsafe_load(p::Ptr{T}, i::Integer=1)
unsafe_load(p::Ptr{T}, order::Symbol)
unsafe_load(p::Ptr{T}, i::Integer, order::Symbol)

p adresindeki i'nci elemanın (1'den başlayan indeks) değerini T türünde yükler. Bu, C ifadesi p[i-1] ile eşdeğerdir. İsteğe bağlı olarak, atomik bellek sıralaması sağlanabilir.

Bu işlevdeki unsafe ön eki, p işaretçisinin geçerli olduğunu doğrulamak için herhangi bir doğrulama yapılmadığını belirtir. C'de olduğu gibi, programcı, bu işlev çağrılırken referans verilen belleğin serbest bırakılmadığından veya çöp toplayıcı tarafından toplanmadığından emin olmaktan sorumludur. Yanlış kullanım, programınızı segfault yapabilir veya geçersiz sonuçlar döndürebilir. C'den farklı olarak, farklı türde tahsis edilmiş bellek bölgesinin dereferans edilmesi, türlerin uyumlu olması koşuluyla geçerli olabilir.

Ayrıca bakınız: atomic

unsafe_store!(p::Ptr{T}, x, i::Integer=1)
unsafe_store!(p::Ptr{T}, x, order::Symbol)
unsafe_store!(p::Ptr{T}, x, i::Integer, order::Symbol)

T türünde bir değeri p adresinden başlayarak i'nci elemanın (1'den başlayan) adresine kaydeder. Bu, C ifadesi p[i-1] = x ile eşdeğerdir. İsteğe bağlı olarak, atomik bellek sıralaması sağlanabilir.

Bu işlevdeki unsafe ön eki, p işaretçisinin geçerli olduğunu doğrulamak için herhangi bir doğrulama yapılmadığını gösterir. C'de olduğu gibi, programcı, bu işlev çağrılırken referans verilen belleğin serbest bırakılmadığından veya çöp toplayıcı tarafından toplanmadığından emin olmaktan sorumludur. Yanlış kullanım programınızı segfault yapabilir. C'den farklı olarak, farklı türde tahsis edilmiş bellek bölgesine veri kaydetmek, türlerin uyumlu olması koşuluyla geçerli olabilir.

Ayrıca bakınız: atomic

unsafe_modify!(p::Ptr{T}, op, x, [order::Symbol]) -> Pair

Bu atomik olarak, op fonksiyonunu uyguladıktan sonra bir bellek adresini almak ve ayarlamak için işlemleri gerçekleştirir. Donanım tarafından destekleniyorsa (örneğin, atomik artırma), bu uygun donanım talimatına optimize edilebilir, aksi takdirde yürütülmesi aşağıdaki gibi olacaktır:

y = unsafe_load(p)
z = op(y, x)
unsafe_store!(p, z)
return y => z

Bu fonksiyondaki unsafe ön eki, p işaretçisinin geçerli olduğunu doğrulamak için herhangi bir doğrulama yapılmadığını gösterir. C'de olduğu gibi, programcı, bu fonksiyonu çağırırken referans verilen belleğin serbest bırakılmadığından veya çöp toplanmadığından emin olmaktan sorumludur. Yanlış kullanım programınızı segfault yapabilir.

Ayrıca bakınız: modifyproperty!, atomic

unsafe_replace!(p::Ptr{T}, expected, desired,
               [success_order::Symbol[, fail_order::Symbol=success_order]]) -> (; old, success::Bool)

Bu atomik olarak, bir bellek adresini verilen bir değere almak ve koşullu olarak ayarlamak için işlemleri gerçekleştirir. Donanım tarafından destekleniyorsa, bu uygun donanım talimatına optimize edilebilir, aksi takdirde yürütülmesi aşağıdaki gibi olacaktır:

y = unsafe_load(p, fail_order)
ok = y === expected
if ok
    unsafe_store!(p, desired, success_order)
end
return (; old = y, success = ok)

Bu işlevdeki unsafe ön eki, p işaretçisinin geçerli olduğunu doğrulamak için herhangi bir doğrulama yapılmadığını gösterir. C'de olduğu gibi, programcı, bu işlevi çağırırken referans verilen belleğin serbest bırakılmadığından veya çöp toplayıcı tarafından toplanmadığından emin olmaktan sorumludur. Yanlış kullanım programınızı segfault yapabilir.

Ayrıca bakınız: replaceproperty!, atomic

unsafe_swap!(p::Ptr{T}, x, [order::Symbol])

Bu atomik olarak bir bellek adresini aynı anda almak ve ayarlamak için işlemleri gerçekleştirir. Donanım tarafından destekleniyorsa, bu uygun donanım talimatına optimize edilebilir, aksi takdirde yürütülmesi aşağıdaki gibi olacaktır:

y = unsafe_load(p)
unsafe_store!(p, x)
return y

Bu işlevdeki unsafe öneki, p işaretçisinin geçerli olduğunu doğrulamak için hiçbir doğrulama yapılmadığını gösterir. C'de olduğu gibi, programcı, bu işlevi çağırırken referans verilen belleğin serbest bırakılmadığından veya çöp toplayıcı tarafından toplanmadığından emin olmaktan sorumludur. Yanlış kullanım programınızı segfault yapabilir.

Ayrıca bakınız: swapproperty!, atomic

unsafe_copyto!(dest::Ptr{T}, src::Ptr{T}, N)

N elemanı bir kaynak işaretçisinden bir hedefe kopyalar, kontrol olmadan. Bir elemanın boyutu işaretçilerin türü tarafından belirlenir.

Bu işlevdeki unsafe ön eki, dest ve src işaretçileri üzerinde geçerliliği sağlamak için hiçbir doğrulama yapılmadığını gösterir. Yanlış kullanım, programınızı C'deki gibi bozulmasına veya segfault olmasına neden olabilir.

unsafe_copyto!(dest::Array, do, src::Array, so, N)

Bir kaynak diziden bir hedefe N eleman kopyalayın, kaynakta so ve hedefte do doğrusal indeksinden başlayarak (1-indeksli).

Bu işlevdeki unsafe ön eki, N'nin her iki dizide de sınır içinde olduğunu doğrulamak için hiçbir doğrulama yapılmadığını gösterir. Yanlış kullanım, programınızı C'de olduğu gibi bozulmasına veya segfault'a neden olabilir.

copyto!(B::AbstractMatrix, ir_dest::AbstractUnitRange, jr_dest::AbstractUnitRange,
        tM::AbstractChar,
        M::AbstractVecOrMat, ir_src::AbstractUnitRange, jr_src::AbstractUnitRange) -> B

Matris M'nin elemanlarını tM karakter parametresine bağlı olarak B'ye verimli bir şekilde kopyalayın:

Elemanlar B[ir_dest, jr_dest] üzerine yazılır. Ayrıca, indeks aralığı parametreleri length(ir_dest) == length(ir_src) ve length(jr_dest) == length(jr_src) koşulunu sağlamalıdır.

Ayrıca copy_transpose! ve copy_adjoint! ile de bakabilirsiniz.

copyto!(dest::AbstractMatrix, src::UniformScaling)

Bir UniformScaling matrisine kopyalar.

copyto!(dest, do, src, so, N)

N elemanı src koleksiyonundan so lineer indeksinden başlayarak, dest dizisine do indeksinden başlayarak kopyalar. dest döner.

copyto!(dest::AbstractArray, src) -> dest

Tüm elemanları src koleksiyonundan dest dizisine kopyalar; dest'in uzunluğu src'nin uzunluğu n'den büyük veya eşit olmalıdır. dest'in ilk n elemanı üzerine yazılır, diğer elemanlar dokunulmadan bırakılır.

Ayrıca bkz. copy!, copy.

!!! uyarı Herhangi bir değiştirilmiş argümanın, başka bir argümanla bellek paylaşması durumunda davranış beklenmedik olabilir.

Örnekler

julia> x = [1., 0., 3., 0., 5.];

julia> y = zeros(7);

julia> copyto!(y, x);

julia> y
7-element Vector{Float64}:
 1.0
 0.0
 3.0
 0.0
 5.0
 0.0
 0.0

copyto!(dest, Rdest::CartesianIndices, src, Rsrc::CartesianIndices) -> dest

Rsrc aralığında src'nin bloğunu Rdest aralığında dest'in bloğuna kopyalayın. İki bölgenin boyutları eşleşmelidir.

Örnekler

julia> A = zeros(5, 5);

julia> B = [1 2; 3 4];

julia> Ainds = CartesianIndices((2:3, 2:3));

julia> Binds = CartesianIndices(B);

julia> copyto!(A, Ainds, B, Binds)
5×5 Matrix{Float64}:
 0.0  0.0  0.0  0.0  0.0
 0.0  1.0  2.0  0.0  0.0
 0.0  3.0  4.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0

pointer(array [, index])

Bir dizinin veya stringin yerel adresini, isteğe bağlı olarak verilen index konumunda alır.

Bu fonksiyon "güvensizdir". Bu işaretçinin kullanılacağı süre boyunca array için bir Julia referansının var olduğundan emin olun. array argümanını belirli bir kod bloğu içinde çöp toplama işlemlerinden korumak için GC.@preserve makrosu kullanılmalıdır.

Genellikle Ref(array[, index]) çağrısı bu fonksiyondan daha tercih edilir çünkü geçerliliği garanti eder.

unsafe_wrap(Array, pointer::Ptr{T}, dims; own = false)

Bir Julia Array nesnesini pointer ile verilen adresteki verilere sarmalar, kopya oluşturmadan. Pointer eleman türü T, dizi eleman türünü belirler. dims, ya bir tam sayı (1d dizi için) ya da dizi boyutlarının bir demetidir. own, isteğe bağlı olarak, Julia'nın belleğin mülkiyetini alıp almayacağını belirtir; dizi artık referans edilmediğinde pointer üzerinde free çağrılır.

Bu işlev "güvensiz" olarak etiketlenmiştir çünkü pointer, istenen uzunluktaki verilere geçerli bir bellek adresi değilse çökmesine neden olur. unsafe_load ve unsafe_store! ile karşılaştırıldığında, programcı ayrıca altındaki verilere farklı eleman türlerine sahip iki dizi aracılığıyla erişilmediğinden emin olmaktan da sorumludur; bu, C'deki katı aliasing kuralına benzer.

pointer_from_objref(x)

Bir Julia nesnesinin bellek adresini Ptr olarak alır. Elde edilen Ptr nesneyi çöp toplama işlemlerinden korumaz, bu nedenle Ptr'nin kullanılacağı süre boyunca nesnenin referansının devam etmesini sağlamalısınız.

Bu fonksiyon, kararlı bellek adreslerine sahip olmadıkları için değiştirilemez nesneler üzerinde çağrılmamalıdır.

Ayrıca bkz. unsafe_pointer_to_objref.

unsafe_pointer_to_objref(p::Ptr)

Bir Ptr'yi bir nesne referansına dönüştürür. İşaretçinin geçerli bir yığın üzerinde tahsis edilmiş Julia nesnesine atıfta bulunduğu varsayılmaktadır. Eğer durum böyle değilse, tanımsız bir davranış ortaya çıkar, bu nedenle bu fonksiyon "güvensiz" olarak kabul edilir ve dikkatle kullanılmalıdır.

Ayrıca bkz. pointer_from_objref.

disable_sigint(f::Function)

Bir işlevin yürütülmesi sırasında Ctrl-C işleyicisini devre dışı bırakır, dış kod çağırmak için, bu kodun kesinti güvenli olmayan julia kodunu çağırabileceği durumlar için. Aşağıdaki gibi do blok sözdizimi kullanılarak çağrılması amaçlanmıştır:

disable_sigint() do
    # kesinti güvenli olmayan kod
    ...
end

Bu, işçi iş parçacıklarında (Threads.threadid() != 1) gerekli değildir, çünkü InterruptException yalnızca ana iş parçacığına iletilecektir. Julia kodunu veya julia çalışma zamanını çağırmayan dış işlevler, yürütmeleri sırasında otomatik olarak sigint'i devre dışı bırakır.

reenable_sigint(f::Function)

Bir işlevin yürütülmesi sırasında Ctrl-C işleyicisini yeniden etkinleştirir. Geçici olarak disable_sigint etkisini tersine çevirir.

exit_on_sigint(on::Bool)

Julia çalışma zamanının exit_on_sigint bayrağını ayarlar. Eğer false ise, Ctrl-C (SIGINT) try bloğunda InterruptException olarak yakalanabilir. Bu, REPL'deki varsayılan davranıştır, -e ve -E ile çalıştırılan herhangi bir kodda ve -i seçeneği ile çalıştırılan Julia betiğinde geçerlidir.

Eğer true ise, Ctrl-C tarafından InterruptException fırlatılmaz. Böyle bir olay üzerine kod çalıştırmak atexit gerektirir. Bu, -i seçeneği olmadan çalıştırılan Julia betiğinde varsayılan davranıştır.

systemerror(sysfunc[, errno::Cint=Libc.errno()])
systemerror(sysfunc, iftrue::Bool)

iftrue true ise sysfunc ile errno için bir SystemError oluşturur.

windowserror(sysfunc[, code::UInt32=Libc.GetLastError()])
windowserror(sysfunc, iftrue::Bool)

systemerror ile benzer, ancak errno ayarlamak yerine bir hata kodu döndürmek için GetLastError kullanan Windows API işlevleri için.

Ptr{T}

T türündeki verilere atıfta bulunan bir bellek adresi. Ancak, belleğin gerçekten geçerli olduğuna veya gerçekten belirtilen türdeki verileri temsil ettiğine dair bir garanti yoktur.

Ref{T}

T türündeki verilere güvenli bir şekilde referans veren bir nesne. Bu tür, geçerli, Julia tarafından tahsis edilmiş doğru türdeki belleğe işaret etme garantisi verir. Temel veri, Ref kendisi referans edildiği sürece çöp toplayıcı tarafından serbest bırakılmaktan korunur.

Julia'da, Ref nesneleri [] ile dereferans edilir (yüklenir veya saklanır).

T türündeki bir x değerine bir Ref oluşturma genellikle Ref(x) şeklinde yazılır. Ayrıca, konteynerlere (Array veya Ptr gibi) içsel işaretçiler oluşturmak için Ref(a, i) şeklinde yazılabilir; bu, a'nın i-inci elemanına bir referans oluşturur.

Ref{T}() başlangıçsız bir T türündeki bir değere referans oluşturur. Bir bitstype T için, değer, tahsis edilen bellekte şu anda bulunan herhangi bir şey olacaktır. Bir non-bitstype T için, referans tanımsız olacaktır ve dereferans etmeye çalışmak "UndefRefError: tanımsız referansa erişim" hatasına yol açacaktır.

Bir Ref'in tanımsız bir referans olup olmadığını kontrol etmek için isassigned(ref::RefValue) kullanın. Örneğin, isassigned(Ref{T}()) eğer T bir bitstype değilse false olacaktır. Eğer T bir bitstype ise, isassigned(Ref{T}()) her zaman true olacaktır.

ccall argümanı olarak geçirildiğinde (ya bir Ptr ya da Ref türü olarak), bir Ref nesnesi, referans verdiği veriye bir yerel işaretçiye dönüştürülecektir. Çoğu T için veya Ptr{Cvoid}'a dönüştürüldüğünde, bu nesne verisine bir işaretçidir. T bir isbits türü olduğunda, bu değer güvenli bir şekilde değiştirilebilir, aksi takdirde değişiklik kesinlikle tanımsız bir davranıştır.

Özel bir durum olarak, T = Any olarak ayarlandığında, Ptr{Any}'ye dönüştürüldüğünde referansa kendisine işaret eden bir işaretçi oluşturulmasına neden olacaktır (eğer T değiştirilemezse jl_value_t const* const*, aksi takdirde jl_value_t *const *). Ptr{Cvoid}'a dönüştürüldüğünde, diğer T'ler için olduğu gibi veri bölgesine bir işaretçi döndürmeye devam edecektir.

Bir C_NULL örneği ccall Ref argümanına geçirilerek başlatılabilir.

Yaygın Kullanım

Ref, referans verilen değerleri bir skalar olarak ele almak için bazen yaygın kullanımlarda kullanılır.

Örnekler

julia> r = Ref(5) # Başlangıç değeri ile bir Ref oluştur
Base.RefValue{Int64}(5)

julia> r[] # Bir Ref'den değer almak
5

julia> r[] = 7 # Bir Ref'de yeni bir değer saklamak
7

julia> r # Ref artık 7 içeriyor
Base.RefValue{Int64}(7)

julia> isa.(Ref([1,2,3]), [Array, Dict, Int]) # Yaygın kullanımlarda referans değerlerini skalar olarak ele al
3-element BitVector:
 1
 0
 0

julia> Ref{Function}()  # Tanımsız referans bir non-bitstype, Function
Base.RefValue{Function}(#undef)

julia> try
           Ref{Function}()[] # Tanımsız bir referansı dereferans etmek bir hataya yol açar
       catch e
           println(e)
       end
UndefRefError()

julia> Ref{Int64}()[]; # Bir bitstype'e referans verilmediğinde belirsiz bir değere işaret eder

julia> isassigned(Ref{Int64}()) # Bir bitstype'e referans her zaman atanmıştır
true

isassigned(ref::RefValue) -> Bool

Verilen Ref değerle ilişkilendirilip ilişkilendirilmediğini test eder. Bu, bir bitstype nesnesinin Ref için her zaman doğrudur. Referans tanımsızsa false döner.

Örnekler

julia> ref = Ref{Function}()
Base.RefValue{Function}(#undef)

julia> isassigned(ref)
false

julia> ref[] = (foobar(x) = x)
foobar (generic function with 1 method)

julia> isassigned(ref)
true

julia> isassigned(Ref{Int}())
true

Cchar

Yerel char c-tipi ile eşdeğerdir.

Cuchar

Yerel unsigned char c-tipi ile eşdeğerdir (UInt8).

Cshort

Yerel signed short c-tipi ile eşdeğerdir (Int16).

Cstring

Yerel karakter türünden oluşan C tarzı bir dize Cchar ile. Cstring'ler NUL ile sonlandırılmıştır. Yerel geniş karakter türünden oluşan C tarzı dizeler için Cwstring kısmına bakın. C ile dize etkileşimi hakkında daha fazla bilgi için kılavuza bakın.

Cushort

Yerel unsigned short c-tipi ile eşdeğerdir (UInt16).

Cint

Yerel signed int c-tipi ile eşdeğerdir (Int32).

Cuint

Yerel unsigned int c-tipi ile eşdeğerdir (UInt32).

Clong

Yerel signed long c-tipi ile eşdeğerdir.

Culong

Yerel unsigned long c-tipi ile eşdeğerdir.

Clonglong

Yerel signed long long c-tipi ile eşdeğerdir (Int64).

Culonglong

Yerel unsigned long long c-tipi ile eşdeğerdir (UInt64).

Cintmax_t

Yerel intmax_t c-tipi ile eşdeğerdir (Int64).

Cuintmax_t

Yerel uintmax_t c-tipi ile eşdeğerdir (UInt64).

Csize_t

Yerel size_t c-tipi ile eşdeğerdir (UInt).

Cssize_t

Yerel ssize_t c-tipi ile eşdeğerdir.

Cptrdiff_t

Yerel ptrdiff_t c-tipi ile eşdeğerdir (Int).

Cwchar_t

Yerel wchar_t c-tipi ile eşdeğerdir (Int32).

Cwstring

Yerel geniş karakter türünden oluşan C tarzı bir dize Cwchar_t ile. Cwstring'ler NUL ile sonlandırılmıştır. Yerel karakter türünden oluşan C tarzı dizeler için Cstring kısmına bakın. C ile dize etkileşimi hakkında daha fazla bilgi için kılavuza bakın.

Cfloat

Yerel float c-tipi ile eşdeğerdir (Float32).

Cdouble

Yerel double c-tipi ile eşdeğerdir (Float64).

llvmcall(fun_ir::String, returntype, Tuple{argtype1, ...}, argvalue1, ...)
llvmcall((mod_ir::String, entry_fn::String), returntype, Tuple{argtype1, ...}, argvalue1, ...)
llvmcall((mod_bc::Vector{UInt8}, entry_fn::String), returntype, Tuple{argtype1, ...}, argvalue1, ...)

İlk argümanda sağlanan LLVM kodunu çağırın. Bu ilk argümanı belirtmenin birkaç yolu vardır:

• argümanların ardışık isimsiz SSA değişkenleri (%0, %1, vb.) olarak mevcut olduğu, fonksiyon seviyesinde IR'yi temsil eden bir literal dize olarak;
• çağrılacak giriş noktası fonksiyonunun adını temsil eden bir dize ve bir modül IR'si içeren 2 elemanlı bir demet olarak;
• ancak modül, bit kodu ile Vector{UInt8} olarak sağlandığında 2 elemanlı bir demet olarak.

ccall'ın aksine, argüman türlerinin bir demet türü olarak belirtilmesi gerektiğini ve türlerin bir demetinin değil. Tüm türler ve LLVM kodu, değişkenler veya ifadeler olarak değil, literal olarak belirtilmelidir (bu literal'leri oluşturmak için @eval kullanmak gerekebilir).

Opak işaretçiler (yazıldığı gibi ptr) LLVM kodunda izin verilmez.

Kullanım örnekleri için test/llvmcall.jl dosyasına bakın.