theMackabu

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdint.h>
#include <math.h>
#define PREFIX    0xFFF0000000000000ULL
#define DATA_MASK 0x00007FFFFFFFFFFFULL
enum Type { T_NUM, T_STR, T_BOOL, T_NIL };
static inline uint64_t mknum(double d)           { uint64_t v; memcpy(&v, &d, 8); return v; }

theMackabu

#include <stdio.h>

#define fmt(x) _Generic((x), \
  int:          "%d",        \
  long:         "%ld",       \
  float:        "%f",        \
  double:       "%lf",       \
  char:         "%c",        \
  char*:        "%s",        \
  const char*:  "%s",        \

theMackabu

it first generates the bytecode from the parsed ast, then runs them through a type feedback checker, which runs the bytecode a few times unoptimized, the type feedback is used to analyze data and control flow simultaneously, like if we can skip the fallbacks to prototype chain walking. then it strips away dead code. if there is less than a detected threshold, it skips to emitting the actual operations and runs. If the threshold is hit, the non-optimizing "baseline" compiler is used that quickly turns bytecode into simple machine code to bridge the gap between interpretation and full optimization, this does not use type feedback. at the third stage, > 1000 iterations, we hit a graph that converts code into a graph representation that ignores the original order of lines to find the most efficient execution path, using the data from stage 2, it "bets" that the data types won't change, this removes expensive safety checks to create highly efficient machine code. if those "bets" fail, for example, if you sudden

theMackabu

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

typedef enum {
    OP_CONST,      // push constant
    OP_LOAD,       // load local variable
    OP_ADD,        // add top two values
    OP_CALL,       // call function

theMackabu

// divisions of grid
const float repeats = 30.;

// number of layers
const float layers = 21.;

// star colours
const vec3 blue = vec3(51.,64.,195.)/255.;
const vec3 cyan = vec3(117.,250.,254.)/255.;
const vec3 white = vec3(255.,255.,255.)/255.;

theMackabu

float ease(float x) {
    return pow(1.0 - x, 10.0);
}

float sdBox(in vec2 p, in vec2 xy, in vec2 b)
{
    vec2 d = abs(p - xy) - b;
    return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
}

theMackabu

# goto directory by name
setopt autocd

# zsh plugins
source $HOME/.config/plugins/completion/completion.zsh
source $HOME/.config/plugins/fsh/fast-syntax-highlighting.plugin.zsh
source $HOME/.config/plugins/autosuggestions/zsh-autosuggestions.plugin.zsh

# enable built in scripts
source $HOME/.local/scripts/entry.sh

theMackabu

#!/bin/bash

# usage: ./create_card.sh <background_image> "<song_name>" "<artist>" "<year>" "<duration>"

# create base image with background
magick "$1" -gravity center -extent 1186x640 base.png

# add dark overlay
magick base.png \( +clone -fill black -colorize 89% \) -composite overlay.png

theMackabu

struct GridLayout {
    raw: String,
    lines: Vec<String>,
    line_starts: Vec<usize>,
}

impl GridLayout {
    fn new(raw: String, max_width: usize) -> Self {
        let mut lines = Vec::new();
        let mut line_starts = Vec::new();

theMackabu

#!/bin/bash

chk_root () {
  if [ ! $( id -u ) -eq 0 ]; then
    echo Must be run as root
    exit
  fi
}

chk_root