# [GOLEM](https://kdx.re/cgit/golem)

## Introduction

Programming language.
Designed for losers, by a loser.

Here's GOLEM's grandiose resume, please be nice: GOLEM is quite shy.

* no typing, everything is a shitty unsigned integer
* no complexity, made to be super simple to parse
* no ambiguity, there's only one shitty way to do each shitty thing
* no safety, every unsigned integer is also a pointer
* no abstraction, there ain't no stdlib

Here's some cute GOLEM code.

```golem
fn main(argc, argv) {
	var i;
	var ret;
	var ptr;
	var arr;

	i = 2;
	powed = 1;
	arr = alloc(argc);
	while i < argc {
		arr[i] = atoi(argv[i]);
		powed *= arr[i];
	}
	// bad heap management
	heap -= argc;

	// GOLEM has no * deference and uses $ for reference
	ptr = $i;
	ret += ptr[0];

	return ret;
}

fn alloc(size) {
	var ptr;

	ptr = heap;
	heap += size;
	return ptr;
}

fn atoi(str) {
	// <--- good code here
	return 2038;
}
```

GOLEM is pretty much dumber 
[C](https://en.wikipedia.org/wiki/C_programming_language),
think [B](https://en.wikipedia.org/wiki/B_programming_language) 2.0.69.

## Why?

GOLEM's goal is to be used on custom made virtual machines at a very low level
of abstraction.

GOLEM code is easy and pleasantly simple to write.
It's sheer simplicity makes it easily expandable.

I fucking wanted to make it.

## Project state

`[ ]` lexer
* `[x]` word
* `[x]` decimal litteral
* `[ ]` hexadecimal litteral
* `[ ]` binary litteral
* `[ ]` char litteral
* `[x]` string litteral
* `[x]` `var`
* `[x]` `const`
* `[x]` `fn`
* `[x]` `if`
* `[x]` `else`
* `[x]` `while`
* `[x]` `(`
* `[x]` `)`
* `[x]` `{`
* `[x]` `}`
* `[x]` `[`
* `[x]` `]`
* `[x]` `:`
* `[x]` `;`
* `[x]` `=`
* `[ ]` `+=`
* `[ ]` `-=`
* `[ ]` `*=`
* `[ ]` `/=`
* `[ ]` `%=`
* `[ ]` `&=`
* `[ ]` `|=`
* `[ ]` `^=`
* `[x]` `+`
* `[x]` `-`
* `[x]` `*`
* `[x]` `/`
* `[x]` `%`
* `[x]` `&`
* `[x]` `|`
* `[x]` `^`
* `[x]` `$`
* `[x]` `!`
* `[x]` `==`
* `[x]` `!=`
* `[x]` `<`
* `[x]` `>`
* `[x]` `<=`
* `[x]` `>=`
* `[x]` `||`
* `[x]` `&&`
* `[x]` `//`