Rename and cleanup

32 files changed, 1486 insertions, 0 deletions

diff --git a/sem3/osc/miniproject/cnasm/Makefile b/sem3/osc/miniproject/cnasm/Makefile
new file mode 100644
index 0000000..9ace547
--- /dev/null
+++ b/sem3/osc/miniproject/cnasm/Makefile
@@ -0,0 +1,30 @@
+
+LEX=flex
+YACC=bison
+LIBS=-ly -lfl -lm
+CC=gcc
+
+PROG=regn
+TRASH=lex.yy.c $(PROG).tab.c $(PROG) $(PROG).tab.h $(PROG).output
+
+$(PROG): $(PROG).tab.o lex.yy.o ast.c codegen.c
+		$(CC) -ggdb -o $@ $^ $(LIBS) 
+
+$(PROG).tab.c $(PROG).tab.h: $(PROG).y
+		$(YACC) -d -v $(PROG).y
+
+lex.yy.c: $(PROG).l
+		$(LEX) $(PROG).l
+
+%.o: %.c
+	$(CC) -ggdb -c -o $@ $^
+
+PHONY: clean run
+
+run: $(PROG)
+	./$(PROG)
+
+clean:
+	rm -f *.o
+	rm -f $(TRASH)
+
diff --git a/sem3/osc/miniproject/cnasm/ast.c b/sem3/osc/miniproject/cnasm/ast.c
new file mode 100644
index 0000000..035b75d
--- /dev/null
+++ b/sem3/osc/miniproject/cnasm/ast.c
@@ -0,0 +1,98 @@
+#include "ast.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+static ast_node_t *create_empty_node() {
+	ast_node_t *n = malloc(sizeof(ast_node_t));
+	memset(n, 0, sizeof(ast_node_t));
+}
+
+ast_node_t *insert_ctrl(enum ntype t, cond_t *c, ast_node_t *iftrue, ast_node_t *iffalse) {
+	ast_node_t *n = create_empty_node();
+
+	n->t = t;
+	n->flowctrl.condition = c;
+	n->flowctrl.iftrue = iftrue;
+	n->flowctrl.iffalse = iffalse;
+
+	return n;
+}
+
+ast_node_t *insert_for(char *pre, cond_t *c, char *inc, ast_node_t *stuff) {
+	ast_node_t *n = create_empty_node();
+
+	n->t = TFOR;
+	n->forloop.condition = c;
+	n->forloop.pre = pre;
+	n->forloop.inc = inc;
+	n->forloop.stuff = stuff;
+
+	return n;
+}
+
+ast_node_t *insert_stm(ast_node_t *stm, ast_node_t *stm_list) {
+	ast_node_t *n = create_empty_node();
+
+	n->t = TSTM_LIST;
+	n->list.children[0] = stm_list;
+	n->list.children[1] = stm;
+
+	return n;
+}
+ast_node_t *insert_ident(char *ident) {
+	ast_node_t *n = create_empty_node();
+
+	n->t = TIDENT;
+	n->ident = ident;
+
+	return n;
+}
+
+cond_t *insert_cond(uint8_t cmp, char *a, char *b) {
+	cond_t *c = malloc( sizeof(cond_t));
+
+	c->cmp = cmp;
+	c->a = a;
+	c->b = b;
+}
+
+void node_print(ast_node_t *node) {
+	if( !node ){
+		printf("Nil");
+		return;
+	}
+	switch(node->t) {
+		case TSTM_LIST: 
+			printf("Stm_list(");
+			node_print(node->list.children[0]);
+			printf(",");
+			node_print(node->list.children[1]);
+			printf(")");
+			break;
+		case TIF:
+			printf("If");
+			printf("(%s %c %s) {", node->flowctrl.condition->a,
+					node->flowctrl.condition->cmp,
+					node->flowctrl.condition->b);
+			node_print(node->flowctrl.iftrue);
+			printf("}{");
+			node_print(node->flowctrl.iffalse);
+			printf("}");
+			break;
+		case TIDENT:
+			printf("%s", node->ident);
+			break;
+		case TWHILE:
+			printf("while");
+			printf("(%s %c %s) {", node->flowctrl.condition->a,
+					node->flowctrl.condition->cmp,
+					node->flowctrl.condition->b);
+			node_print(node->flowctrl.iftrue);
+			printf("}");
+			break;
+		default:
+			printf("invalid");
+	}
+}
diff --git a/sem3/osc/miniproject/cnasm/ast.h b/sem3/osc/miniproject/cnasm/ast.h
new file mode 100644
index 0000000..61a8f4f
--- /dev/null
+++ b/sem3/osc/miniproject/cnasm/ast.h
@@ -0,0 +1,53 @@
+#ifndef AST_HEADER
+#define AST_HEADER
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#define CEQ 0x10
+#define CNEQ CEQ ^ 0x80
+#define CGT 0x20
+#define CLT 0x30
+#define CLEQ CGT ^ 0x80
+#define CGEQ CLT ^ 0x80
+
+enum ntype { TSTM_LIST, TIF, TFOR, TIDENT, TWHILE};
+
+typedef struct cond {
+	uint8_t cmp;
+	char *a;
+	char *b;
+} cond_t;
+
+typedef struct ast_node {
+	enum ntype t;
+	// Dependent on type
+	union {
+		struct {
+			cond_t *condition;
+			struct ast_node *iftrue;
+			struct ast_node *iffalse;
+		} flowctrl;
+		struct {
+			cond_t *condition;
+			char *pre;
+			char *inc;
+			struct ast_node *stuff;
+		} forloop;
+		char *ident;
+		struct {
+			struct ast_node *children[2];
+		} list;
+	};
+} ast_node_t;
+
+ast_node_t *insert_ctrl(enum ntype t, cond_t *c, ast_node_t *iftrue, ast_node_t *iffalse);
+ast_node_t *insert_stm(ast_node_t *stm, ast_node_t *stm_list);
+ast_node_t *insert_ident(char *ident);
+ast_node_t *insert_for(char *pre, cond_t *c, char *inc, ast_node_t *stuff);
+
+cond_t *insert_cond(uint8_t cmp, char *a, char *b);
+
+void node_print(ast_node_t *node);
+
+#endif 
diff --git a/sem3/osc/miniproject/cnasm/codegen.c b/sem3/osc/miniproject/cnasm/codegen.c
new file mode 100644
index 0000000..c995df9
--- /dev/null
+++ b/sem3/osc/miniproject/cnasm/codegen.c
@@ -0,0 +1,132 @@
+#include "codegen.h"
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include "ast.h"
+
+static void gencondjmp(FILE *f, cond_t *c, bool neg) {
+	uint8_t cmp = neg ? c->cmp^0x80 : c->cmp;
+	fprintf(f, "cmp %s %s\n", c->a, c->b);
+	switch(cmp) {
+		case CEQ:
+			fprintf(f, "je ");
+			break;
+		case CNEQ:
+			fprintf(f, "jne ");
+			break;
+		case CGT:
+			fprintf(f, "jg ");
+			break;
+		case CLT:
+			fprintf(f, "jl ");
+			break;
+		case CLEQ:
+			fprintf(f, "jle ");
+			break;
+		case CGEQ:
+			fprintf(f, "jge ");
+			break;
+		default:
+			fprintf(stderr, "Invalid cmp type %x", cmp);
+			fprintf(f, "jmp ");
+	}
+}
+
+static void genif(FILE *f, struct genctx *ctx, ast_node_t *n) {
+	bool doElse = n->flowctrl.iffalse;
+	// Create conditional jump
+	gencondjmp(f, n->flowctrl.condition, true);
+	if( doElse ) {
+		fprintf(f, "else_%d\n", ctx->nested);
+	} else {
+		fprintf(f, "end_%d\n", ctx->nested);
+	}
+
+	struct genctx octx = { ctx->nested+1 };
+	// Paste code
+	gentree(f, &octx, n->flowctrl.iftrue);
+	
+	// Do else
+	if( doElse ) {
+		fprintf(f, "jmp end_%d\n", ctx->nested);
+		fprintf(f, "else_%d:\n", ctx->nested);
+		gentree(f, &octx, n->flowctrl.iffalse);
+	}
+
+	// End block
+	fprintf(f, "end_%d:\n", ctx->nested);
+}
+
+static void genwhile(FILE *f, struct genctx *ctx, ast_node_t *n) {
+	// Create loop label
+	fprintf(f, "loop_%d:\n", ctx->nested);
+
+	// Create conditional jump
+	gencondjmp(f, n->flowctrl.condition, true);
+	fprintf(f, "end_%d\n", ctx->nested);
+
+	struct genctx octx = { ctx->nested+1 };
+	// Paste code
+	gentree(f, &octx, n->flowctrl.iftrue);
+
+	// Jump to start
+	fprintf(f, "jmp loop_%d\n", ctx->nested);
+	
+	// End block
+	fprintf(f, "end_%d:\n", ctx->nested);
+}
+
+static void genfor(FILE *f, struct genctx *ctx, ast_node_t *n) {
+	// Do pre stuff
+	fprintf(f, "%s\n", n->forloop.pre);
+
+	// Create loop label
+	fprintf(f, "loop_%d:\n", ctx->nested);
+
+	// Create conditional jump
+	gencondjmp(f, n->flowctrl.condition, true);
+	fprintf(f, "end_%d\n", ctx->nested);
+
+	struct genctx octx = { ctx->nested+1 };
+	// Paste code
+	gentree(f, &octx, n->forloop.stuff);
+
+	// Do inc stuff
+	fprintf(f, "%s\n", n->forloop.inc);
+	// Jump to start
+	fprintf(f, "jmp loop_%d\n", ctx->nested);
+	
+	// End block
+	fprintf(f, "end_%d:\n", ctx->nested);
+}
+
+void gentree(FILE *f, struct genctx *ctx, ast_node_t *n) {
+	if( !n ) {
+		return;
+	}
+	if( ctx == NULL ) {
+		ctx = malloc(sizeof(struct genctx));
+		ctx->nested = 0;
+	}
+	switch(n->t) {
+		case TSTM_LIST: 
+			gentree(f, ctx, n->list.children[0]);
+			gentree(f, ctx, n->list.children[1]);
+			break;
+		case TIF:
+			genif(f, ctx, n);
+			break;
+		case TIDENT:
+			fprintf(f, "%s\n", n->ident);
+			break;
+		case TFOR:
+			genfor(f, ctx, n);
+			break;
+		case TWHILE:
+			genwhile(f, ctx, n);
+			break;
+		default:
+			return;
+	}
+}
diff --git a/sem3/osc/miniproject/cnasm/codegen.h b/sem3/osc/miniproject/cnasm/codegen.h
new file mode 100644
index 0000000..24ad6c4
--- /dev/null
+++ b/sem3/osc/miniproject/cnasm/codegen.h
@@ -0,0 +1,14 @@
+
+#ifndef CODEGEN_HEADER
+#define CODEGEN_HEADER
+
+#include <stdio.h>
+#include "ast.h"
+
+struct genctx {
+	unsigned int nested;
+};
+
+void gentree(FILE *f, struct genctx *ctx, ast_node_t *n);
+
+#endif 
diff --git a/sem3/osc/miniproject/cnasm/regn.l b/sem3/osc/miniproject/cnasm/regn.l
new file mode 100644
index 0000000..00876d6
--- /dev/null
+++ b/sem3/osc/miniproject/cnasm/regn.l
@@ -0,0 +1,39 @@
+%{
+#include <math.h>
+#include <string.h>
+#include "regn.tab.h"
+#include "ast.h"
+%}
+
+id		[a-zA-Z0-9_;]([^\n=><(){}])*
+if		if[ \t]*
+else	else[ \t]*
+for		for[ \t]*
+while	while[ \t]*
+
+%%
+
+{if} {return IFF;};
+{else} {return EELSE;};
+{for} {return FFOR;};
+{while} {return WHILE;};
+"(" {return LP;};
+")" {return RP;};
+"{" {return LCP;};
+"}" {return RCP;};
+"<" {yylval.cmp = CLT; return CMP;};
+">" {yylval.cmp = CGT; return CMP;};
+"=" {yylval.cmp = CEQ; return CMP;};
+"!=" {yylval.cmp = CNEQ; return CMP;};
+{id} {yylval.string = strdup(yytext);return ID;};
+[1-9][0-9]* {yylval.string = yytext;return NO;};
+
+
+
+[ \t\n] ;
+
+.           {return yytext[0];} 
+
+%%
+
+// TODO match normal assembler
diff --git a/sem3/osc/miniproject/cnasm/regn.y b/sem3/osc/miniproject/cnasm/regn.y
new file mode 100644
index 0000000..b72d440
--- /dev/null
+++ b/sem3/osc/miniproject/cnasm/regn.y
@@ -0,0 +1,81 @@
+%{
+#include "ast.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include "codegen.h"
+
+#define CLEAN_BOTH 2
+#define CLEAN_DST 1
+
+char *strconcat(char *dst, char *src, unsigned int clean) {
+	size_t dstlen = strlen(dst) + 1;
+	size_t srclen = strlen(src) + 1;
+
+	// Create new duplicate
+	char *new = malloc(( dstlen + srclen ) * sizeof(char));
+
+	// Copy stuff
+	memcpy(new, dst, dstlen);
+	strcat(new, src);
+
+	// Free old one
+	if( clean-- ) {
+		free(dst);
+
+		if( clean ) {
+			free(src);
+		}
+	}
+	return new;
+}
+
+// Trace node
+
+%}
+
+%token IFF EELSE FFOR RP RCP RSP LP LCP LSP ID COLON CMP NO WHILE
+
+%union {
+	char				*string;
+	struct ast_node		*node;
+	struct cond			*condition;
+	uint8_t				cmp;
+}
+
+%type <string>	ID 
+%type <node>	statement stm_list 
+%type <cmp>		CMP
+%type <condition> condition
+
+%%
+
+program: stm_list 			{gentree(stdout, NULL, $1);printf("\n");};
+
+stm_list: statement				{ $$ = $1; }
+		| stm_list statement 	{ $$ = insert_stm($2, $1); };
+
+condition: ID CMP ID		{ $$ = insert_cond($2, $1, $3); }
+		 | ID				{ $$ = insert_cond(CNEQ, $1, "0");};
+
+statement: ID																{$$ = insert_ident($1);}
+		 | IFF LP condition RP LCP stm_list RCP								{$$ = insert_ctrl(TIF, $3, $6, NULL);}
+		 | IFF LP condition RP LCP stm_list RCP	EELSE LCP stm_list RCP		{$$ = insert_ctrl(TIF, $3, $6, $10);}
+		 | WHILE LP condition RP LCP stm_list RCP							{$$ = insert_ctrl(TWHILE, $3, $6, NULL);}
+		 | FFOR LP ID LP condition LP ID RP LCP stm_list RCP				{$$ = insert_for($3, $5, $7, $10);};
+
+%%
+
+
+int main() {
+
+	/*for(;;) {
+		int t = yylex();
+		printf("yylex: %d\n", t);
+	} */
+
+	yyparse(); 
+}
+
diff --git a/sem3/osc/miniproject/cnasm/test.asm b/sem3/osc/miniproject/cnasm/test.asm
new file mode 100644
index 0000000..77a3572
--- /dev/null
+++ b/sem3/osc/miniproject/cnasm/test.asm
@@ -0,0 +1,39 @@
+global _start
+
+section .data
+        align 2
+        ; String, which is just a collection of bytes, 0xA is newline
+        str:     db 'Hello, world!',0xA
+        strLen:  equ $-str
+
+section .bss
+
+section .text
+        _start:
+
+        mov     edx, strLen     ; Arg three: the length of the string
+        mov     ecx, str        ; Arg two: the address of the string
+        mov     ebx, 1          ; Arg one: file descriptor, in this case stdout
+        mov     eax, 4          ; Syscall number, in this case the 
+        int     0x80            ; Interrupt 0x80        
+
+		if ( hej = 10 ) {
+			mov     ebx, 0          ; Arg one: the status
+			mov     eax, 1          ; Syscall number:
+			if(cool) {
+				int     0x80
+			}
+		} else {
+			while( lol ) {
+				mov hej, 0
+			}
+		}
+		while( lol ) {
+			mov hej, 0
+		}
+
+		hej
+
+		for(mov a, 0( a < 100( a++ ) {
+			test
+		}
diff --git a/sem3/osc/mm1/.gitignore b/sem3/osc/mm1/.gitignore
new file mode 100644
index 0000000..b18a498
--- /dev/null
+++ b/sem3/osc/mm1/.gitignore
@@ -0,0 +1,10 @@
+jmod.ko
+.jmod.ko.cmd
+jmod.mod.c
+jmod.mod.o
+.jmod.mod.o.cmd
+jmod.o
+.jmod.o.cmd
+modules.order
+Module.symvers
+.tmp_versions
diff --git a/sem3/osc/mm1/mm1/Makefile b/sem3/osc/mm1/mm1/Makefile
new file mode 100644
index 0000000..13c8e62
--- /dev/null
+++ b/sem3/osc/mm1/mm1/Makefile
@@ -0,0 +1,7 @@
+obj-m += jmod.o
+
+all:
+	make -C /lib/modules/$(shell uname -r)/build M=$(shell pwd) modules
+clean:
+	make -C /lib/modules/$(shell uname -r)/build M=$(shell pwd) clean
+
diff --git a/sem3/osc/mm1/mm1/Readme.md b/sem3/osc/mm1/mm1/Readme.md
new file mode 100644
index 0000000..fcc6cb3
--- /dev/null
+++ b/sem3/osc/mm1/mm1/Readme.md
@@ -0,0 +1,34 @@
+# Opgaver til operativ systemer
+
+Ligenu er det ikke delt op i mapper. 
+
+## Kør mini kernel modul
+
+Compile med make.
+Husk at peg makefile på din kernel modul mappe.
+Denne er testet på ubuntu server 19.04.
+
+```
+make
+```
+
+Nu burde der være kommet et jmod.ko som kan loades med.
+
+```
+sudo insmod jmod.ko
+```
+
+Hvis du får permission denied kan du få flere information ved at checke `dmesg` loggen.
+
+Nu kan du hente major number ind fra dmesg. Led efter `COOL_MODULE:`.
+Dette nummer bruger du til at assign den en node
+
+```
+sudo mknod /dev/cooldev c MAJOR 0
+```
+
+Dette vil map kernel-modul/driver til cooldev i /dev/ mappen.
+Husk at skriv til MAJOR nummer fra `dmesg` i stedet for MAJOR.
+
+Hvis man læser man pagen kan man se at det bliver lavet som en character unbuffered file. 
+MINOR nummeret er 0 da vores driver alligevel ikke bruger det til noget.
diff --git a/sem3/osc/mm1/mm1/jmod.c b/sem3/osc/mm1/mm1/jmod.c
new file mode 100644
index 0000000..a07077c
--- /dev/null
+++ b/sem3/osc/mm1/mm1/jmod.c
@@ -0,0 +1,70 @@
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/fs.h>
+#include <asm/uaccess.h>
+
+static int major_num;
+static int busy;
+
+
+static int cool_open(struct inode *inode, struct file *file) {
+	/* Check if we are already serving someone */
+	if (busy) {
+		return -EBUSY;
+	}
+
+	busy = 1;
+	return 0;
+}
+
+static int cool_release (struct inode *inode, struct file *file) {
+	busy = 0;
+
+	return 0;
+}
+
+static ssize_t cool_read (struct file *filp, char *buffer, size_t len, loff_t *offset) {
+
+	char str[12] = "hej med dig";
+	int i;
+
+	for (i = 0; i < len; i++) {
+		put_user(str[i % 12], buffer++);
+	}
+
+	return i;
+}
+
+static struct file_operations file_ops = {
+	.owner = THIS_MODULE,
+	.read = cool_read,
+	.open = cool_open,
+	.release = cool_release
+};
+
+static int __init jmod_init(void) 
+{
+	printk(KERN_INFO "COOL_MODULE: Registering cooldev\n");
+	
+	major_num = register_chrdev(0, "cooldev", &file_ops);
+	if (major_num < 0) {
+		printk(KERN_ERR "COOL_MODULE: Could not register major\n");
+		return 1;
+	}
+
+	printk(KERN_INFO "COOL_MODULE: Got major %d\n", major_num);
+
+	return 0;
+}
+
+
+static void __exit jmod_exit(void) 
+{
+	printk(KERN_INFO "COOL_MODULE: Nou moe\n");
+	unregister_chrdev(major_num, "cooldev");
+}
+
+module_init( jmod_init );
+module_exit( jmod_exit );
+
diff --git a/sem3/osc/mm1/mm2/tprog.c b/sem3/osc/mm1/mm2/tprog.c
new file mode 100644
index 0000000..377555f
--- /dev/null
+++ b/sem3/osc/mm1/mm2/tprog.c
@@ -0,0 +1,71 @@
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+
+#define STARTSEC 10
+#define ENDUSEC 500000
+#define SPEED 0.8
+
+struct itimerval timer;
+
+void timer_handler(int signum) {
+    /* Handy structure reference */
+    struct timeval *tv = &timer.it_value;
+    printf("Hey we hit the alarm\n\a");
+
+    /* Calculate new alarm */
+    tv->tv_sec *= SPEED;
+    if (tv->tv_sec == 0) {
+	/* If tv_usec is 0 set i to 1 sec otherwise half it */
+	if (tv->tv_usec == 0) {
+	    tv->tv_usec = 999999;
+	} else if (tv->tv_usec > ENDUSEC) {
+	    tv->tv_usec *= SPEED;
+	    if (tv->tv_usec < ENDUSEC) {
+		tv->tv_usec = ENDUSEC;
+	    }
+	} else {
+	    /* Return letting the timer be set to ENDUSEC */
+	    return;
+	}
+    }
+
+    printf("Set to %d and %d\n", timer.it_value.tv_sec, timer.it_value.tv_usec);
+    /* Set alarm */
+    int err = setitimer(ITIMER_REAL, &timer, NULL);
+    if (err) {
+	printf("Hey we got an error guys\n");
+	exit(1);
+    }
+}
+
+int main() {
+    /* Setup handler for timer */
+    struct sigaction sa;
+    memset(&sa, 0, sizeof(sa)); /* Remeber to set all fields to zero */
+
+    sa.sa_handler = &timer_handler;
+    sigaction(SIGALRM, &sa, NULL);
+
+    /* Setup timer values */
+    timer.it_value.tv_sec = STARTSEC;
+    timer.it_value.tv_usec = 0;
+
+    timer.it_interval.tv_sec = 0;
+    timer.it_interval.tv_usec = ENDUSEC;
+
+    /* Start the timer */
+    setitimer(ITIMER_REAL, &timer, NULL);
+
+    /* Select signals */
+    sigset_t sigset;
+    sigemptyset(&sigset);
+    sigaddset(&sigset, SIGTERM);
+
+    /* Wait for termination */
+    sigwait(&sigset, NULL);
+
+    return 0;
+}
diff --git a/sem3/osc/mm10/Makefile b/sem3/osc/mm10/Makefile
new file mode 100644
index 0000000..99bd635
--- /dev/null
+++ b/sem3/osc/mm10/Makefile
@@ -0,0 +1,25 @@
+opgaver=opg1 opg3 opg4
+
+LEX=flex
+CC=gcc
+LINKFLAG=-lfl
+DEFAULT_TARGET=all
+
+%: %.yy.c
+	$(CC) -o $@ $^ $(LINKFLAG)
+
+%.o: %.c
+	$(CC) -c -o $@ $^
+
+%.yy.c: %.l
+	$(LEX) -o $@ $^
+
+all: $(opgaver)
+
+phony: all clean run
+
+run: $(BIN)
+	./$(BIN)
+
+clean:
+	rm -f $(opgaver)
diff --git a/sem3/osc/mm10/opg1.l b/sem3/osc/mm10/opg1.l
new file mode 100644
index 0000000..b5cb478
--- /dev/null
+++ b/sem3/osc/mm10/opg1.l
@@ -0,0 +1,22 @@
+%{
+
+#include <stdio.h>
+
+%}
+
+ting		(a|b)abcd
+
+%%
+
+{ting}		{ printf("Fandt ting %s\n", yytext); return 1; }
+.			{ printf("Meh"); }
+
+%%
+
+int main(void) {
+
+	printf("yylex: %d\n", yylex());
+
+	return 0;
+	
+}
diff --git a/sem3/osc/mm10/opg3.l b/sem3/osc/mm10/opg3.l
new file mode 100644
index 0000000..1c4b9c7
--- /dev/null
+++ b/sem3/osc/mm10/opg3.l
@@ -0,0 +1,36 @@
+%{
+
+#include <stdio.h>
+
+#define BEGIN_T 1
+#define END_T 2
+#define NUM_T 3
+#define VAR_T 4
+
+%}
+
+VAR			[a-zA-Z][a-zA-Z\_\-0-9]*
+TAL			[0-9]+
+
+%%
+
+begin		{printf("Found a BEGIN\n"); return BEGIN_T;}
+end			{printf("Found a END\n"); return END_T;}
+{VAR}		{printf("Found a variable %s\n", yytext); return VAR_T;}
+{TAL}		{printf("Found a number %d\n", strtol(yytext, NULL, 10)); return NUM_T;}
+
+%%
+
+int main(void) {
+
+	for(;;) {
+		int t = yylex();
+		printf("yylex: %d\n", t);
+		if( t == END_T ) {
+			break;
+		}
+	}
+
+	return 0;
+	
+}
diff --git a/sem3/osc/mm10/opg4.l b/sem3/osc/mm10/opg4.l
new file mode 100644
index 0000000..aeb73b1
--- /dev/null
+++ b/sem3/osc/mm10/opg4.l
@@ -0,0 +1,101 @@
+%{
+
+#include <stdio.h>
+#include <stdint.h>
+
+#define BEGIN_T 1
+#define END_T 2
+#define NUM_T 3
+#define VAR_T 4
+#define HASHSIZE 100
+
+typedef struct symnode_struct {
+	struct symnode_struct *next;
+	char *name;
+} symnode_t;
+
+symnode_t *sym_insert(char *var);
+symnode_t *sym_lookup(char *var);
+
+%}
+
+VAR			[a-zA-Z][a-zA-Z\_\-0-9]*
+TAL			[0-9]+
+
+%%
+
+begin		{printf("Found a BEGIN\n"); return BEGIN_T;}
+end			{printf("Found a END\n"); return END_T;}
+{VAR}		{printf("Found a variable %s\n", yytext); 
+				if( !sym_lookup(yytext) ) { 
+					printf("Not found inserting\n");
+					sym_insert(yytext);
+				}
+				return VAR_T;}
+{TAL}		{printf("Found a number %d\n", strtol(yytext, NULL, 10)); return NUM_T;}
+
+%%
+
+symnode_t *symlist[HASHSIZE];
+
+unsigned int hash(char *s) {
+	uint32_t hv = 0;
+	for( int i = 0; s[i] != '\0'; i++ ) {
+		// take MSB 6 bits of hv and xors with LSB of s[i]
+		uint32_t v = ( hv >> 26 ) ^ (s[i] & 0x3f);
+
+		// Push those back on hv
+		hv = (hv << 4) | v;
+	}
+	// Return appropriate size
+	return hv % HASHSIZE;
+}
+
+
+symnode_t *sym_insert(char *var) {
+	unsigned int index = hash(var);
+
+	// Save old value
+	symnode_t *oldSym = symlist[index];
+
+	// Make new
+	symlist[index] = malloc(sizeof(symnode_t));
+	if( symlist[index] == NULL ) {
+		// If malloc failed
+		symlist[index] = oldSym;
+		return NULL;
+	}
+
+	// Link old one
+	symlist[index]->next = oldSym;
+	symlist[index]->name = var;
+
+	return symlist[index];
+}
+
+symnode_t *sym_lookup(char *var) {
+	unsigned int index = hash(var);
+	symnode_t *n = symlist[index];
+
+	// Look trough list
+	while(n != NULL && strcmp(n->name, var) != 0) {
+		n = n->next;
+	}
+
+	return n;
+}
+
+
+int main(void) {
+
+	for(;;) {
+		int t = yylex();
+		printf("yylex: %d\n", t);
+		if( t == END_T ) {
+			break;
+		}
+	}
+
+	return 0;
+	
+}
diff --git a/sem3/osc/mm10/opgaver.md b/sem3/osc/mm10/opgaver.md
new file mode 100644
index 0000000..b8c8186
--- /dev/null
+++ b/sem3/osc/mm10/opgaver.md
@@ -0,0 +1,55 @@
+# MM10
+
+## Opgave 1
+
+A)
+
+<img src="./stateMachine.png"></img>
+
+B)
+
+Kan ses i den tilhørende opg1.l fil.
+For at compile kør:
+
+```
+make run BIN=opg1
+```
+
+C)
+
+```
+aabcd
+
+Fandt ting aabcd
+yylex: 1
+```
+
+```
+afggfd
+
+MehMehMehMehMehMeh
+```
+
+## Opgave 2
+
+Regulære udtryk for:
+
+```
+c kommentarer: \/\/.*\n
+real konstant: [-+]?[0-9]*(\.[0-9]+)?(e\+[0-9]+)?
+starter med store: [A-Z][a-zA-z]+
+```
+
+## Opgave 3
+
+Dette laver jeg i opg3.l filen.
+
+## Opgave 4
+
+Se opg4.l fil og kør med.
+
+```
+make run BIN=opg4
+```
+
+
diff --git a/sem3/osc/mm10/stateMachine.png b/sem3/osc/mm10/stateMachine.png
new file mode 100644
index 0000000..08c5bf2
--- /dev/null
+++ b/sem3/osc/mm10/stateMachine.png
diff --git a/sem3/osc/mm11/opgaver.md b/sem3/osc/mm11/opgaver.md
new file mode 100644
index 0000000..276236a
--- /dev/null
+++ b/sem3/osc/mm11/opgaver.md
@@ -0,0 +1,32 @@
+# Opgave 1
+
+Mange af dem er okay.
+
+```
+<program> ::= 'program''(' <ident> ')' <statementlist> 'end'.
+<statementlist> ::= <statement> <statementlist> | e
+<statement> ::= <ident> '=' <exp>;
+
+<exp> ::= <term> <expB>
+<expB> ::= <termopr> <term> <expB> | e
+
+<term> ::= <factor> <termB>
+<termB> ::= <factoropr> <factor> <termB> | e
+<termopr> ::= '+' | '-'
+
+<factor> ::= '(' <exp> ')' | <ident>
+<factoropr> ::= '*' | '/'
+```
+
+# Opgave 2
+
+Denne laver jeg måske senere.
+
+# Opgave 3
+
+Denne er løst i regn mappen. 
+Kør `make run` deri for at køre.
+
+# Opgave 4
+
+I regn2 mappen
diff --git a/sem3/osc/mm11/regn/Makefile b/sem3/osc/mm11/regn/Makefile
new file mode 100644
index 0000000..442feba
--- /dev/null
+++ b/sem3/osc/mm11/regn/Makefile
@@ -0,0 +1,30 @@
+
+LEX=flex
+YACC=bison
+LIBS=-ly -lfl -lm
+CC=gcc
+
+PROG=regn
+TRASH=lex.yy.c $(PROG).tab.c $(PROG) $(PROG).tab.h $(PROG).output
+
+$(PROG): $(PROG).tab.o lex.yy.o symtab.o
+		$(CC) -o $@ $^ $(LIBS) 
+
+$(PROG).tab.c $(PROG).tab.h: $(PROG).y
+		$(YACC) -d -v $(PROG).y
+
+lex.yy.c: $(PROG).l
+		$(LEX) $(PROG).l
+
+%.o: %.c
+	$(CC) -c -o $@ $^
+
+PHONY: clean run
+
+run: $(PROG)
+	./$(PROG)
+
+clean:
+	rm -f *.o
+	rm -f $(TRASH)
+
diff --git a/sem3/osc/mm11/regn/regn.l b/sem3/osc/mm11/regn/regn.l
new file mode 100644
index 0000000..bbaadb8
--- /dev/null
+++ b/sem3/osc/mm11/regn/regn.l
@@ -0,0 +1,40 @@
+%{
+#include <math.h>
+#include <string.h>
+#include "symtab.h"
+#include "regn.tab.h"
+%}
+
+realtal      ([0-9]+|([0-9]*\.[0-9]+))([eE][-+]?[0-9]+)?
+var_begin	 let
+op_log		 log
+op_exp		 exp
+op_sqrt		 sqrt
+var			 [A-Za-z][A-Za-z0-9]*
+
+%%
+{realtal}      {yylval.dval = atof(yytext); 
+                return TAL;}
+{var_begin}	   {return VAR_BEGIN;}
+{op_log}	   {return LOG;}
+{op_exp}	   {return EXP;}
+{op_sqrt}	   {return SQRT;}
+
+{var}		   {yylval.string = strdup(yytext); return VAR;}
+
+[ \t] ;
+
+
+'$'            {return 0;} 
+
+\n|.           {return yytext[0];} 
+
+%%
+
+void init_sym()
+{
+	int  i;
+	for (i = 0; i < HASHSIZE; i++)
+		symbolarray[i] = NULL;
+}
+
diff --git a/sem3/osc/mm11/regn/regn.y b/sem3/osc/mm11/regn/regn.y
new file mode 100644
index 0000000..d0f67eb
--- /dev/null
+++ b/sem3/osc/mm11/regn/regn.y
@@ -0,0 +1,54 @@
+%{
+#include <stdio.h>
+#include <math.h>
+#include "symtab.h"
+#include <string.h>
+%}
+
+%union {
+	char           *string;
+	double          dval;
+}
+
+%token <string> VAR
+%token <dval> TAL
+%token LOG EXP SQRT VAR_BEGIN
+
+%left '-' '+'
+%right LOG EXP SQRT
+%left '*' '/'
+%right UMINUS
+
+%type <dval> expression
+
+%%
+
+statement_list: statement '\n'
+	  | statement_list statement '\n' ;
+
+statement:  expression					{printf("= %f\n",$1);}
+	  | VAR_BEGIN VAR '=' expression	{symnode_t *n = sym_lookup($2);
+										 if( !n ) {n = sym_insert($2); }
+										 n->value = $4;};
+
+expression: expression '+' expression   {$$ = $1 + $3;}
+	  | expression '-' expression   {$$ = $1 - $3;}
+	  | expression '*' expression   {$$ = $1 * $3;}
+	  | expression '/' expression   {if ($3 == 0.0) 
+                                           yyerror("divide dy zero");
+                                         else $$ = $1 / $3;}
+	  | '-' expression %prec UMINUS {$$ =  - $2;}
+	  | '(' expression ')'          {$$= $2;}
+	  | LOG expression				{$$ = log($2);}
+	  | EXP expression				{$$ = exp($2);}
+	  | SQRT expression				{$$ = sqrt($2);}
+          | TAL                         {$$ = $1;}
+	  | VAR							{symnode_t *n = sym_lookup($1);
+									 if( !n ) { yyerror("Var not found"); } else { $$ = n->value;} };
+%%
+
+int main()
+{ 
+  yyparse(); 
+}
+
diff --git a/sem3/osc/mm11/regn/symtab.c b/sem3/osc/mm11/regn/symtab.c
new file mode 100644
index 0000000..8103203
--- /dev/null
+++ b/sem3/osc/mm11/regn/symtab.c
@@ -0,0 +1,50 @@
+#include "symtab.h"
+#include <stdlib.h>
+#include <string.h>
+
+unsigned int hash(char *s) {
+	uint32_t hv = 0;
+	for( int i = 0; s[i] != '\0'; i++ ) {
+		// take MSB 6 bits of hv and xors with LSB of s[i]
+		uint32_t v = ( hv >> 26 ) ^ (s[i] & 0x3f);
+
+		// Push those back on hv
+		hv = (hv << 4) | v;
+	}
+	// Return appropriate size
+	return hv % HASHSIZE;
+}
+
+
+symnode_t *sym_insert(char *var) {
+	unsigned int index = hash(var);
+
+	// Save old value
+	symnode_t *oldSym = symbolarray[index];
+
+	// Make new
+	symbolarray[index] = malloc(sizeof(symnode_t));
+	if( symbolarray[index] == NULL ) {
+		// If malloc failed
+		symbolarray[index] = oldSym;
+		return NULL;
+	}
+
+	// Link old one
+	symbolarray[index]->next = oldSym;
+	symbolarray[index]->name = var;
+
+	return symbolarray[index];
+}
+
+symnode_t *sym_lookup(char *var) {
+	unsigned int index = hash(var);
+	symnode_t *n = symbolarray[index];
+
+	// Look trough list
+	while(n != NULL && strcmp(n->name, var) != 0) {
+		n = n->next;
+	}
+
+	return n;
+}
diff --git a/sem3/osc/mm11/regn/symtab.h b/sem3/osc/mm11/regn/symtab.h
new file mode 100644
index 0000000..c61f3a8
--- /dev/null
+++ b/sem3/osc/mm11/regn/symtab.h
@@ -0,0 +1,20 @@
+#include <stdint.h>
+#define HASHSIZE 100
+
+typedef struct symnode_struct {
+	char *name;
+	struct symnode_struct *next;
+	double value;
+} symnode_t;
+
+symnode_t *sym_insert(char *var);
+symnode_t *sym_lookup(char *var);
+
+struct symnode {
+	struct symnode *next;
+	char *name;
+	int type;
+	double value;
+};
+
+symnode_t *symbolarray[HASHSIZE];
diff --git a/sem3/osc/mm11/regn2/Makefile b/sem3/osc/mm11/regn2/Makefile
new file mode 100644
index 0000000..9640aaa
--- /dev/null
+++ b/sem3/osc/mm11/regn2/Makefile
@@ -0,0 +1,30 @@
+
+LEX=flex
+YACC=bison
+LIBS=-ly -lfl -lm
+CC=gcc
+
+PROG=regn
+TRASH=lex.yy.c $(PROG).tab.c $(PROG) $(PROG).tab.h $(PROG).output
+
+$(PROG): $(PROG).tab.o lex.yy.o
+		$(CC) -o $@ $^ $(LIBS) 
+
+$(PROG).tab.c $(PROG).tab.h: $(PROG).y
+		$(YACC) -d -v $(PROG).y
+
+lex.yy.c: $(PROG).l
+		$(LEX) $(PROG).l
+
+%.o: %.c
+	$(CC) -c -o $@ $^
+
+PHONY: clean run
+
+run: $(PROG)
+	./$(PROG)
+
+clean:
+	rm -f *.o
+	rm -f $(TRASH)
+
diff --git a/sem3/osc/mm11/regn2/regn.l b/sem3/osc/mm11/regn2/regn.l
new file mode 100644
index 0000000..9988ddd
--- /dev/null
+++ b/sem3/osc/mm11/regn2/regn.l
@@ -0,0 +1,27 @@
+%{
+#include <math.h>
+#include <string.h>
+#include "regn.tab.h"
+%}
+
+realtal      ([0-9]+|([0-9]*\.[0-9]+))([eE][-+]?[0-9]+)?
+op_log		 log
+op_exp		 exp
+op_sqrt		 sqrt
+
+%%
+{realtal}      {yylval.dval = atof(yytext); 
+                return TAL;}
+{op_log}	   {return LOG;}
+{op_exp}	   {return EXP;}
+{op_sqrt}	   {return SQRT;}
+
+[ \t] ;
+
+
+'$'            {return 0;} 
+
+\n|.           {return yytext[0];} 
+
+%%
+
diff --git a/sem3/osc/mm11/regn2/regn.y b/sem3/osc/mm11/regn2/regn.y
new file mode 100644
index 0000000..eac24c8
--- /dev/null
+++ b/sem3/osc/mm11/regn2/regn.y
@@ -0,0 +1,46 @@
+%{
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+%}
+
+%union {
+	double          dval;
+}
+
+%token <dval> TAL
+%token LOG EXP SQRT
+
+%left '-' '+'
+%left LOG EXP SQRT
+%left '*' '/'
+%right UMINUS
+
+%type <dval> expression
+
+%%
+
+statement_list: statement '\n'
+	  | statement_list statement '\n' ;
+
+statement:  expression					{printf("out \n");};
+
+expression: expression '+' expression   {printf("sum \n");}
+	  | expression '-' expression		{printf("sub \n");}
+	  | expression '*' expression		{printf("mul \n");}
+	  | expression '/' expression		{if ($3 == 0.0) 
+                                           yyerror("divide dy zero");
+                                         else printf("div \n");}
+	  | '-' expression %prec UMINUS		{printf("neg \n");}
+	  | '(' expression ')'				{;}
+	  | LOG expression					{printf("log \n");}
+	  | EXP expression					{printf("exp \n");}
+	  | SQRT expression					{printf("sqrt \n");}
+          | TAL                         {printf("load %f \n", $$);};
+%%
+
+int main()
+{ 
+  yyparse(); 
+}
+
diff --git a/sem3/osc/mm3/opgaver.md b/sem3/osc/mm3/opgaver.md
new file mode 100644
index 0000000..d9440f8
--- /dev/null
+++ b/sem3/osc/mm3/opgaver.md
@@ -0,0 +1,47 @@
+# Opgave 1
+
+> Et operativsystem anvenderen 2-level page tabel og 4Kbyte pagesize. Det
+virtuelle adresseområde er på 4GByte. De programmer der afvikles på
+computeren er på mellem 64 KByte og 16MByte. Hvor mange bit vil I anvende til
+index ind i hhv. page tabel 1 og pagetabel 2.
+
+Her betyder det at man har en tabel der referere til level 2 tabeller.
+
+Så i level to tabellen ville jeg nok have 4M da det er 1023 pages. 
+Dette betyder at der vil lidt spild med det lille program på 64kb men det større program på 16Mb betøver ikke få så mange pages.
+
+1023 pages kræver tilgængeld 10 bits til indexering hvilket er lidt spild.
+
+For at få op til 4GB skal man igen have 1023 reference i level 1 tabel.
+
+En anden mulighed ville være at have 8 bits til level 2 index, og derfor have 255 pages i level to tabel.
+Dette vil betyde at level to indexen ikke spilder plads from med 10 bit.
+
+En level 1 tabel indexer derfor 4Kb * 255 = 4096 * 255 = 104 4480 = 104Kb
+
+Her vil level 1 tabellen få 4Gb / 104.4480Kb = 4 000 000 000 / 104 4480 =~= 4112
+
+Her skal man bruge 13 bits, hvilket betyder at man spilder 3 bits hvis man bruger 16 bit system.
+
+# Opgave 2
+
+> Diskuter måder at håndtere virtuelle pages på. Kan man optimere software i
+forhold til hvordan et OS håndterer pages? Er der noget i en eller flere
+koncepter I måske kan anvende i jeres projekt?
+
+Læser på wikipedia at dette er en teknik hvor man gemmer under pagene i virtuel memory i stedet for physical.
+Dette vil betyder at den også kan blive swappet til disk osv.
+
+Dette vil tilgengeld kræve at man har nogle pages i physical som skal holder styr på de virtuelle som indeholder andre pages.
+Det vil nok egentlig være lidt bøvlet. 
+
+Man kunne måske have at level 1 tabellen signalere om pagen er i physical eller virtuel.
+
+# Opgave 3
+
+> Skriv et lille program, der allokerer en stadig voksende mængde hukommelse,
+f.eks. start med 8kB, 8MB, 8GB og mere... hvornår løber I ind i problemer?
+Observer evt. med værktøjet ovenstående eller andet der passer til jeres
+platform.
+
+
diff --git a/sem3/osc/mm8/mm8.ino b/sem3/osc/mm8/mm8.ino
new file mode 100644
index 0000000..f47306d
--- /dev/null
+++ b/sem3/osc/mm8/mm8.ino
@@ -0,0 +1,47 @@
+// Spg kernel
+#include <krnl.h>
+
+#define PRIO 10
+#define STACK 100
+
+char stackFast[STACK];
+struct k_t *semFast, *fastTask;
+
+void fast() {
+	/* Gotta go fast(10 Hz) */
+	k_set_sem_timer(semFast, 1000);
+	for(;;) {
+		k_wait(semFast, 0);
+		k_eat_ticks(90);
+	}
+}
+
+void setup() {
+	pinMode(13, OUTPUT);
+
+	PORTB |= 0x20;
+	delay(1000);
+	PORTB &= 0xDF;
+	delay(200);
+
+	k_init(1, 1, 0);
+	
+	fastTask = k_crt_task(fast, PRIO, stackFast, STACK);
+	semFast = k_crt_sem(0, 2);
+
+	k_start(1);
+	PORTB |= 0x20;
+}
+
+void loop() {}
+
+extern "C" {
+
+	void k_breakout() {
+		if( pRun->nr == 0 ) {
+			PORTB |= 0x20;
+		} else {
+			PORTB &= 0xDF;
+		}
+	}
+}
diff --git a/sem3/osc/mm9/opgaver.md b/sem3/osc/mm9/opgaver.md
new file mode 100644
index 0000000..fe2ec99
--- /dev/null
+++ b/sem3/osc/mm9/opgaver.md
@@ -0,0 +1,129 @@
+# Opgave A
+
+Hmm ved ikke lige med projekt men har en fed ide.
+
+Openscad men til 2d graffik som **kompilere** til svg.
+
+Tænker at man vil lave det i et sprog som c, go eller rust. 
+Rust ville være optimalt men det er også lidt svært.
+
+Det skulle være et emperisk sprog med variabler og functioner.
+Funktioner returnere ikke noget, men mere en bestemt figur.
+
+Variables can be strings, floating point numbers.
+
+Lists are defined as list.
+
+Strings begin with big letters. 
+
+Bools are defined as numbers 0 and 1.
+
+Lists are defined as [] and contain all numbers or all strings.
+
+C style comments.
+
+```
+var Black = "#FFFFFF";
+var White = "#000000";
+list Names = [ "nice", "nice2" ];
+
+var radius = 10.2;
+
+func coolCircle(r, Name) {
+	// Defined as circle(radius, fgCol, bgCol)
+	circle(r, Black, White);
+
+	// Defined as insertText(Text, allign, fgCol)
+	insertText(Name, ALIGN_CENTER, Black);
+}
+
+translate(1, 2) {
+	coolCircle(radius / 2, Names[0]);
+}
+
+coolCircle(radius, Names[1]);
+```
+
+The code will generate two circles, one in the center and one on the coordinates 1, 2.
+
+# Opgave B
+
+Der er defineret to globale variabler, men de er ikke på stacken.
+
+Inde i main laver man en pointer til a og sender ind i funktionen.
+Dette betyder at denne pointer enten ligger på stacken eller i et register når funktionen ainc kører.
+
+Men der kan siges sikkert at stacken indeholder en return pointer til main og en reference til den tidelige stack(tror jeg).
+
+
+## Kode i assembly
+
+Jeg har ikke taget højde for integer operationer.
+
+```
+JMP main
+var_a: DB 4
+
+ainc:
+	MOV B, [A]
+	ADD B, 1
+	MOV [A], B
+	RET
+
+main:
+	MOV A, var_a
+	CALL ainc
+
+	HLT
+```
+
+## Forskellige compile trin
+
+Proprocessor har ikke noget at lave.
+
+Start med at compile til assembly:
+
+Læg a og b i starten af programmet.
+
+Compiler funktionen ainc og adec og sæt en label ved dem.
+Dette gøres ved først at lave koden der henter argument ud og gemmer tidligere stack pointer.
+Derefter compiles indholdet i funktionen.
+Slut af med at returner til caller.
+
+Derefter bliver assembly'en assemblet:
+
+De forskellige mnenorics(eller hvad det nu hed) bliver lavet om til opcodes og lags sammen med deres argumenter.
+Dette gøres for alle funktionerne.
+
+a og b bliver placeret i filen.
+
+Derefter placeres main ved entrypoint og de to funktioner bliver lagt ved siden af.
+De forskellige referencer til funktioner og globale variabler bliver byttet ud med deres virkelige værdier i binary.
+
+# Opgave C
+
+Grammastart -> *Viggo* stmList *End*
+stmList -> stm stmList | e
+stm -> ident *=* exp *;*
+ident -> letter symList
+letter -> *a* | ... | *å* | *A* | ... | *Å*
+digit -> *0* | ... | *9*
+symbol -> letter | digit
+symList -> symbol symList | e
+exp -> term expB
+expB -> termopr term expB | e
+termOpr -> *+* | *-*
+term -> factor termB
+termB -> factorOpr factor termB | e
+factorOpr -> _*_ | _/_
+factor -> *(* exp *)* | ident
+
+## C.2
+
+See tree.png
+
+## C.3
+
+
+
+
diff --git a/sem3/osc/noter.md b/sem3/osc/noter.md
new file mode 100644
index 0000000..6e13640
--- /dev/null
+++ b/sem3/osc/noter.md
@@ -0,0 +1,17 @@
+# HUsk
+
+Ikke Deterministisk: Et stadie i kan føre til flere andre states.
+
+Undersøg **kontekst fri**
+
+Leksikal analysen: bruger regulær
+
+Parsing: ikke regulær.
+
+Shift-reduce parser.
+
+3 adress code bruges til mellem kode.
+
+In order: tree (venstre, top, højre)
+preorder: tree (top, venstre, højre)
+postorder: tree (venstre, højre, top)