mt-lang 0.2.0 → 0.2.1

data/std/c/string.mt

@@ -0,0 +1,16 @@
+# generated by mtc bindgen from /home/teefan/Projects/Ruby/mt-lang/std/c/string_bindgen.h
+external
+
+include "string_bindgen.h"
+
+external function mt_string_memcpy(destination: ptr[void], source: const_ptr[void], size_bytes: ptr_uint) -> ptr[void]
+external function mt_string_memmove(destination: ptr[void], source: const_ptr[void], size_bytes: ptr_uint) -> ptr[void]
+external function mt_string_memset(destination: ptr[void], value: int, size_bytes: ptr_uint) -> ptr[void]
+external function mt_string_memcmp(left: const_ptr[void], right: const_ptr[void], size_bytes: ptr_uint) -> int
+external function mt_string_memchr(source: const_ptr[void], value: int, size_bytes: ptr_uint) -> ptr[void]?
+external function mt_string_strlen(text: cstr) -> ptr_uint
+external function mt_string_strcmp(left: cstr, right: cstr) -> int
+external function mt_string_strncmp(left: cstr, right: cstr, size_bytes: ptr_uint) -> int
+external function mt_string_strchr(text: cstr, value: int) -> ptr[char]?
+external function mt_string_strrchr(text: cstr, value: int) -> ptr[char]?
+external function mt_string_strstr(haystack: cstr, needle: cstr) -> ptr[char]?

data/std/c/string_bindgen.h

@@ -0,0 +1,36 @@
+#ifndef MT_LANG_STRING_BINDGEN_H
+#define MT_LANG_STRING_BINDGEN_H
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static inline void *mt_string_memcpy(void *destination, const void *source, size_t size_bytes) { return memcpy(destination, source, size_bytes); }
+static inline void *mt_string_memmove(void *destination, const void *source, size_t size_bytes) { return memmove(destination, source, size_bytes); }
+static inline void *mt_string_memset(void *destination, int value, size_t size_bytes) { return memset(destination, value, size_bytes); }
+static inline int mt_string_memcmp(const void *left, const void *right, size_t size_bytes) { return memcmp(left, right, size_bytes); }
+#ifdef __cplusplus
+static inline void *mt_string_memchr(const void *source, int value, size_t size_bytes) { return const_cast<void *>(memchr(source, value, size_bytes)); }
+#else
+static inline void *mt_string_memchr(const void *source, int value, size_t size_bytes) { return memchr(source, value, size_bytes); }
+#endif
+static inline size_t mt_string_strlen(const char *text) { return strlen(text); }
+static inline int mt_string_strcmp(const char *left, const char *right) { return strcmp(left, right); }
+static inline int mt_string_strncmp(const char *left, const char *right, size_t size_bytes) { return strncmp(left, right, size_bytes); }
+#ifdef __cplusplus
+static inline char *mt_string_strchr(const char *text, int value) { return const_cast<char *>(strchr(text, value)); }
+static inline char *mt_string_strrchr(const char *text, int value) { return const_cast<char *>(strrchr(text, value)); }
+static inline char *mt_string_strstr(const char *haystack, const char *needle) { return const_cast<char *>(strstr(haystack, needle)); }
+#else
+static inline char *mt_string_strchr(const char *text, int value) { return strchr(text, value); }
+static inline char *mt_string_strrchr(const char *text, int value) { return strrchr(text, value); }
+static inline char *mt_string_strstr(const char *haystack, const char *needle) { return strstr(haystack, needle); }
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/std/c/sync.mt

@@ -0,0 +1,33 @@
+external
+
+link "uv"
+include "sync_support.h"
+
+opaque mt_mutex = c"mt_mutex"
+opaque mt_condition = c"mt_condition"
+opaque mt_semaphore = c"mt_semaphore"
+opaque mt_atomic_uint = c"mt_atomic_uint"
+
+external function mt_mutex_create(out out_mutex: ptr[mt_mutex]?) -> int
+external function mt_mutex_create_recursive(out out_mutex: ptr[mt_mutex]?) -> int
+external function mt_mutex_destroy(handle: ptr[mt_mutex]?) -> void
+external function mt_mutex_lock(handle: ptr[mt_mutex]) -> void
+external function mt_mutex_try_lock(handle: ptr[mt_mutex]) -> int
+external function mt_mutex_unlock(handle: ptr[mt_mutex]) -> void
+external function mt_condition_create(out out_condition: ptr[mt_condition]?) -> int
+external function mt_condition_destroy(handle: ptr[mt_condition]?) -> void
+external function mt_condition_signal(handle: ptr[mt_condition]) -> void
+external function mt_condition_broadcast(handle: ptr[mt_condition]) -> void
+external function mt_condition_wait(handle: ptr[mt_condition], mutex: ptr[mt_mutex]) -> void
+external function mt_semaphore_create(initial_value: uint, out out_semaphore: ptr[mt_semaphore]?) -> int
+external function mt_semaphore_destroy(handle: ptr[mt_semaphore]?) -> void
+external function mt_semaphore_post(handle: ptr[mt_semaphore]) -> void
+external function mt_semaphore_wait(handle: ptr[mt_semaphore]) -> void
+external function mt_semaphore_try_wait(handle: ptr[mt_semaphore]) -> int
+external function mt_atomic_uint_create(out out_atomic: ptr[mt_atomic_uint]?, initial_value: uint) -> int
+external function mt_atomic_uint_destroy(handle: ptr[mt_atomic_uint]?) -> void
+external function mt_atomic_uint_load(atomic: ptr[mt_atomic_uint]) -> uint
+external function mt_atomic_uint_store(atomic: ptr[mt_atomic_uint], new_value: uint) -> void
+external function mt_atomic_uint_fetch_add(atomic: ptr[mt_atomic_uint], delta: uint) -> uint
+external function mt_atomic_uint_fetch_sub(atomic: ptr[mt_atomic_uint], delta: uint) -> uint
+external function mt_atomic_uint_compare_exchange(atomic: ptr[mt_atomic_uint], expected: ptr[uint], desired: uint) -> bool

data/std/c/sync_support.h

@@ -0,0 +1,219 @@
+#ifndef MT_SYNC_SUPPORT_H
+#define MT_SYNC_SUPPORT_H
+
+#include <stdlib.h>
+#include <uv.h>
+
+typedef struct mt_mutex {
+  uv_mutex_t native;
+} mt_mutex;
+
+typedef struct mt_condition {
+  uv_cond_t native;
+} mt_condition;
+
+typedef struct mt_semaphore {
+  uv_sem_t native;
+} mt_semaphore;
+
+static inline int mt_mutex_create(mt_mutex** out_mutex) {
+  if (out_mutex != NULL) {
+    *out_mutex = NULL;
+  }
+
+  mt_mutex* mutex = (mt_mutex*) malloc(sizeof(mt_mutex));
+  if (mutex == NULL) {
+    return UV_ENOMEM;
+  }
+
+  int status = uv_mutex_init(&mutex->native);
+  if (status != 0) {
+    free(mutex);
+    return status;
+  }
+
+  if (out_mutex != NULL) {
+    *out_mutex = mutex;
+  }
+  return 0;
+}
+
+static inline int mt_mutex_create_recursive(mt_mutex** out_mutex) {
+  if (out_mutex != NULL) {
+    *out_mutex = NULL;
+  }
+
+  mt_mutex* mutex = (mt_mutex*) malloc(sizeof(mt_mutex));
+  if (mutex == NULL) {
+    return UV_ENOMEM;
+  }
+
+  int status = uv_mutex_init_recursive(&mutex->native);
+  if (status != 0) {
+    free(mutex);
+    return status;
+  }
+
+  if (out_mutex != NULL) {
+    *out_mutex = mutex;
+  }
+  return 0;
+}
+
+static inline void mt_mutex_destroy(mt_mutex* handle) {
+  if (handle == NULL) {
+    return;
+  }
+
+  uv_mutex_destroy(&handle->native);
+  free(handle);
+}
+
+static inline void mt_mutex_lock(mt_mutex* handle) {
+  uv_mutex_lock(&handle->native);
+}
+
+static inline int mt_mutex_try_lock(mt_mutex* handle) {
+  return uv_mutex_trylock(&handle->native);
+}
+
+static inline void mt_mutex_unlock(mt_mutex* handle) {
+  uv_mutex_unlock(&handle->native);
+}
+
+static inline int mt_condition_create(mt_condition** out_condition) {
+  if (out_condition != NULL) {
+    *out_condition = NULL;
+  }
+
+  mt_condition* condition = (mt_condition*) malloc(sizeof(mt_condition));
+  if (condition == NULL) {
+    return UV_ENOMEM;
+  }
+
+  int status = uv_cond_init(&condition->native);
+  if (status != 0) {
+    free(condition);
+    return status;
+  }
+
+  if (out_condition != NULL) {
+    *out_condition = condition;
+  }
+  return 0;
+}
+
+static inline void mt_condition_destroy(mt_condition* handle) {
+  if (handle == NULL) {
+    return;
+  }
+
+  uv_cond_destroy(&handle->native);
+  free(handle);
+}
+
+static inline void mt_condition_signal(mt_condition* handle) {
+  uv_cond_signal(&handle->native);
+}
+
+static inline void mt_condition_broadcast(mt_condition* handle) {
+  uv_cond_broadcast(&handle->native);
+}
+
+static inline void mt_condition_wait(mt_condition* handle, mt_mutex* mutex) {
+  uv_cond_wait(&handle->native, &mutex->native);
+}
+
+static inline int mt_semaphore_create(unsigned int initial_value, mt_semaphore** out_semaphore) {
+  if (out_semaphore != NULL) {
+    *out_semaphore = NULL;
+  }
+
+  mt_semaphore* semaphore = (mt_semaphore*) malloc(sizeof(mt_semaphore));
+  if (semaphore == NULL) {
+    return UV_ENOMEM;
+  }
+
+  int status = uv_sem_init(&semaphore->native, initial_value);
+  if (status != 0) {
+    free(semaphore);
+    return status;
+  }
+
+  if (out_semaphore != NULL) {
+    *out_semaphore = semaphore;
+  }
+  return 0;
+}
+
+static inline void mt_semaphore_destroy(mt_semaphore* handle) {
+  if (handle == NULL) {
+    return;
+  }
+
+  uv_sem_destroy(&handle->native);
+  free(handle);
+}
+
+static inline void mt_semaphore_post(mt_semaphore* handle) {
+  uv_sem_post(&handle->native);
+}
+
+static inline void mt_semaphore_wait(mt_semaphore* handle) {
+  uv_sem_wait(&handle->native);
+}
+
+static inline int mt_semaphore_try_wait(mt_semaphore* handle) {
+  return uv_sem_trywait(&handle->native);
+}
+
+typedef struct mt_atomic_uint {
+  unsigned int value;
+} mt_atomic_uint;
+
+static inline int mt_atomic_uint_create(mt_atomic_uint** out_atomic, unsigned int initial_value) {
+  if (out_atomic != NULL) {
+    *out_atomic = NULL;
+  }
+
+  mt_atomic_uint* atomic = (mt_atomic_uint*) malloc(sizeof(mt_atomic_uint));
+  if (atomic == NULL) {
+    return UV_ENOMEM;
+  }
+
+  atomic->value = initial_value;
+  if (out_atomic != NULL) {
+    *out_atomic = atomic;
+  }
+  return 0;
+}
+
+static inline void mt_atomic_uint_destroy(mt_atomic_uint* handle) {
+  if (handle == NULL) {
+    return;
+  }
+
+  free(handle);
+}
+
+static inline unsigned int mt_atomic_uint_load(mt_atomic_uint* atomic) {
+  return __atomic_load_n(&atomic->value, __ATOMIC_SEQ_CST);
+}
+
+static inline void mt_atomic_uint_store(mt_atomic_uint* atomic, unsigned int new_value) {
+  __atomic_store_n(&atomic->value, new_value, __ATOMIC_SEQ_CST);
+}
+
+static inline unsigned int mt_atomic_uint_fetch_add(mt_atomic_uint* atomic, unsigned int delta) {
+  return __atomic_fetch_add(&atomic->value, delta, __ATOMIC_SEQ_CST);
+}
+
+static inline unsigned int mt_atomic_uint_fetch_sub(mt_atomic_uint* atomic, unsigned int delta) {
+  return __atomic_fetch_sub(&atomic->value, delta, __ATOMIC_SEQ_CST);
+}
+
+static inline bool mt_atomic_uint_compare_exchange(mt_atomic_uint* atomic, unsigned int* expected, unsigned int desired) {
+  return __atomic_compare_exchange_n(&atomic->value, expected, desired, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+}
+
+#endif

data/std/c/terminal.mt

@@ -0,0 +1,24 @@
+external
+
+include "terminal_support.h"
+
+struct mt_terminal_size = c"mt_terminal_size":
+    width: int
+    height: int
+
+struct mt_terminal_error = c"mt_terminal_error":
+    code: int
+    message_data: ptr[char]?
+    message_len: ptr_uint
+
+external function mt_terminal_stdin_is_tty() -> bool
+external function mt_terminal_stdout_is_tty() -> bool
+external function mt_terminal_stderr_is_tty() -> bool
+external function mt_terminal_get_size(out result: mt_terminal_size, out error: mt_terminal_error) -> int
+external function mt_terminal_enter_raw_mode(out error: mt_terminal_error) -> int
+external function mt_terminal_leave_raw_mode(out error: mt_terminal_error) -> int
+external function mt_terminal_write_stdout(buffer: const_ptr[ubyte]?, len: ptr_uint, out out_written: ptr_uint, out error: mt_terminal_error) -> int
+external function mt_terminal_write_stderr(buffer: const_ptr[ubyte]?, len: ptr_uint, out out_written: ptr_uint, out error: mt_terminal_error) -> int
+external function mt_terminal_flush_stdout(out error: mt_terminal_error) -> int
+external function mt_terminal_flush_stderr(out error: mt_terminal_error) -> int
+external function mt_terminal_read_stdin(buffer: ptr[ubyte]?, capacity: ptr_uint, timeout_ms: int, out out_read: ptr_uint, out error: mt_terminal_error) -> int