@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} в подписи.

Обратите внимание, что кортеж типа аргументов должен быть литеральным кортежем, а не переменной или выражением с кортежем в качестве значения (хотя он может содержать выражение с разбросом). И что эти аргументы будут оценены в глобальной области видимости во время компиляции (а не отложены до выполнения). Добавление '$' перед аргументом функции изменяет это на создание замыкания во время выполнения над локальной переменной 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::AbstractMatrix, src::UniformScaling)

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

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

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

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

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

См. также 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 в блок данных dest в диапазоне Rdest. Размеры двух областей должны совпадать.

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 или runtime Julia, автоматически отключают sigint во время своего выполнения.

reenable_sigint(f::Function)

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

exit_on_sigint(on::Bool)

Установить флаг exit_on_sigint runtime 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, значение будет таким, каким оно в настоящий момент находится в выделенной памяти. Для небитовых типов T, ссылка будет неопределённой, и попытка обратится к ней приведёт к ошибке "UndefRefError: доступ к неопределённой ссылке".

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

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

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