std::ffi::c (v0.2.1)
Type aliases, constants, and C ABI signatures used by standard wrappers.
Latest
Overview
std::ffi::c contains the raw C bindings used by the standard library. The declarations are grouped by area, such as I/O, memory, math, and primitive C types.
Most application code should prefer std::io, std::mem, or std::math. Those modules use clearer Thrust names while still relying on the same C symbols underneath.
Use the raw FFI layer when you need a C symbol directly or when writing a wrapper for a library that is not yet covered by std.
Source: thrustc/std/v0.2.1/ffi/c/*.thrust
Public Signatures
Exported declarations for this module snapshot.
type c_Char @public = s8;
type c_SignedChar @public = s8;
type c_UnsignedChar @public = u8;
type c_Short @public = s16;
type c_UnsignedShort @public = u16;
type c_Int @public = s32;
type c_UnsignedInt @public = u32;
type c_Long @public = s64;
type c_UnsignedLong @public = u64;
type c_LongLong @public = s64;
type c_UnsignedLongLong @public = u64;
type c_Int8 @public = s8;
type c_Uint8 @public = u8;
type c_Int16 @public = s16;
type c_Uint16 @public = u16;
type c_Int32 @public = s32;
type c_Uint32 @public = u32;
type c_Int64 @public = s64;
type c_Uint64 @public = u64;
type c_Float @public = f32;
type c_Double @public = f64;
type c_LongDouble @public = f80;
type c_Bool @public = bool;
type c_SizeT @public = usize;
type c_SsizeT @public = ssize;
type c_PtrdiffT @public = ssize;
type c_WcharT @public = s32;
type c_IntPtrT @public = ssize;
type c_UintPtrT @public = usize;
static mut stdin: ptr @public @extern("stdin");
static mut stdout: ptr @public @extern("stdout");
static mut stderr: ptr @public @extern("stderr");
fn vprintf(fmt: CString, ap: ptr) s32 @public @extern("vprintf") @convention("C");
fn vfprintf(stream: ptr, fmt: CString, ap: ptr) s32 @public @extern("vfprintf") @convention("C");
fn vsprintf(buffer: ptr, fmt: CString, ap: ptr) s32 @public @extern("vsprintf") @convention("C");
fn vsnprintf(buffer: ptr, size: usize, fmt: CString, ap: ptr) s32 @public @extern("vsnprintf") @convention("C");
fn vscanf(fmt: CString, ap: ptr) s32 @public @extern("vscanf") @convention("C");
fn vfscanf(stream: ptr, fmt: CString, ap: ptr) s32 @public @extern("vfscanf") @convention("C");
fn vsscanf(text: CString, fmt: CString, ap: ptr) s32 @public @extern("vsscanf") @convention("C");
fn fopen(filename: CString, mode: CString) ptr @public @extern("fopen") @convention("C");
fn freopen(filename: CString, mode: CString, stream: ptr) ptr @public @extern("freopen") @convention("C");
fn fclose(stream: ptr) s32 @public @extern("fclose") @convention("C");
fn fflush(stream: ptr) s32 @public @extern("fflush") @convention("C");
fn fread(buffer: ptr, size: usize, count: usize, stream: ptr) usize @public @extern("fread") @convention("C");
fn fwrite(buffer: ptr, size: usize, count: usize, stream: ptr) usize @public @extern("fwrite") @convention("C");
fn fseek(stream: ptr, offset: s64, whence: s32) s32 @public @extern("fseek") @convention("C");
fn ftell(stream: ptr) s64 @public @extern("ftell") @convention("C");
fn rewind(stream: ptr) void @public @extern("rewind") @convention("C");
fn fgetpos(stream: ptr, position: ptr) s32 @public @extern("fgetpos") @convention("C");
fn fsetpos(stream: ptr, position: ptr) s32 @public @extern("fsetpos") @convention("C");
fn feof(stream: ptr) s32 @public @extern("feof") @convention("C");
fn ferror(stream: ptr) s32 @public @extern("ferror") @convention("C");
fn clearerr(stream: ptr) void @public @extern("clearerr") @convention("C");
fn fileno(stream: ptr) s32 @public @extern("fileno") @convention("C");
fn fdopen(fd: s32, mode: CString) ptr @public @extern("fdopen") @convention("C");
fn fgetc(stream: ptr) s32 @public @extern("fgetc") @convention("C");
fn getc(stream: ptr) s32 @public @extern("getc") @convention("C");
fn getchar() s32 @public @extern("getchar") @convention("C");
fn fputc(character: s32, stream: ptr) s32 @public @extern("fputc") @convention("C");
fn putc(character: s32, stream: ptr) s32 @public @extern("putc") @convention("C");
fn putchar(character: s32) s32 @public @extern("putchar") @convention("C");
fn ungetc(character: s32, stream: ptr) s32 @public @extern("ungetc") @convention("C");
fn fgets(buffer: ptr, size: s32, stream: ptr) ptr @public @extern("fgets") @convention("C");
fn fputs(text: CString, stream: ptr) s32 @public @extern("fputs") @convention("C");
fn puts(text: CString) s32 @public @extern("puts") @convention("C");
fn perror(text: CString) void @public @extern("perror") @convention("C");
fn remove(filename: CString) s32 @public @extern("remove") @convention("C");
fn rename(old: CString, newName: CString) s32 @public @extern("rename") @convention("C");
fn setvbuf(stream: ptr, buffer: ptr, mode: s32, size: usize) s32 @public @extern("setvbuf") @convention("C");
fn setbuf(stream: ptr, buffer: ptr) void @public @extern("setbuf") @convention("C");
fn tmpfile() ptr @public @extern("tmpfile") @convention("C");
fn fseeko(stream: ptr, offset: s64, whence: s32) s32 @public @extern("fseeko") @convention("C");
fn ftello(stream: ptr) s64 @public @extern("ftello") @convention("C");
fn getline(lineptr: ptr, n: ptr[usize], stream: ptr) s64 @public @extern("getline") @convention("C");
const c_PROT_READ: s32 @public = 0x1;
const c_PROT_WRITE: s32 @public = 0x2;
const c_PROT_EXEC: s32 @public = 0x4;
const c_PROT_NONE: s32 @public = 0x0;
const c_PROT_GROWSDOWN: s32 @public = 0x01000000;
const c_PROT_GROWSUP: s32 @public = 0x02000000;
const c_MAP_SHARED: s32 @public = 0x01;
const c_MAP_PRIVATE: s32 @public = 0x02;
const c_MAP_SHARED_VALIDATE: s32 @public = 0x03;
const c_MAP_TYPE: s32 @public = 0x0f;
const c_MAP_FIXED: s32 @public = 0x10;
const c_MAP_ANONYMOUS: s32 @public = 0x20;
const c_MAP_ANON: s32 @public = 0x20;
const c_MAP_GROWSDOWN: s32 @public = 0x00100;
const c_MAP_DENYWRITE: s32 @public = 0x00800;
const c_MAP_EXECUTABLE: s32 @public = 0x01000;
const c_MAP_LOCKED: s32 @public = 0x02000;
const c_MAP_NORESERVE: s32 @public = 0x04000;
const c_MAP_POPULATE: s32 @public = 0x08000;
const c_MAP_NONBLOCK: s32 @public = 0x10000;
const c_MAP_STACK: s32 @public = 0x20000;
const c_MAP_HUGETLB: s32 @public = 0x40000;
const c_MAP_SYNC: s32 @public = 0x80000;
const c_MAP_FIXED_NOREPLACE: s32 @public = 0x100000;
const c_MS_ASYNC: s32 @public = 1;
const c_MS_INVALIDATE: s32 @public = 2;
const c_MS_SYNC: s32 @public = 4;
const c_MADV_NORMAL: s32 @public = 0;
const c_MADV_RANDOM: s32 @public = 1;
const c_MADV_SEQUENTIAL: s32 @public = 2;
const c_MADV_WILLNEED: s32 @public = 3;
const c_MADV_DONTNEED: s32 @public = 4;
const c_MADV_FREE: s32 @public = 8;
const c_MADV_REMOVE: s32 @public = 9;
const c_MADV_DONTFORK: s32 @public = 10;
const c_MADV_DOFORK: s32 @public = 11;
const c_MADV_MERGEABLE: s32 @public = 12;
const c_MADV_UNMERGEABLE: s32 @public = 13;
const c_MADV_HUGEPAGE: s32 @public = 14;
const c_MADV_NOHUGEPAGE: s32 @public = 15;
const c_MADV_DONTDUMP: s32 @public = 16;
const c_MADV_DODUMP: s32 @public = 17;
const c_MADV_WIPEONFORK: s32 @public = 18;
const c_MADV_KEEPONFORK: s32 @public = 19;
const c_MADV_COLD: s32 @public = 20;
fn sin(x: f64) f64 @public @extern("sin") @convention("C");
fn cos(x: f64) f64 @public @extern("cos") @convention("C");
fn tan(x: f64) f64 @public @extern("tan") @convention("C");
fn asin(x: f64) f64 @public @extern("asin") @convention("C");
fn acos(x: f64) f64 @public @extern("acos") @convention("C");
fn atan(x: f64) f64 @public @extern("atan") @convention("C");
fn atan2(y: f64, x: f64) f64 @public @extern("atan2") @convention("C");
fn sinh(x: f64) f64 @public @extern("sinh") @convention("C");
fn cosh(x: f64) f64 @public @extern("cosh") @convention("C");
fn tanh(x: f64) f64 @public @extern("tanh") @convention("C");
fn asinh(x: f64) f64 @public @extern("asinh") @convention("C");
fn acosh(x: f64) f64 @public @extern("acosh") @convention("C");
fn atanh(x: f64) f64 @public @extern("atanh") @convention("C");
fn exp(x: f64) f64 @public @extern("exp") @convention("C");
fn exp2(x: f64) f64 @public @extern("exp2") @convention("C");
fn expm1(x: f64) f64 @public @extern("expm1") @convention("C");
fn log(x: f64) f64 @public @extern("log") @convention("C");
fn log2(x: f64) f64 @public @extern("log2") @convention("C");
fn log10(x: f64) f64 @public @extern("log10") @convention("C");
fn log1p(x: f64) f64 @public @extern("log1p") @convention("C");
fn logb(x: f64) f64 @public @extern("logb") @convention("C");
fn ldexp(x: f64, exponent: s32) f64 @public @extern("ldexp") @convention("C");
fn frexp(x: f64, exponent: ptr[s32]) f64 @public @extern("frexp") @convention("C");
fn modf(x: f64, integer_part: ptr[f64]) f64 @public @extern("modf") @convention("C");
fn pow(x: f64, y: f64) f64 @public @extern("pow") @convention("C");
fn sqrt(x: f64) f64 @public @extern("sqrt") @convention("C");
fn cbrt(x: f64) f64 @public @extern("cbrt") @convention("C");
fn hypot(x: f64, y: f64) f64 @public @extern("hypot") @convention("C");
fn pown(x: f64, n: s64) f64 @public @extern("pown") @convention("C");
fn powr(x: f64, y: f64) f64 @public @extern("powr") @convention("C");
fn rootn(x: f64, n: s64) f64 @public @extern("rootn") @convention("C");
fn rsqrt(x: f64) f64 @public @extern("rsqrt") @convention("C");
fn compoundn(x: f64, n: s64) f64 @public @extern("compoundn") @convention("C");
fn ceil(x: f64) f64 @public @extern("ceil") @convention("C");
fn floor(x: f64) f64 @public @extern("floor") @convention("C");
fn round(x: f64) f64 @public @extern("round") @convention("C");
fn trunc(x: f64) f64 @public @extern("trunc") @convention("C");
fn rint(x: f64) f64 @public @extern("rint") @convention("C");
fn nearbyint(x: f64) f64 @public @extern("nearbyint") @convention("C");
fn fmod(x: f64, y: f64) f64 @public @extern("fmod") @convention("C");
fn remainder(x: f64, y: f64) f64 @public @extern("remainder") @convention("C");
fn remquo(x: f64, y: f64, quotient: ptr[s32]) f64 @public @extern("remquo") @convention("C");
fn fabs(x: f64) f64 @public @extern("fabs") @convention("C");
fn fmin(x: f64, y: f64) f64 @public @extern("fmin") @convention("C");
fn fmax(x: f64, y: f64) f64 @public @extern("fmax") @convention("C");Behavior and Use
Each declaration must match the external C symbol. Pay special attention to pointer types, return types, and variadic functions.
Keep raw extern calls in small wrappers when possible. That makes mistakes easier to find and keeps the rest of the program cleaner.
Examples
import std::ffi::c::io as c;
fn printLine(msg: CString) void @public {
c::puts(msg);
}import std::ffi::c::math as c;
fn absValue(v: f64) f64 @public {
return c::fabs(v);
}Notes
- Raw bindings follow the behavior of the C library on the target platform.
- Prefer wrapper modules for normal application code.
- When a C library changes, recheck the matching Thrust declarations.