Tetralux

/*
    A short demonstration of how atomized strings (strings turned into single ints to make comparison faster and storage simpler) can be serialised into a stream (or file),
    alongside the blobs that refer to them, without doing anything more than just memcpy'ing everything into the stream.

    It achieves this using the following techniques:
    1) Atoms are stored in the Person structs only. They are i32s.
    2) Atomizer turns strings into i32s by copying their length (u32le) into a buffer, followed by the string data. The current offset into the buffer is the atom for that string.
    3) Both the slice of Persons and the atomizer's buffer can be directly written into a stream without alteration. See the comment in main() of the output.

    Written by Tetralux 2024-10-12.

Tetralux

/*
        A simple example of a linked list implementation that does NOT allocate the nodes individually.
        Written by TetraluxOnPC, 2024-07-28.
*/

package linked_list_example

import "core:mem"
import "core:mem/virtual"       
import "core:fmt"

Tetralux

package util

import "base:runtime"
import "base:intrinsics"

import "core:mem"
import "core:mem/virtual"
import "core:os"
import "core:fmt"

Tetralux

const Ally = struct {
    data: ?*anyopaque,
    proc: *const fn(
        ally_data: ?*anyopaque, 
        mode: Mode, 
        count: usize, 
        alignment: usize, 
        old_memory: []u8,
    ) error{OutOfMemory}![]u8,

Tetralux

// A simple illustration of a stream server that handles each client with a thread pool, and
// if any worker returns an error then it prints out the errorReturnTrace.
//
// Untested.
//
// Written by Tetralux, 2023-11-15.

const std = @import("std");

const Data = struct {

Tetralux

const std = @import("std");

const string = []const u8;
const Allocator = std.mem.Allocator;

/// Given an entire INI string, parses it into a map of key-value pairs.
/// The pairs are all freed by a call to `Parser.deinit`, and retrieved via `Parser.get`.
/// If you need them to live beyond that, use `some_other_allocator.dupe(u8, value)`.
pub const Parser = struct {
    data: std.StringArrayHashMap(string),

Tetralux

//
// A simple example program that runs a program with the given arguments by searching the PATH environment variable.
//
// Tetralux, 2023-10-13.
//

const std = @import("std");
const builtin = @import("builtin");

const string = []const u8;

Tetralux

import "core:mem"
import "core:runtime"

Counting_Allocator :: struct {
    total_used: uint,
    backing_ally: mem.Allocator,
}

counting_allocator :: proc(ca: ^Counting_Allocator) -> mem.Allocator {
    return {

Tetralux

//
// A simple example of a calculator programming language, that compiles to native code!
//
// Written by Tetralux <[email protected]>, 2023-03-09.
//
// Programs are a string that you pass as an argument in the form of a mathmetical expression.
// e.g: '10 + 4 - 1 + 7'.
// This program will generate some Zig code that computes the answer, and prints it to stdout.
// It then will invoke the Zig compiler as a subprocess to compile and run this program.
//

Tetralux

package process

import "core:c"
import "core:c/libc"
import "core:strings"

when ODIN_OS == .Windows {
    foreign import libc_obj "system:libucrt.lib"
    POPEN_NAME :: "_popen"
    PCLOSE_NAME :: "_pclose"