@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.

Поддержка аргументов с произвольным числом параметров (varargs) реализована следующим образом:

@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 может вернуть объект другого типа, отличного от T, но подходящего для обработки unsafe_convert. Результат этой функции должен оставаться валидным (для GC) до тех пор, пока результат unsafe_convert больше не нужен. Это может быть использовано для выделения памяти, которая будет обработана ccall. Если нужно выделить несколько объектов, то кортеж из объектов может быть использован как возвращаемое значение.

Ни 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

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

Примеры

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.

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

В большинстве случаев предпочтительнее вызывать 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 runtime, автоматически отключают обработку sigint во время своего выполнения.

reenable_sigint(f::Function)

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

exit_on_sigint(on::Bool)

Установить флаг exit_on_sigint в Julia runtime. Если 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 и т.д.);
• как кортеж из 2 элементов, содержащий строку модульного IR и строку, представляющую имя функции точки входа для вызова;
• как кортеж из 2 элементов, но с модулем, представленным как Vector{UINt8} с биткодом.

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

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