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

Вызов функции из C-экспортированной библиотеки общего использования, указанной через library.function_name, где library — строковая константа или литерал. Библиотека может быть опущена, в этом случае function_name разрешается в текущем процессе. В качестве альтернативы, @ccall также может быть использовано для вызова указателя на функцию $function_pointer, например, возвращаемого dlsym.

Каждый argvalue до @ccall преобразуется в соответствующий argtype, путём автоматического вставки вызовов unsafe_convert(argtype, cconvert(argtype, argvalue)). (См. также документацию по unsafe_convert и cconvert для более подробной информации.) В большинстве случаев это просто приводит к вызову convert(argtype, argvalue).

Примеры

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

Это вызывает функцию стандартной C-библиотеки:

size_t strlen(char *)

с использованием переменной Julia с именем s. См. также ccall.

Поддержка аргументов переменной длины происходит по следующей схеме:

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

Точка с запятой используется для разделения обязательных аргументов (должно быть как минимум один) от аргументов переменной длины.

Пример использования внешней библиотеки:

# C signature of g_uri_escape_string:
# 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 также может быть использовано для вызова указателя на функцию function_pointer, например, возвращаемого dlsym.

Обратите внимание, что кортеж типов аргументов должен быть литеральным кортежем, а не кортежем-переменной или выражением.

Каждый argvalue в ccall преобразуется в соответствующий argtype, путём автоматического вставки вызовов unsafe_convert(argtype, cconvert(argtype, argvalue)). (См. также документацию по unsafe_convert и cconvert для более подробной информации.) В большинстве случаев это просто приводит к вызову convert(argtype, argvalue).

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

Получение указателя на глобальную переменную в C-экспортированной библиотеке общего использования, указанной точно так же, как в ccall. Возвращает Ptr{Type}, по умолчанию Ptr{Cvoid}, если аргумент Type не указан. Значения могут быть считаны или записаны с помощью unsafe_load или unsafe_store! соответственно.

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

Генерация указателя на вызываемую функцию C из функции Julia callable для заданной подписи типа. Для передачи возвращаемого значения в ccall, используйте тип аргумента Ptr{Cvoid} в подписи.

Обратите внимание, что кортеж типов аргументов должен быть литеральным кортежем, а не кортежем-переменной или выражением (хотя он может содержать выражение splat). И что эти аргументы будут вычислены в глобальном пространстве имён во время компиляции (а не отложены до времени выполнения). Добавление '$' перед аргументом функции изменяет это на создание замыкания во время выполнения над локальной переменной callable (это не поддерживается на всех архитектурах).

См. раздел руководства по использованию ccall и cfunction.

Примеры

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

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

CFunction struct

Обработка сборки мусора для возвращаемого значения из @cfunction при аннотации первого аргумента символом '$'. Как и все обработчики cfunction, она должна передаваться ccall как Ptr{Cvoid}, и будет автоматически преобразована в вызываемом месте в соответствующий тип.

См. @cfunction.

unsafe_convert(T, x)

Преобразование x в аргумент C типа T, где вход x должен быть возвращаемым значением cconvert(T, ...).

В случаях, когда convert необходимо преобразовать объект Julia в Ptr, следует использовать эту функцию для определения и выполнения этого преобразования.

Убедитесь, что ссылка Julia на x существует, пока результат этой функции будет использоваться. Соответственно, аргумент x этой функции никогда не должен быть выражением, только именем переменной или ссылкой на поле. Например, x=a.b.c допустимо, но x=[a,b,c] — нет.

Префикс unsafe этой функции указывает, что использование результата этой функции после того, как аргумент x этой функции больше недоступен для программы, может привести к неопределённому поведению, включая повреждение программы или сегментофаулы, в любое время в дальнейшем.

См. также cconvert

cconvert(T,x)

Преобразование x в значение, которое должно быть передано в C-код как тип T, обычно путём вызова convert(T, x).

В случаях, когда x не может быть безопасно преобразован в T, в отличие от convert, cconvert может вернуть объект другого типа, который, однако, подходит для обработки unsafe_convert. Результат этой функции должен сохраняться действительным (для сборки мусора) до тех пор, пока результат unsafe_convert больше не нужен. Это можно использовать для выделения памяти, которая будет использоваться C-кодом. Если необходимо выделить несколько объектов, в качестве возвращаемого значения может использоваться кортеж объектов.

Ни convert, ни cconvert не должны принимать объект Julia и преобразовывать его в Ptr.

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

Загрузка значения типа T из адреса i-го элемента (индексируется с 1) начиная с p. Это эквивалентно C-выражению p[i-1].

Префикс unsafe этой функции указывает, что никакая валидация не выполняется для указателя p, чтобы убедиться, что он корректен. Неправильное использование может привести к сегментофаулу вашей программы или возвращению мусора, аналогично C.

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

Запись значения типа T по адресу i-го элемента (индексируется с 1) начиная с p. Это эквивалентно C-выражению p[i-1] = x.

Префикс unsafe этой функции указывает, что никакая валидация не выполняется для указателя p, чтобы убедиться, что он корректен. Неправильное использование может привести к повреждению или сегментофаулу вашей программы, аналогично C.

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!(dest, do, src, so, N)

Копирует элементы из коллекции N, начиная с смещения so, в массив dest, начиная с смещения do. Возвращает dest.

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

Копирует все элементы из коллекции src в массив dest, длина которого должна быть не меньше длины n коллекции src. Первые n элементов массива dest перезаписываются, остальные остаются без изменений.

Примеры

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

Копирует блок данных src в диапазоне Rsrc в блок данных dest в диапазоне Rdest. Размеры двух областей должны совпадать.

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

Копирует UniformScaling в матрицу.

pointer(array [, index])

Получение исходного адреса массива или строки, необязательно по заданному смещению index.

Эта функция является "неопасной". Следует быть внимательным, чтобы убедиться, что ссылка Julia на array существует до тех пор, пока этот указатель будет использоваться. Макрос GC.@preserve должен быть использован для защиты аргумента array от сбора мусора в заданном блоке кода.

Вызов Ref(array[, index]) обычно предпочтительнее этой функции, так как он гарантирует валидность.

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

Оборачивание объекта Julia Array вокруг данных по адресу, указанному в pointer, без копирования. Тип элемента указателя T определяет тип элемента массива. dims - это либо целое число (для одномерного массива), либо кортеж из размерностей массива. own необязательно указывает, должна ли Julia взять на себя управление памятью, вызывая free для указателя, когда массив больше не используется.

Эта функция помечена как "неопасная", так как она аварийно завершится, если pointer не является допустимым адресом в памяти для данных заданной длины.

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 во время выполнения функции на текущей задаче для вызова внешнего кода, который может вызвать код Julia, не поддерживающий прерывания. Предназначена для вызова с помощью синтаксиса блока do, как показано ниже:

disable_sigint() do
    # interrupt-unsafe code
    ...
end

Это не нужно для рабочих потоков (Threads.threadid() != 1), так как InterruptException будет доставлен только главному потоку. Внешние функции, которые не вызывают код Julia или среду выполнения Julia, автоматически отключают обработчик sigint во время своего выполнения.

reenable_sigint(f::Function)

Возобновление обработчика Ctrl-C во время выполнения функции. Временно отменяет действие disable_sigint.

exit_on_sigint(on::Bool)

Устанавливает флаг exit_on_sigint среды выполнения Julia. Если false, Ctrl-C (SIGINT) перехватывается как InterruptException в try блоке. Это поведение по умолчанию в REPL, любом коде, запущенном через -e и -E, и в скриптах Julia, запущенных с опцией -i.

Если true, InterruptException не генерируется Ctrl-C. Запуск кода при таком событии требует atexit. Это поведение по умолчанию в скриптах Julia, запущенных без опции -i.

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

Вызывает исключение SystemError для errno с описательным строковым значением sysfunc, если iftrue имеет значение true

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

Аналогично systemerror, но для функций API Windows, которые используют GetLastError для возврата кода ошибки вместо установки errno.

Ptr{T}

Адрес в памяти, указывающий на данные типа T. Однако нет гарантии, что память действительна или что она действительно представляет данные указанного типа.

Ref{T}

Объект, который безопасно ссылается на данные типа T. Этот тип гарантирует указание на корректную, выделенную память в Julia, подходящего типа. Подлежащие данные защищены от освобождения сборщиком мусора, пока сам Ref ссылается на них.

В Julia, объекты Ref разыменовываются (загружаются или сохраняются) с помощью [].

Создание Ref на значение x типа T обычно записывается как Ref(x). Кроме того, для создания внутренних указателей на контейнеры (такие как Array или Ptr), это может быть записано как Ref(a, i) для создания ссылки на i-й элемент a.

Ref{T}() создаёт ссылку на значение типа T без инициализации. Для T, значение будет таким, какое в данный момент находится в выделенной памяти. Для не-bitstype T, ссылка будет неопределённой, и попытка разыменования приведёт к ошибке "UndefRefError: доступ к неопределённой ссылке".

Для проверки, является ли Ref неопределённой ссылкой, используйте isassigned(ref::RefValue). Например, isassigned(Ref{T}()) равно false если T не является bitstype. Если T является bitstype, isassigned(Ref{T}()) всегда будет истинным.

При передаче в качестве ccall аргумента (как тип Ptr или Ref), объект Ref будет преобразован в родной указатель на данные, на которые он ссылается. Для большинства T, или при преобразовании в Ptr{Cvoid}, это указатель на данные объекта. Когда T является типом isbits, это значение можно безопасно изменять, в противном случае изменение строго запрещено.

В качестве специального случая, установка T = Any вместо этого вызовет создание указателя на саму ссылку при преобразовании в Ptr{Any} (jl_value_t const* const* если T неизменяем, иначе jl_value_t *const *). При преобразовании в Ptr{Cvoid}, он всё равно вернёт указатель на область данных, как и для любого другого T.

Экземпляр C_NULL типа Ptr может быть передан в ccall Ref аргумент для его инициализации.

Использование в широковещательной передаче

Ref иногда используется в широковещательной передаче, чтобы обращаться к ссылаемым значениям как к скалярам.

Примеры

julia> Ref(5)
Base.RefValue{Int64}(5)

julia> isa.(Ref([1,2,3]), [Array, Dict, Int]) # Treat reference values as scalar during broadcasting
3-element BitVector:
 1
 0
 0

julia> Ref{Function}()  # Undefined reference to a non-bitstype, Function
Base.RefValue{Function}(#undef)

julia> try
           Ref{Function}()[] # Dereferencing an undefined reference will result in an error
       catch e
           println(e)
       end
UndefRefError()

julia> Ref{Int64}()[]; # A reference to a bitstype refers to an undetermined value if not given

julia> isassigned(Ref{Int64}()) # A reference to a bitstype is always assigned
true

julia> Ref{Int64}(0)[] == 0 # Explicitly give a value for a bitstype reference
true

isassigned(ref::RefValue) -> Bool

Проверка, связан ли данный Ref со значением. Это всегда верно для Ref объекта bitstype. Возвращает 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.

Cuchar

Эквивалент родному типу unsigned char c (UInt8).

Cshort

Эквивалент родному типу signed short c (Int16).

Cstring

Строка в стиле C, составленная из родных символов типа Cchar. Строки Cstring завершаются нулём. Для строк в стиле C, составленных из родного типа символов с расширенной кодировкой, см. Cwstring. Для получения дополнительной информации о совместимости строк с C, обратитесь к руководству.

Cushort

Эквивалент родному типу unsigned short c (UInt16).

Cint

Эквивалент родному типу signed int c (Int32).

Cuint

Эквивалент родному типу unsigned int c (UInt32).

Clong

Эквивалент родному типу signed long c.

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

Строка в стиле C, составленная из типов символов с широким набором значений Cwchar_t. Строки в стиле C завершаются нулём. Для строк в стиле 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 на уровне функции (аналогично блоку LLVM define), где аргументы доступны как последовательные безымянные переменные SSA (%0, %1 и т. д.);
• в виде пары из двух элементов, содержащей строку с модульным IR и строку, представляющую имя вызываемой функции входа;
• в виде пары из двух элементов, но с модулем, представленным Vector{UINt8} с кодом bitcode.

Обратите внимание, что в отличие от ccall, типы аргументов должны быть указаны как кортеж типа, а не кортеж типов. Все типы, а также код LLVM должны быть указаны как литералы, а не как переменные или выражения (может потребоваться использовать @eval для генерации этих литералов).

Примеры использования см. в test/llvmcall.jl.