c

FFI Binding to C

moon add tonyfettes/c@0.7.8

Download zip

Author

tonyfettes

Version

0.7.8

License

Apache-2.0

Repository

github.com/tonyfettes/c.mbt

Last updated

2 months ago

Downloads

10K

Dependencies

tonyfettes/nat0.1.1

README

#tonyfettes/c

FFI Binding to C.

#Usage

Add this library using moon add:
```
moon add tonyfettes/c
```

Import the library in your moon.pkg.json:

{
  "import": [
    "tonyfettes/c"
  ]
}

Insert the following code somewhere in your MoonBit code:
```
fn init {
  ignore(@c.moonbit_ffi_make_closure)
}
```
This prevents the closure help function from being eliminated by the MoonBit compiler.
Use the library in your code.

#
Pointer

source

using @tonyfettes/c/pointer { type Pointer }

A generic pointer type that wraps the underlying platform pointer type.

Pointer[T] represents a pointer to a value of type T. This type is used for low-level memory operations and interoperability with C code.

#
Ptr

source

using @tonyfettes/c/pointer { type Pointer as Ptr }

A generic pointer type that wraps the underlying platform pointer type.

Pointer[T] represents a pointer to a value of type T. This type is used for low-level memory operations and interoperability with C code.

#
Ptrdiff

source

using @tonyfettes/c/stddef { type Ptrdiff }

#
Size

source

using @tonyfettes/c/stddef { type Size }

#
atexit

source

fn atexit(func : FuncRef[() -> Unit]) -> Int

#
borrow

source

fn[T : @tonyfettes/c/pointer.Borrow
Borrow, R] borrow(value : T, f : (@tonyfettes/c/pointer.Pointer
Pointer[Unit]) -> R raise?) -> R raise?

Borrows a pointer from a value that implements the Borrow trait.

The value is temporarily converted to a pointer, passed to the function, and then restored. This ensures the value remains valid after the operation.

Parameters:

value: The value to borrow from (must implement Borrow)
f: The function to call with the borrowed pointer

Returns the result of calling f.

#
borrow_array

source

fn[T, R] borrow_array(array : FixedArray[T], f : (@tonyfettes/c/pointer.Pointer
Pointer[T]) -> R raise?) -> R raise?

Borrows a pointer from a fixed array for the duration of a function call.

The array is temporarily converted to a pointer, passed to the function, and then restored. This ensures the array remains valid after the operation.

Parameters:

array: The fixed array to borrow from
f: The function to call with the borrowed pointer

Returns the result of calling f.

#
borrow_bytes

source

fn[R] borrow_bytes(bytes : Bytes, f : (@tonyfettes/c/pointer.Pointer
Pointer[Byte]) -> R raise?) -> R raise?

Borrows a pointer from a bytes buffer for the duration of a function call.

The bytes buffer is temporarily converted to a pointer, passed to the function, and then restored. This ensures the buffer remains valid after the operation.

Parameters:

bytes: The bytes buffer to borrow from
f: The function to call with the borrowed pointer

Returns the result of calling f.

#
borrow_ref

source

fn[T, R] borrow_ref(ref_ : @moonbitlang/core/ref.Ref
Ref[T], f : (@tonyfettes/c/pointer.Pointer
Pointer[T]) -> R raise?) -> R raise?

Borrows a pointer from a reference for the duration of a function call.

The reference is temporarily converted to a pointer, passed to the function, and then restored. This ensures the reference remains valid after the operation.

Parameters:

ref_: The reference to borrow from
f: The function to call with the borrowed pointer

Returns the result of calling f.

#
calloc

source

fn[T] calloc(n : @tonyfettes/c/stddef.Size
Size, size : @tonyfettes/c/stddef.Size
Size) -> @tonyfettes/c/pointer.Pointer
Pointer[T]

Allocates and zeroes memory on the heap.

This function is a wrapper around the C calloc function. It allocates memory for an array of n elements, each of size bytes, and initializes all bytes to zero.

Parameters:

n: The number of elements to allocate
size: The size of each element in bytes

Returns a pointer to the allocated and zeroed memory, or a null pointer if allocation fails.

Note: The caller is responsible for freeing the allocated memory using free.

#
exit

source

fn[T] exit(status : Int) -> T

#
exit_failure

source

let exit_failure : Int

#
exit_success

source

let exit_success : Int

#
free

source

fn[T] free(ptr : @tonyfettes/c/pointer.Pointer
Pointer[T]) -> Unit

Frees previously allocated memory.

This function is a wrapper around the C free function. It deallocates the memory block pointed to by ptr, which must have been previously allocated by malloc, calloc, or realloc.

Parameters:

ptr: A pointer to the memory block to free

Note: After calling free, the pointer becomes invalid and should not be used. Freeing a null pointer is safe and does nothing. Freeing the same pointer twice or freeing a pointer not returned by allocation functions leads to undefined behavior.

#
getenv

source

fn[T : @tonyfettes/c/string.Borrow
Borrow] getenv(name : T) -> @tonyfettes/c/pointer.Pointer
Pointer[Byte]

#
malloc

source

fn[T] malloc(size : @tonyfettes/c/stddef.Size
Size) -> @tonyfettes/c/pointer.Pointer
Pointer[T]

Allocates memory on the heap.

This function is a wrapper around the C malloc function. It allocates a block of memory of the specified size and returns a pointer to it. The memory is not initialized.

Parameters:

size: The number of bytes to allocate

Returns a pointer to the allocated memory, or a null pointer if allocation fails.

Note: The caller is responsible for freeing the allocated memory using free.

#
memcpy

source

fn[Dst : @tonyfettes/c/pointer.Borrow
Borrow, Src : @tonyfettes/c/pointer.Borrow
Borrow] memcpy(dst : Dst, src : Src, len : @tonyfettes/c/stddef.Size
Size) -> Unit

Copies memory from source to destination.

This function is a wrapper around the C memcpy function. It copies len bytes from the memory area src to the memory area dst. The memory areas must not overlap (use memmove for overlapping regions).

Parameters:

dst: The destination memory location
src: The source memory location
len: The number of bytes to copy

Note: If the memory regions overlap, the behavior is undefined. Both dst and src must be valid memory locations with at least len bytes accessible.

#
memset

source

fn[Dst] memset(dst : Dst, val : Byte, len : @tonyfettes/c/stddef.Size
Size) -> Unit

Fills a memory block with a constant byte value.

This function is a wrapper around the C memset function. It fills the first len bytes of the memory area pointed to by dst with the constant byte val.

Parameters:

dst: The destination memory location to fill
val: The byte value to fill with
len: The number of bytes to fill

Note: The destination memory must have at least len bytes accessible.

#
null

source

fn[T] null() -> @tonyfettes/c/pointer.Pointer
Pointer[T]

Creates a null pointer of type T.

Returns a null pointer that points to no valid memory location.

#
rand

source

fn rand() -> Int

#
rand_max

source

let rand_max : Int

#
realloc

source

fn[T] realloc(ptr : @tonyfettes/c/pointer.Pointer
Pointer[T], size : UInt64) -> @tonyfettes/c/pointer.Pointer
Pointer[T]

Reallocates a previously allocated memory block.

This function is a wrapper around the C realloc function. It changes the size of the memory block pointed to by ptr to size bytes. The contents of the memory block are preserved up to the minimum of the old and new sizes.

Parameters:

ptr: A pointer to previously allocated memory (or null)
size: The new size in bytes

Returns a pointer to the reallocated memory, which may be different from ptr, or a null pointer if reallocation fails (in which case the original block is unchanged).

Note: If ptr is null, this behaves like malloc. If size is 0, this may behave like free (platform-dependent).

#
srand

source

fn srand(seed : UInt) -> Unit

#
strcmp

source

fn[Str1 : @tonyfettes/c/string.Borrow
Borrow, Str2 : @tonyfettes/c/string.Borrow
Borrow] strcmp(s1 : Str1, s2 : Str2) -> Int

#
strlen

source

fn[Str : @tonyfettes/c/string.Borrow
Borrow] strlen(s : Str) -> @tonyfettes/c/stddef.Size
Size

#
system

source

fn[T : @tonyfettes/c/string.Borrow
Borrow] system(command : T) -> Int

#
unsafe_borrow

source

fn[T, R] unsafe_borrow(value : T, f : (@tonyfettes/c/pointer.Pointer
Pointer[Unit]) -> R raise?) -> R raise?

Unsafely borrows a pointer from any value for the duration of a function call.

Warning: This is an unsafe operation. The value is temporarily converted to a pointer and restored after the function call, but this may lead to undefined behavior if not used carefully.

Parameters:

value: The value to borrow from
f: The function to call with the borrowed pointer

Returns the result of calling f.

Source Files

c.mbt

Site source Report issue Packages Build queue Skills Statistics

c

#tonyfettes/c

#Usage

#Pointer

#Ptr

#Ptrdiff

#Size

#atexit

#borrow

#borrow_array

#borrow_bytes

#borrow_ref

#calloc

#exit

#exit_failure

#exit_success

#free

#getenv

#malloc

#memcpy

#memset

#null

#rand

#rand_max

#realloc

#srand

#strcmp

#strlen

#system

#unsafe_borrow

Source Files

#
Pointer

#
Ptr

#
Ptrdiff

#
Size

#
atexit

#
borrow

#
borrow_array

#
borrow_bytes

#
borrow_ref

#
calloc

#
exit

#
exit_failure

#
exit_success

#
free

#
getenv

#
malloc

#
memcpy

#
memset

#
null

#
rand

#
rand_max

#
realloc

#
srand

#
strcmp

#
strlen

#
system

#
unsafe_borrow