brew tap Ziadstr/nashmic
brew install nashmic

yay -S nashmic-git

sudo dpkg -i nashmic_*.deb

curl -fsSL https://raw.githubusercontent.com/Ziadstr/nashmic/main/install.sh | bash

git clone https://github.com/Ziadstr/nashmic.git
cd nashmic
make
sudo make install

code --install-extension ziadstr.nashmic

yalla() {
    itba3("marhaba ya 3alam!\n")
}

mansaf run marhaba.nsh

mansaf build marhaba.nsh
./marhaba

yalla() {
    khalli name: nass = "Ziad"
    khalli age: adad64 = 23

    itba3("marhaba ya {name}!\n")
    itba3("age: {age}, next year: {age + 1}\n")
}

yalla() {
    lakol i fi 0..10 {
        itba3("{i}\n")
    }
}

khalli name: nass = "Ziad"
khalli age: adad64 = 23
khalli pi: fasle64 = 3.14159
khalli alive: mante2 = ah

thabet MAX_USERS: adad64 = 1000
thabet PI: fasle64 = 3.14159265
thabet GREETING: nass = "marhaba"

dalle add(a: adad64, b: adad64) -> adad64 {
    rajje3 a + b
}

dalle greet(name: nass) {
    itba3("marhaba ya {name}!\n")
}

yalla() {
    itba3("the program starts here\n")
}

dalle fibonacci(n: adad64) -> adad64 {
    iza n <= 1 {
        rajje3 n
    }
    rajje3 fibonacci(n - 1) + fibonacci(n - 2)
}

yalla() {
    lakol i fi 0..15 {
        itba3("fib({i}) = {fibonacci(i)}\n")
    }
}

iza x > 0 {
    itba3("positive\n")
} wala_iza x == 0 {
    itba3("zero\n")
} wala {
    itba3("negative\n")
}

lakol i fi 0..10 {
    itba3("{i}\n")
}

khalli count: adad64 = 0
tool_ma count < 10 {
    itba3("{count}\n")
    count = count + 1
}

liff {
    iza i >= 10 {
        khalas
    }
    i = i + 1
}

dalle fizzbuzz(n: adad64) {
    lakol i fi 1..n {
        iza i % 15 == 0 {
            itba3("FizzBuzz\n")
        } wala_iza i % 3 == 0 {
            itba3("Fizz\n")
        } wala_iza i % 5 == 0 {
            itba3("Buzz\n")
        } wala {
            itba3("{i}\n")
        }
    }
}

yalla() {
    fizzbuzz(30)
}

khalli message: nass = "marhaba ya 3alam"

khalli name: nass = "Ziad"
khalli age: adad64 = 23

itba3("marhaba ya {name}!\n")
itba3("age: {age}, next year: {age + 1}\n")

haikal Point {
    x: fasle64,
    y: fasle64,
}

yalla() {
    khalli p: Point = Point{ x: 3.0, y: 4.0 }
    itba3("Point: ({p.x}, {p.y})\n")
}

dalle print_point(p: Point) {
    itba3("({p.x}, {p.y})\n")
}

haikal Line {
    start: Point,
    end: Point,
}

khalli a3dad: saff<adad64> = [10, 20, 30, 40, 50]
khalli drajat: saff<fasle64> = [95.5, 87.3, 92.1]
khalli farigh: saff<adad64> = []

itba3("a3dad[0] = %lld\n", a3dad[0])
itba3("toul: %lld\n", a3dad.toul())

khalli a3dad: saff<adad64> = [10, 20, 30]
a3dad.zeed(40)
a3dad.zeed(50)

lakol n fi a3dad {
    itba3("%lld ", n)
}
itba3("\n")

dalle print_array(nums: saff<adad64>) {
    itba3("[ ")
    lakol n fi nums {
        itba3("%lld ", n)
    }
    itba3("]\n")
}

// saff<adad64> compiles to:
struct nsh_array_int64_t {
    int64_t *data;
    int64_t len;
    int64_t cap;
};

// Array literal [10, 20, 30] becomes:
struct nsh_array_int64_t a3dad;
a3dad.cap = 3;
a3dad.len = 3;
a3dad.data = malloc(sizeof(int64_t) * 3);
a3dad.data[0] = 10;
a3dad.data[1] = 20;
a3dad.data[2] = 30;

// .zeed(40) checks capacity, doubles if full:
if (a3dad.len >= a3dad.cap) {
    a3dad.cap *= 2;
    a3dad.data = realloc(a3dad.data, sizeof(int64_t) * a3dad.cap);
}
a3dad.data[a3dad.len++] = 40;

// lakol n fi a3dad becomes:
for (int64_t _i = 0; _i < a3dad.len; _i++) {
    int64_t n = a3dad.data[_i];
    // body
}

ta3dad Shape {
    Da2ira(fasle64),
    Mustateel(fasle64),
    Noqta,
}

khalli circle: Shape = Da2ira(5.0)
khalli point: Shape = Noqta
khalli color: Color = Ahmar

hasab s {
    hale Da2ira(radius) => {
        itba3("Circle: radius %g\n", radius)
    }
    hale Mustateel(width) => {
        itba3("Rect: width %g\n", width)
    }
    hale Noqta => {
        itba3("Point\n")
    }
}

// ta3dad Shape { Da2ira(fasle64), Mustateel(fasle64), Noqta }
// compiles to:

#define Shape_Da2ira    0
#define Shape_Mustateel 1
#define Shape_Noqta     2

struct Shape {
    int _tag;
    union {
        double Da2ira;
        double Mustateel;
        // Noqta carries no data
    } _v;
};

// khalli circle: Shape = Da2ira(5.0) becomes:
struct Shape circle;
circle._tag = Shape_Da2ira;
circle._v.Da2ira = 5.0;

// hasab s { hale Da2ira(radius) => ... } becomes:
switch (s._tag) {
    case Shape_Da2ira: {
        double radius = s._v.Da2ira;
        // arm body
        break;
    }
    case Shape_Mustateel: {
        double width = s._v.Mustateel;
        // arm body
        break;
    }
    case Shape_Noqta: {
        // arm body
        break;
    }
}

dalle find_even(n: adad64) -> yimkin<adad64> {
    iza n % 2 == 0 {
        rajje3 fi(n)
    }
    rajje3 mafi
}

iza fi result = find_even(10) {
    itba3("found even: %lld\n", result)
} wala {
    itba3("no even number\n")
}

hasab find_even(7) {
    hale fi(val) => {
        itba3("%lld\n", val)
    }
    hale mafi => {
        itba3("nothing\n")
    }
}

// yimkin<adad64> compiles to:
struct nsh_option_int64_t {
    int _has_value;
    int64_t _value;
};

// rajje3 fi(n) becomes:
struct nsh_option_int64_t _ret;
_ret._has_value = 1;
_ret._value = n;
return _ret;

// rajje3 mafi becomes:
struct nsh_option_int64_t _ret;
_ret._has_value = 0;
return _ret;

// iza fi result = find_even(10) { ... } becomes:
struct nsh_option_int64_t _tmp = find_even(10);
if (_tmp._has_value) {
    int64_t result = _tmp._value;
    // body
} else {
    // wala body
}

dalle divide(a: fasle64, b: fasle64) -> natije<fasle64> {
    iza b == 0.0 {
        rajje3 ghalat("ya zalameh, division by zero!")
    }
    rajje3 tamam(a / b)
}

dalle safe_math(x: fasle64) -> natije<fasle64> {
    khalli result: fasle64 = divide(x, 2.0) wala?
    rajje3 tamam(result + 1.0)
}

hasab divide(10.0, 0.0) {
    hale tamam(val) => {
        itba3("%g\n", val)
    }
    hale ghalat(msg) => {
        itba3("Error: %s\n", msg)
    }
}

// natije<fasle64> compiles to:
struct nsh_result_double {
    int _is_ok;
    union {
        double _ok;
        const char* _err;
    } _v;
};

// rajje3 tamam(a / b) becomes:
struct nsh_result_double _ret;
_ret._is_ok = 1;
_ret._v._ok = a / b;
return _ret;

// rajje3 ghalat("division by zero!") becomes:
struct nsh_result_double _ret;
_ret._is_ok = 0;
_ret._v._err = "division by zero!";
return _ret;

// khalli result: fasle64 = divide(x, 2.0) wala?
// uses a GNU C statement expression:
double result = ({
    struct nsh_result_double _tmp = divide(x, 2.0);
    if (!_tmp._is_ok) {
        struct nsh_result_double _prop;
        _prop._is_ok = 0;
        _prop._v._err = _tmp._v._err;
        return _prop;
    }
    _tmp._v._ok;
});

dalle greet() {
    itba3("start\n")
    ba3dain {
        itba3("cleanup 1\n")
    }
    ba3dain {
        itba3("cleanup 2\n")
    }
    itba3("middle\n")
    rajje3
}
// Output: start, middle, cleanup 2, cleanup 1

dalle compute(x: adad64) -> adad64 {
    ba3dain {
        itba3("  compute done\n")
    }
    rajje3 x * 2
}

// dalle greet() {
//     itba3("start\n")
//     ba3dain { itba3("cleanup 1\n") }
//     ba3dain { itba3("cleanup 2\n") }
//     itba3("middle\n")
//     rajje3
// }
// compiles to:

void greet(void) {
    printf("start\n");
    // ba3dain blocks are registered, not executed here
    printf("middle\n");
    goto _defer_2;  // return jumps to the chain

_defer_2:
    printf("cleanup 2\n");  // LIFO: last defer runs first
_defer_1:
    printf("cleanup 1\n");  // then the earlier one
    return;                 // actual return happens here
}

ta3dad Shape {
    Da2ira(fasle64),
    Mustateel(fasle64),
    Noqta,
}

dalle describe_shape(s: Shape) {
    hasab s {
        hale Da2ira(radius) => {
            itba3("Circle: radius %g\n", radius)
        }
        hale Mustateel(width) => {
            itba3("Rect: width %g\n", width)
        }
        hale Noqta => {
            itba3("Point\n")
        }
    }
}

hasab value {
    hale 1 => itba3("one\n")
    hale 2 => itba3("two\n")
    3adi => itba3("something else\n")
}

hasab parse_number(input) {
    hale tamam(n) => itba3("got: {n}\n")
    hale ghalat(msg) => itba3("error: {msg}\n")
}

// hasab s { hale Da2ira(radius) => ... } compiles to:
switch (s._tag) {
    case Shape_Da2ira: {
        double radius = s._v.Da2ira;  // destructured, scoped to this block
        printf("Circle: radius %g\n", radius);
        break;
    }
    case Shape_Noqta: {
        printf("Point\n");
        break;
    }
}

// hasab divide(10.0, 0.0) { hale tamam(val) => ... } compiles to:
struct nsh_result_double _match = divide(10.0, 0.0);
if (_match._is_ok) {
    double val = _match._v._ok;
    printf("%g\n", val);
} else {
    const char* msg = _match._v._err;
    printf("Error: %s\n", msg);
}

// hasab find_even(7) { hale fi(val) => ... } compiles to:
struct nsh_option_int64_t _match = find_even(7);
if (_match._has_value) {
    int64_t val = _match._value;
    // fi arm
} else {
    // mafi arm
}

haikal Point {
    x: fasle64,
    y: fasle64,
}

tabbe2 Point {
    dalle magnitude(had) -> fasle64 {
        rajje3 sqrt(had.x * had.x + had.y * had.y)
    }

    dalle distance(had, other: Point) -> fasle64 {
        khalli dx: fasle64 = had.x - other.x
        khalli dy: fasle64 = had.y - other.y
        rajje3 sqrt(dx * dx + dy * dy)
    }
}

khalli p: Point = Point{ x: 3.0, y: 4.0 }
khalli m: fasle64 = p.magnitude()

// tabbe2 Point {
//     dalle magnitude(had) -> fasle64 { ... }
//     dalle distance(had, other: Point) -> fasle64 { ... }
// }
// compiles to:

double Point_magnitude(struct Point *had) {
    return sqrt(had->x * had->x + had->y * had->y);
}

double Point_distance(struct Point *had, struct Point other) {
    double dx = had->x - other.x;
    double dy = had->y - other.y;
    return sqrt(dx * dx + dy * dy);
}

// p.magnitude() becomes:
Point_magnitude(&p);

// p.distance(q) becomes:
Point_distance(&p, q);

itba3("marhaba ya {name}!\n")

khalli input: nass = i2ra()

yalla() {
    nashmi()    // about NashmiC
    drobi()     // random proverb
    mansaf()    // the recipe
    sahteen()   // bon appetit
}

yalla() {
    itba3("jadhr(16) = %f\n", jadhr(16.0))
    itba3("qowa(2, 10) = %f\n", qowa(2.0, 10.0))
    itba3("3shwa2i(1, 100) = %lld\n", 3shwa2i(1, 100))
}

yalla() {
    khalli name: nass = "nashmic"
    itba3("toul: %lld\n", toul(name))
    itba3("a3la: %s\n", a3la(name))
    itba3("karrer: %s\n", karrer(name, 3))
}

yalla() {
    uktub_malaf("test.txt", "marhaba ya dunya!\n")
    khalli content: nass = i2ra_kol("test.txt")
    itba3("content: %s", content)
    imsah_malaf("test.txt")
}

error[E0001]: expected expression
  --> src/main.nsh:12:18
     |
  12 |     khalli x = ???
     |                ^^^
     |
      = patience turns sour to sweet

done! zay il ful       (everything's perfect)
done! nashmi wallah    (noble work)
done! wallah ma 2assart (you didn't fall short)

.nsh source → Lexer → Parser → AST → Sema → C Codegen → cc → native binary