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

C에서 내보낸 공유 라이브러리의 함수를 호출합니다. 여기서 library.function_name은 문자열 상수 또는 리터럴입니다. 라이브러리는 생략할 수 있으며, 이 경우 function_name은 현재 프로세스에서 해결됩니다. 또는 @ccall을 사용하여 dlsym에 의해 반환된 함수 포인터 $function_pointer를 호출할 수도 있습니다.

각 argvalue는 자동으로 unsafe_convert(argtype, cconvert(argtype, argvalue)) 호출을 삽입하여 해당 argtype으로 변환됩니다. (자세한 내용은 unsafe_convert 및 cconvert 문서를 참조하십시오.) 대부분의 경우, 이는 단순히 convert(argtype, argvalue) 호출로 이어집니다.

예제

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

이는 C 표준 라이브러리 함수를 호출합니다:

size_t strlen(char *)

여기서 s라는 이름의 Julia 변수를 사용합니다. ccall도 참조하십시오.

가변 인자는 다음과 같은 규칙으로 지원됩니다:

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

세미콜론은 필수 인수(최소 하나 이상이어야 함)와 가변 인수를 구분하는 데 사용됩니다.

외부 라이브러리를 사용하는 예:

# g_uri_escape_string의 C 시그니처:
# 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

문자열 리터럴은 원할 경우 함수 이름 앞에 직접 사용할 수도 있습니다 "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에서 내보낸 공유 라이브러리의 함수를 호출합니다. (function_name, library) 튜플로 지정되며, 각 구성 요소는 문자열 또는 기호일 수 있습니다. 라이브러리를 지정하는 대신, 현재 프로세스에서 해결되는 function_name 기호 또는 문자열을 사용할 수도 있습니다. 또는 ccall을 사용하여 dlsym에 의해 반환된 함수 포인터 function_pointer를 호출할 수도 있습니다.

인수 유형 튜플은 리터럴 튜플이어야 하며, 튜플 값을 가진 변수나 표현식이 아니어야 합니다.

ccall에 대한 각 argvalue는 자동으로 unsafe_convert(argtype, cconvert(argtype, argvalue)) 호출을 삽입하여 해당 argtype으로 변환됩니다. (자세한 내용은 unsafe_convert 및 cconvert 문서를 참조하십시오.) 대부분의 경우, 이는 단순히 convert(argtype, argvalue) 호출로 이어집니다.

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

C로 내보낸 공유 라이브러리에서 전역 변수에 대한 포인터를 가져옵니다. 이는 ccall에서 정확히 지정된 대로입니다. Ptr{Type}을 반환하며, Type 인수가 제공되지 않으면 기본적으로 Ptr{Cvoid}로 설정됩니다. 값은 각각 unsafe_load 또는 unsafe_store!를 통해 읽거나 쓸 수 있습니다.

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

주어진 타입 서명에 대해 Julia 함수 callable에서 C 호출 가능 함수 포인터를 생성합니다. 반환 값을 ccall에 전달하려면 서명에서 인수 타입 Ptr{Cvoid}를 사용하십시오.

인수 타입 튜플은 리터럴 튜플이어야 하며, 튜플 값 변수나 표현식이 아니어야 합니다(스플랫 표현식을 포함할 수는 있지만). 이러한 인수는 컴파일 타임 동안 전역 범위에서 평가됩니다(런타임까지 연기되지 않음). 함수 인수 앞에 '$'를 추가하면 대신 로컬 변수 callable에 대한 런타임 클로저를 생성합니다(모든 아키텍처에서 지원되지 않습니다).

ccall 및 cfunction 사용에 대한 매뉴얼 섹션을 참조하십시오.

예제

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

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

CFunction 구조체

@cfunction에서 첫 번째 인수가 '$'로 주석 처리된 경우 반환 값에 대한 가비지 수집 핸들입니다. 모든 cfunction 핸들과 마찬가지로 ccall에 Ptr{Cvoid}로 전달되어야 하며, 호출 지점에서 자동으로 적절한 유형으로 변환됩니다.

@cfunction를 참조하세요.

unsafe_convert(T, x)

x를 T 타입의 C 인자로 변환합니다. 여기서 입력 x는 cconvert(T, ...)의 반환값이어야 합니다.

convert가 Julia 객체를 받아 Ptr로 변환해야 하는 경우, 이 함수를 사용하여 해당 변환을 정의하고 수행해야 합니다.

이 함수의 결과가 사용되는 동안 x에 대한 Julia 참조가 존재하도록 주의해야 합니다. 따라서 이 함수의 인자 x는 절대 표현식이 되어서는 안 되며, 변수 이름이나 필드 참조만 사용해야 합니다. 예를 들어, x=a.b.c는 허용되지만, x=[a,b,c]는 허용되지 않습니다.

이 함수의 unsafe 접두사는 이 함수의 x 인자가 더 이상 프로그램에서 접근할 수 없게 된 후 이 함수의 결과를 사용하면 정의되지 않은 동작, 프로그램 손상 또는 세그멘테이션 오류(segfaults)를 초래할 수 있음을 나타냅니다.

자세한 내용은 cconvert를 참조하십시오.

cconvert(T,x)

x를 C 코드에 T 타입으로 전달할 값으로 변환합니다. 일반적으로 convert(T, x)를 호출하여 수행됩니다.

x를 T로 안전하게 변환할 수 없는 경우, convert와는 달리 cconvert는 T와 다른 타입의 객체를 반환할 수 있지만, 이는 unsafe_convert가 처리하기에 적합합니다. 이 함수의 결과는 unsafe_convert의 결과가 더 이상 필요하지 않을 때까지 유효하게 유지되어야 합니다(GC를 위해). 이는 ccall에 의해 접근될 메모리를 할당하는 데 사용될 수 있습니다. 여러 객체를 할당해야 하는 경우, 객체의 튜플을 반환 값으로 사용할 수 있습니다.

convert나 cconvert는 Julia 객체를 Ptr로 변환해서는 안 됩니다.

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에서 시작하여 i번째 요소(1부터 인덱스 시작) 주소에서 타입 T의 값을 로드합니다. 이는 C 표현식 p[i-1]와 동일합니다. 선택적으로 원자적 메모리 순서를 제공할 수 있습니다.

이 함수의 unsafe 접두사는 포인터 p가 유효한지 확인하기 위한 검증이 수행되지 않음을 나타냅니다. C와 마찬가지로, 프로그래머는 이 함수를 호출하는 동안 참조된 메모리가 해제되거나 가비지 수집되지 않도록 보장할 책임이 있습니다. 잘못된 사용은 프로그램을 세그멘트 오류로 만들거나 쓰레기 값을 반환할 수 있습니다. C와는 달리, 서로 다른 타입으로 할당된 메모리 영역을 역참조하는 것은 타입이 호환되는 경우 유효할 수 있습니다.

참고: 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)

p에서 시작하여 i번째 요소(1부터 인덱스 시작)에 T 유형의 값을 저장합니다. 이는 C 표현식 p[i-1] = x와 동일합니다. 선택적으로 원자 메모리 순서를 제공할 수 있습니다.

이 함수의 unsafe 접두사는 포인터 p에 대해 유효성을 검사하지 않음을 나타냅니다. C와 마찬가지로 프로그래머는 이 함수를 호출하는 동안 참조된 메모리가 해제되거나 가비지 수집되지 않도록 보장할 책임이 있습니다. 잘못된 사용은 프로그램을 세그멘트 오류로 만들 수 있습니다. C와는 달리, 서로 다른 유형으로 할당된 메모리 영역을 저장하는 것은 유형이 호환되는 경우 유효할 수 있습니다.

참고: atomic

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

이 함수는 메모리 주소를 가져오고 설정하기 위해 op 함수를 적용한 후 원자적으로 작업을 수행합니다. 하드웨어에서 지원하는 경우(예: 원자적 증가) 적절한 하드웨어 명령어로 최적화될 수 있으며, 그렇지 않으면 실행은 다음과 유사합니다:

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

이 함수의 unsafe 접두사는 포인터 p가 유효한지 확인하기 위한 검증이 수행되지 않음을 나타냅니다. C와 마찬가지로, 프로그래머는 이 함수를 호출하는 동안 참조된 메모리가 해제되거나 가비지 수집되지 않도록 보장할 책임이 있습니다. 잘못된 사용은 프로그램을 세그멘테이션 오류로 만들 수 있습니다.

참고: modifyproperty!, atomic

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

이 함수는 메모리 주소를 주어진 값으로 조건부로 설정하고 가져오는 작업을 원자적으로 수행합니다. 하드웨어에서 지원하는 경우, 이는 적절한 하드웨어 명령어로 최적화될 수 있으며, 그렇지 않으면 실행은 다음과 유사합니다:

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

이 함수의 unsafe 접두사는 포인터 p가 유효한지 확인하기 위한 검증이 수행되지 않음을 나타냅니다. C와 마찬가지로, 프로그래머는 이 함수를 호출하는 동안 참조된 메모리가 해제되거나 가비지 수집되지 않도록 보장할 책임이 있습니다. 잘못된 사용은 프로그램을 세그멘테이션 오류로 만들 수 있습니다.

참고: replaceproperty!, atomic

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

이 함수는 메모리 주소를 동시에 가져오고 설정하는 작업을 원자적으로 수행합니다. 하드웨어에서 지원하는 경우, 이는 적절한 하드웨어 명령어로 최적화될 수 있으며, 그렇지 않으면 실행은 다음과 유사합니다:

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

이 함수의 unsafe 접두사는 포인터 p에 대해 유효성을 검사하지 않음을 나타냅니다. C와 마찬가지로, 프로그래머는 이 함수를 호출하는 동안 참조된 메모리가 해제되거나 가비지 수집되지 않도록 보장할 책임이 있습니다. 잘못된 사용은 프로그램을 세그멘테이션 오류로 만들 수 있습니다.

참고: swapproperty!, atomic

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

소스 포인터에서 목적지로 N 개의 요소를 복사하며, 검증 없이 수행됩니다. 요소의 크기는 포인터의 타입에 의해 결정됩니다.

이 함수의 unsafe 접두사는 포인터 dest와 src가 유효한지 확인하기 위한 검증이 수행되지 않음을 나타냅니다. 잘못된 사용은 C와 마찬가지로 프로그램을 손상시키거나 세그멘테이션 오류를 일으킬 수 있습니다.

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

소스 배열에서 목적지로 N 개의 요소를 복사하며, 소스의 선형 인덱스 so와 목적지의 do에서 시작합니다 (1-인덱스).

이 함수의 unsafe 접두사는 N이 두 배열 모두에서 유효한지 확인하는 검증이 수행되지 않음을 나타냅니다. 잘못된 사용은 C와 같은 방식으로 프로그램을 손상시키거나 세그멘테이션 오류를 일으킬 수 있습니다.

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

행렬 M의 요소를 매개변수 tM에 따라 B로 효율적으로 복사합니다:

요소 B[ir_dest, jr_dest]는 덮어쓰여집니다. 또한, 인덱스 범위 매개변수는 length(ir_dest) == length(ir_src) 및 length(jr_dest) == length(jr_src)를 만족해야 합니다.

또한 copy_transpose! 및 copy_adjoint!를 참조하십시오.

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

UniformScaling를 행렬에 복사합니다.

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

컬렉션 src에서 선형 인덱스 so부터 N 개의 요소를 복사하여 배열 dest의 인덱스 do부터 시작합니다. dest를 반환합니다.

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

컬렉션 src의 모든 요소를 배열 dest로 복사합니다. dest의 길이는 src의 길이 n보다 크거나 같아야 합니다. dest의 첫 번째 n 요소는 덮어쓰여지며, 나머지 요소는 그대로 유지됩니다.

자세한 내용은 copy!, copy를 참조하세요.

!!! 경고 변형된 인수가 다른 인수와 메모리를 공유할 경우 예상치 못한 동작이 발생할 수 있습니다.

예제

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 범위의 src 블록을 Rdest 범위의 dest 블록으로 복사합니다. 두 영역의 크기는 일치해야 합니다.

예제

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])

배열 또는 문자열의 네이티브 주소를 가져오며, 선택적으로 주어진 위치 index에서 가져옵니다.

이 함수는 "안전하지 않습니다". 이 포인터가 사용되는 동안 array에 대한 Julia 참조가 존재하는지 확인하는 데 주의해야 합니다. GC.@preserve 매크로는 주어진 코드 블록 내에서 array 인수가 가비지 수집으로부터 보호되도록 사용하는 것이 좋습니다.

일반적으로 Ref(array[, index])를 호출하는 것이 이 함수보다 바람직하며, 이는 유효성을 보장합니다.

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

주어진 pointer 주소의 데이터 주위에 Julia Array 객체를 복사하지 않고 감쌉니다. 포인터 요소 유형 T는 배열 요소 유형을 결정합니다. dims는 정수(1차원 배열의 경우) 또는 배열 차원의 튜플입니다. own은 선택적으로 Julia가 메모리의 소유권을 가져와야 하는지 여부를 지정하며, 배열이 더 이상 참조되지 않을 때 포인터에서 free를 호출합니다.

이 함수는 "안전하지 않음"으로 표시되며, 이는 pointer가 요청된 길이의 데이터에 대한 유효한 메모리 주소가 아닐 경우 충돌할 수 있기 때문입니다. unsafe_load 및 unsafe_store!와 달리, 프로그래머는 C의 엄격한 별칭 규칙과 유사하게 서로 다른 요소 유형의 두 배열을 통해 기본 데이터에 접근하지 않도록 보장할 책임이 있습니다.

pointer_from_objref(x)

Julia 객체의 메모리 주소를 Ptr로 가져옵니다. 결과로 생성된 Ptr는 객체가 가비지 컬렉션으로부터 보호되지 않으므로, Ptr가 사용되는 동안 객체가 계속 참조되도록 해야 합니다.

이 함수는 불변 객체에 대해 호출할 수 없습니다. 불변 객체는 안정적인 메모리 주소를 가지지 않기 때문입니다.

또한 unsafe_pointer_to_objref를 참조하세요.

unsafe_pointer_to_objref(p::Ptr)

Ptr를 객체 참조로 변환합니다. 포인터가 유효한 힙에 할당된 Julia 객체를 참조한다고 가정합니다. 그렇지 않은 경우 정의되지 않은 동작이 발생하므로 이 함수는 "안전하지 않다"고 간주되며 주의해서 사용해야 합니다.

또한 pointer_from_objref를 참조하십시오.

disable_sigint(f::Function)

현재 작업에서 함수 실행 중 Ctrl-C 핸들러를 비활성화하여, 인터럽트에 안전하지 않은 줄리아 코드를 호출할 수 있는 외부 코드를 호출할 때 사용합니다. 다음과 같이 do 블록 구문을 사용하여 호출하는 것이 좋습니다:

disable_sigint() do
    # 인터럽트에 안전하지 않은 코드
    ...
end

작업자 스레드(Threads.threadid() != 1)에서는 필요하지 않습니다. 왜냐하면 InterruptException은 마스터 스레드에만 전달되기 때문입니다. 줄리아 코드를 호출하지 않거나 줄리아 런타임을 호출하지 않는 외부 함수는 실행 중 자동으로 sigint를 비활성화합니다.

reenable_sigint(f::Function)

함수 실행 중 Ctrl-C 핸들러를 다시 활성화합니다. disable_sigint의 효과를 일시적으로 되돌립니다.

exit_on_sigint(on::Bool)

exit_on_sigint 플래그를 줄리아 런타임에 설정합니다. false인 경우, Ctrl-C (SIGINT)는 try 블록에서 InterruptException으로 캡처할 수 있습니다. 이는 REPL의 기본 동작이며, -e 및 -E를 통해 실행되는 모든 코드와 -i 옵션으로 실행되는 줄리아 스크립트에서도 마찬가지입니다.

true인 경우, Ctrl-C에 의해 InterruptException이 발생하지 않습니다. 이러한 이벤트에서 코드를 실행하려면 atexit가 필요합니다. 이는 -i 옵션 없이 실행되는 줄리아 스크립트의 기본 동작입니다.

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

iftrue가 true일 경우 sysfunc에 대한 설명 문자열과 함께 errno에 대해 SystemError를 발생시킵니다.

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

systemerror와 유사하지만, errno를 설정하는 대신 오류 코드를 반환하기 위해 GetLastError를 사용하는 Windows API 함수에 대한 것입니다.

Ptr{T}

타입 T의 데이터를 참조하는 메모리 주소입니다. 그러나 메모리가 실제로 유효하다는 보장이나 지정된 타입의 데이터를 실제로 나타낸다는 보장이 없습니다.

Ref{T}

타입 T의 데이터를 안전하게 참조하는 객체입니다. 이 타입은 올바른 타입의 유효한 Julia 할당 메모리를 가리키도록 보장됩니다. Ref 자체가 참조되는 한, 기본 데이터는 가비지 컬렉터에 의해 해제되는 것으로부터 보호됩니다.

Julia에서 Ref 객체는 []로 역참조(로드 또는 저장)됩니다.

타입 T의 값 x에 대한 Ref의 생성은 일반적으로 Ref(x)로 작성됩니다. 또한, 컨테이너(예: Array 또는 Ptr)에 대한 내부 포인터를 생성할 때는 Ref(a, i)로 작성하여 a의 i-번째 요소에 대한 참조를 생성할 수 있습니다.

Ref{T}()는 초기화 없이 타입 T의 값에 대한 참조를 생성합니다. 비트 타입 T의 경우, 값은 현재 할당된 메모리에 있는 어떤 것이든 될 것입니다. 비비트 타입 T의 경우, 참조는 정의되지 않으며 이를 역참조하려고 하면 "UndefRefError: access to undefined reference"라는 오류가 발생합니다.

Ref가 정의되지 않은 참조인지 확인하려면 isassigned(ref::RefValue)를 사용하십시오. 예를 들어, isassigned(Ref{T}())는 T가 비트 타입이 아닐 경우 false입니다. T가 비트 타입인 경우, isassigned(Ref{T}())는 항상 true입니다.

ccall 인수로 전달될 때( Ptr 또는 Ref 타입으로), Ref 객체는 참조하는 데이터에 대한 네이티브 포인터로 변환됩니다. 대부분의 T에 대해, 또는 Ptr{Cvoid}로 변환될 때, 이는 객체 데이터에 대한 포인터입니다. T가 isbits 타입인 경우, 이 값은 안전하게 변형될 수 있지만, 그렇지 않으면 변형은 엄격히 정의되지 않은 동작입니다.

특별한 경우로, T = Any로 설정하면 Ptr{Any}로 변환될 때 참조 자체에 대한 포인터가 생성됩니다(불변인 경우 jl_value_t const* const*, 그렇지 않으면 jl_value_t *const *). Ptr{Cvoid}로 변환될 때는 여전히 다른 T와 마찬가지로 데이터 영역에 대한 포인터를 반환합니다.

C_NULL 인스턴스의 Ptr는 초기화하기 위해 ccall Ref 인수로 전달될 수 있습니다.

브로드캐스팅에서의 사용

Ref는 때때로 브로드캐스팅에서 참조된 값을 스칼라로 처리하기 위해 사용됩니다.

예제

julia> r = Ref(5) # 초기 값으로 Ref 생성
Base.RefValue{Int64}(5)

julia> r[] # Ref에서 값 가져오기
5

julia> r[] = 7 # Ref에 새 값 저장
7

julia> r # Ref는 이제 7을 포함합니다
Base.RefValue{Int64}(7)

julia> isa.(Ref([1,2,3]), [Array, Dict, Int]) # 브로드캐스팅 중 참조 값을 스칼라로 처리
3-element BitVector:
 1
 0
 0

julia> Ref{Function}()  # 비비트 타입인 Function에 대한 정의되지 않은 참조
Base.RefValue{Function}(#undef)

julia> try
           Ref{Function}()[] # 정의되지 않은 참조를 역참조하면 오류가 발생합니다
       catch e
           println(e)
       end
UndefRefError()

julia> Ref{Int64}()[]; # 비트 타입에 대한 참조는 주어지지 않으면 미정의 값을 참조합니다

julia> isassigned(Ref{Int64}()) # 비트 타입에 대한 참조는 항상 할당됩니다
true

isassigned(ref::RefValue) -> Bool

주어진 Ref가 값과 연결되어 있는지 테스트합니다. 이는 비트 타입 객체의 Ref에 대해 항상 참입니다. 참조가 정의되지 않은 경우 false를 반환합니다.

예제

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

네이티브 char c-type과 동등합니다.

Cuchar

네이티브 unsigned char c-type (UInt8)에 해당합니다.

Cshort

네이티브 signed short c-type (Int16)와 동등합니다.

Cstring

네이티브 문자 유형 Cchar로 구성된 C 스타일 문자열입니다. Cstring은 NUL로 종료됩니다. 네이티브 와이드 문자 유형으로 구성된 C 스타일 문자열에 대해서는 Cwstring를 참조하세요. C와의 문자열 상호 운용성에 대한 자세한 내용은 매뉴얼을 참조하세요.

Cushort

네이티브 unsigned short c-타입에 해당합니다 (UInt16).

Cint

네이티브 signed int C 타입에 해당합니다 (Int32).

Cuint

네이티브 unsigned int C 타입에 해당합니다 (UInt32).

Clong

네이티브 signed long c-type과 동일합니다.

Culong

네이티브 unsigned long C 타입과 동등합니다.

Clonglong

네이티브 signed long long c-타입에 해당합니다 (Int64).

Culonglong

네이티브 unsigned long long c-타입에 해당합니다 (UInt64).

Cintmax_t

네이티브 intmax_t C 타입에 해당합니다 (Int64).

Cuintmax_t

네이티브 uintmax_t c-타입에 해당합니다 (UInt64).

Csize_t

네이티브 size_t c-타입(UInt)과 동일합니다.

Cssize_t

네이티브 ssize_t C 타입과 동일합니다.

Cptrdiff_t

네이티브 ptrdiff_t c-타입(Int)과 동일합니다.

Cwchar_t

네이티브 wchar_t c-타입에 해당합니다 (Int32).

Cwstring

네이티브 와이드 문자 유형 Cwchar_t로 구성된 C 스타일 문자열입니다. Cwstring은 NUL로 종료됩니다. 네이티브 문자 유형으로 구성된 C 스타일 문자열에 대해서는 Cstring를 참조하십시오. C와의 문자열 상호 운용성에 대한 자세한 내용은 매뉴얼을 참조하십시오.

Cfloat

네이티브 float c-타입에 해당합니다 (Float32).

Cdouble

네이티브 double c-타입에 해당합니다 (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, ...)

첫 번째 인수로 제공된 LLVM 코드를 호출합니다. 이 첫 번째 인수를 지정하는 방법에는 여러 가지가 있습니다:

• 함수 수준 IR을 나타내는 리터럴 문자열로, 인수는 연속적인 이름 없는 SSA 변수(%0, %1 등)로 사용 가능합니다;
• 모듈 IR의 문자열과 호출할 진입점 함수의 이름을 나타내는 문자열을 포함하는 2요소 튜플로;
• 비트코드로 제공된 모듈을 가진 Vector{UInt8}로, 하지만 2요소 튜플로.

ccall과는 달리, 인수 유형은 튜플 유형으로 지정해야 하며, 유형의 튜플이 아닙니다. 모든 유형과 LLVM 코드는 리터럴로 지정해야 하며, 변수나 표현식이 아니어야 합니다(이러한 리터럴을 생성하기 위해 @eval을 사용해야 할 수도 있습니다).

불투명 포인터 ( ptr로 작성됨)는 LLVM 코드에서 허용되지 않습니다.

사용 예는 test/llvmcall.jl를 참조하세요.