C Интерфейс

ccallКлючевое слово

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

Вызывает функцию в библиотеке общего пользования C, экспортируемой на 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).

Core.Intrinsics.cglobalФункция

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

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

Base.@cfunctionМакрос

@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

Base.CFunctionТип

CFunction struct

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

См. @cfunction.

Base.unsafe_convertФункция

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

Base.cconvertФункция

cconvert(T,x)

Преобразует x в значение, которое будет передано коду C как тип T, обычно вызывая convert(T, x).

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

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

Base.unsafe_loadФункция

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

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

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

Base.unsafe_store!Функция

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

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

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

Base.unsafe_copyto!Метод

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

Копирует N элементов из исходного указателя в целевой, без проверок. Размер элемента определяется типом указателей.

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

Base.unsafe_copyto!Метод

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

Копирует N элементов из исходного массива в целевой, начиная со смещения so в источнике и do в пункте назначения (индексирование с 1).

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

Base.copyto!Функция

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

Копирует N элементов из коллекции src начиная со смещения 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 Array{Float64,1}:
 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 в матрицу.

Base.pointerФункция

pointer(array [, index])

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

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

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

Base.unsafe_wrapМетод

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

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

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

Base.pointer_from_objrefФункция

pointer_from_objref(x)

Получить адрес памяти объекта Julia в виде Ptr. Существование полученного Ptr не защищает объект от сборки мусора, поэтому необходимо гарантировать, что объект остается ссылкой в течение всего времени использования Ptr.

Эта функция не может быть вызвана для неизменяемых объектов, так как у них нет стабильных адресов памяти.

См. также: unsafe_pointer_to_objref.

Base.unsafe_pointer_to_objrefФункция

unsafe_pointer_to_objref(p::Ptr)

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

См. также: pointer_from_objref.

Base.disable_sigintФункция

disable_sigint(f::Function)

Отключает обработчик Ctrl+C во время выполнения функции на текущей задаче для вызова внешнего кода, который может вызывать код Julia, не поддерживающий прерывания. Предполагается, что она вызывается с использованием синтаксиса блока do, как показано ниже:

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

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

Base.reenable_sigintФункция

reenable_sigint(f::Function)

Включает обработчик Ctrl+C после выполнения функции. Временно отменяет эффект функции disable_sigint.

Base.systemerrorФункция

systemerror(sysfunc, iftrue)

Возбуждает SystemError для errno с описательной строкой sysfunc, если iftrue равно true.

Core.PtrТип

Ptr{T}

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

Core.RefТип

Ref{T}

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

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

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

При передаче в качестве аргумента ccall (либо как тип Ptr, либо Ref), объект Ref будет преобразован в базовый указатель на данные, к которым он ссылается.

В Julia нет недействительных (NULL) Ref , но экземпляр C_NULL типа Ptr может быть передан аргументу ccall Ref.

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

При широковещательной передаче с Ref(x) объект x рассматривается как скаляр:

julia> isa.(Ref([1,2,3]), [Array, Dict, Int])
3-element BitArray{1}:
 1
 0
 0

Base.CcharТип

Cchar

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

Base.CucharТип

Cuchar

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

Base.CshortТип

Cshort

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

Base.CstringТип

Cstring

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

Base.CushortТип

Cushort

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

Base.CintТип

Cint

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

Base.CuintТип

Cuint

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

Base.ClongТип

Clong

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

Base.CulongТип

Culong

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

Base.ClonglongТип

Clonglong

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

Base.CulonglongТип

Culonglong

Эквивалент собственному типу unsigned long long c (UInt64).

Base.Cintmax_tТип

Cintmax_t

Эквивалент собственному типу intmax_t c (Int64).

Base.Cuintmax_tТип

Cuintmax_t

Эквивалент собственному типу uintmax_t c (UInt64).

Base.Csize_tТип

Csize_t

Эквивалент собственному типу size_t c (UInt).

Base.Cssize_tТип

Cssize_t

Эквивалент собственному типу ssize_t c-типа.

Base.Cptrdiff_tТип

Cptrdiff_t

Эквивалент собственному типу ptrdiff_t c-типа (Int).

Base.Cwchar_tТип

Cwchar_t

Эквивалент собственному типу wchar_t c-типа (Int32).

Base.CwstringТип

Cwstring

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

Base.CfloatТип

Cfloat

Эквивалент собственному типу float c (Float32).

Base.CdoubleТип

Cdouble

Эквивалент собственному типу double c (Float64).

Интерфейс LLVM

Core.Intrinsics.llvmcallФункция

llvmcall(IR::String, ReturnType, (ArgumentType1, ...), ArgumentValue1, ...)
llvmcall((declarations::String, IR::String), ReturnType, (ArgumentType1, ...), ArgumentValue1, ...)

Вызов LLVM IR строки в первом аргументе. Аналогично блоку LLVM функции define, аргументы доступны как последовательные неименованные переменные SSA (%0, %1 и т. д.).

Необязательная строка объявлений содержит объявления внешних функций, необходимые для компиляции LLVM IR строки. Несколько объявлений можно передать, разделив их символом новой строки.

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

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

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