#include <conio.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define GETAL 0
#define INSTRUCTIE 1

#define ONMIDDELIJK 0
#define DIRECT 1
#define INDIRECT 2

struct registers {
	unsigned int a: 32;
	unsigned int b: 32;
	unsigned int zero: 1;
	unsigned int nega: 1;
	unsigned int over: 1;
	unsigned int teller: 24;
}regs;

struct regel{
	
	union geheugenCel{
		int getal;
		struct {
			unsigned int operand: 24;
			unsigned int adressering: 2;
			unsigned int operat: 6;
		} instructie;
	} cel;


	int type;
	int nr;
	struct regel *volgend;
};


char* trim(char *string);
int decode(unsigned int getal);
void printBin (int oper);
int laatsteCel (struct regel *lijst);
struct regel * zoekCel (struct regel *lijst, int nummer);
void setGeheugen(int operat, int adressering, int operand, struct regel **lijst);
void printLijst(struct regel *lijst);
char * stringIn(void);
void fileToWorkdoc (char * bestandsnaam);
void verwijderLijn (int regelnr);
void pasLijnAan (int regelnr);
void inputToWorkdoc (char * input);
void printWorkdoc (void);

void zetInA(int getal);

int telCommandoRegels(struct regel *lijst);

int checkGetal(char *getal);
int checkPosGetal(char *getal);
int checkHaakjes(char *getal);

int setLDA(char* regel);
int setLDB(char* regel);
int setSTA(char* regel);
int setSTB(char* regel);
int setINP(char* regel);
int setOUT(char* regel);
int setNOP(char* regel);
int setHLT(char* regel);
int setADD(char* regel);
int setSUB(char* regel);
int setDIV(char* regel);
int setMUL(char* regel);
int setJMP(char *regel);
int setJSP(char *regel);
int setJSN(char *regel);
int setJIZ(char *regel);
int setJOF(char *regel);
int setJSB(char *regel);
int setRTS(char *regel);


int doLDA(struct regel* lijn);
int doLDB(struct regel* lijn);
int doSTA(struct regel* lijn);
int doSTB(struct regel* lijn);

int doLDA(struct regel* lijn);
int doLDB(struct regel* lijn);
int doNOP(struct regel* lijn);
int doADD(struct regel* lijn);
int doSUB(struct regel* lijn);
int doMUL(struct regel* lijn);
int doDIV(struct regel* lijn);
int doJMP(struct regel* lijn);
int doJSP(struct regel* lijn);
int doJSN(struct regel* lijn);
int doJIZ(struct regel* lijn);
int doJOF(struct regel* lijn);
int doHLT(struct regel* lijn);

void addCel(struct regel * toAdd, struct regel **lijst);
int verwerkLijn(char * commando);

struct regel *lijst;

void zetInA(int getal){

 if(getal < 0)
	 regs.nega = 1;
 if(getal = 0)
	 regs.zero = 1;
 if(getal > 16777215 || getal < -16777215)
	 regs.over = 1;
 regs.a = getal;
}

char* trim(char *string){
    int tel=0;
    int i= strlen(string)-1;
    char* oplos;
    // 123456789   \0
    while(string[i] == ' '){
    tel++;
    i--;
    }
    oplos = (char*) malloc(sizeof(char)*(strlen(string)-tel+1));
    oplos[strlen(string)-tel] = '\0';
    for(i=0;i<strlen(oplos);i++)
        oplos[i] = string[i];
    return oplos;
}
int decode(unsigned int getal) {
	int opvang;
	opvang = getal;
	if ((opvang & 0x800000) == 0x800000) {
		opvang = opvang & 0x7FFFFF;
		opvang = opvang -1;
		opvang = opvang ^ 0x7FFFFF;
		opvang *= -1;
	}
	/* 8388608 */
	return opvang;
}

void printBin (int oper) {
	int mask = 0x800000;
	while (mask != 0) {
		printf("%d",(mask & oper)?1:0);
		mask >>= 1;
	}
	printf("\n");
}

int laatsteCel (struct regel *lijst) {
	int teller=0;
	while (lijst != NULL) {
		teller++;
		lijst = lijst->volgend;
	}
	return teller;
}

struct regel * zoekCel (struct regel *lijst, int nummer) {
	while (lijst != NULL) {
		if (lijst->nr == nummer) {
			return lijst;
		}
		lijst = lijst->volgend;
	}
	return NULL;
}

void setGeheugen(int operat, int adressering, int operand, struct regel **lijst) {
	struct regel *nieuw = (struct regel *)malloc(sizeof(struct regel));
	struct regel *doorloop = *lijst;
	nieuw->nr = laatsteCel(*lijst);
	nieuw->type = 1;
	nieuw->cel.instructie.adressering = adressering;
	nieuw->cel.instructie.operand = operand;
	nieuw->cel.instructie.operat = operat;
	nieuw->volgend = NULL;
	if (*lijst == NULL) {
		*lijst = nieuw;
	}
	else {
		while(doorloop->volgend != NULL)
			doorloop = doorloop->volgend;
		doorloop->volgend = nieuw;
	}
}

void printLijst(struct regel *lijst) {
	while (lijst != NULL) {
		if(1 == 1){
			printf("\nNR:%d Operat:%x Adress:%x Operand:\n", lijst->nr, lijst->cel.instructie.operat, lijst->cel.instructie.adressering);
			printBin(lijst->cel.instructie.operand);
			printf("bin %d\n",decode(lijst->cel.instructie.operand));
		}
		else {
			printf("\ngetal\n");
		}
		lijst = lijst->volgend;
	}
}

char * stringIn(void) {
  int i = 0;
  char buffer[512], opvang;
  char * resultaat = NULL;
  /*gets en scanf zorgden voor problemen */
  do {
    opvang = getch();
	if (opvang != 13 && opvang != 8)  /* backspace moet apart behandeld worden ingelezen worden */
		printf("%c",opvang);
	if (opvang != 13 && opvang == 8) {
		if (i != 0){ /* Out of bounds voorkomen */
			i--; /* Backspace in de buffer nadoen */
		printf("%c",opvang); /* Terug gaan in console en backspace effectief nadoen (karakter 'wissen') */
		printf(" ");
		printf("%c",opvang);
		}
	}
	if (opvang != 8) {
		buffer[i] = opvang;
		i++;
	}
	opvang = ' ';	
  }while(i<512 && buffer[i-1] != 13);
  buffer[i-1] = '\0';
  resultaat = (char*)malloc(strlen(buffer)+1); /* +1 voor de \0 */
  strcpy(resultaat,buffer);
  return resultaat;
}

void fileToWorkdoc (char * bestandsnaam) {
	FILE *fptr, *fptr2;
	char opvang[128];
	/*VRAAG BESTANDSNAAM OP */ 
	fptr = fopen(bestandsnaam,"r");
	fptr2 = fopen("workdoc.txt","w");
	if ( (fptr)==NULL || (fptr2)==NULL)
		 printf("\n\t\tFile bestaat niet, of kan niet geopend worden..");
	else {
		while ((fgets(opvang,128,fptr)) != NULL)
			fputs(opvang, fptr2);
		}
	fclose(fptr);
	fclose(fptr2);
}


void verwijderLijn (int regelnr) {
	FILE *fptr, *fptr2;
	char opvang[128];
	int teller = 0;
	fptr = fopen("workdoc.txt","r");
	fptr2 = fopen("tempor.txt","w");
	if ( (fptr)==NULL || (fptr2)==NULL)
		 printf("\n\t\tFile bestaat niet, of kan niet geopend worden..");
	else {
		while ((fgets(opvang,128,fptr)) != NULL) {
			if(teller != regelnr) 
				fputs(opvang, fptr2);
			teller++;
		}
	}
	fclose(fptr);
	fclose(fptr2);
	fileToWorkdoc("tempor.txt");
	if(remove("tempor.txt") == -1)
		perror("\nFout bij verwijderen temp-bestand:");
}

void pasLijnAan (int regelnr) {
	FILE *fptr, *fptr2;
	char opvang[128];
	char * nieuweregel;
	int teller = 0;
	fptr = fopen("workdoc.txt","r");
	fptr2 = fopen("tempor.txt","w");
	if ( (fptr)==NULL || (fptr2)==NULL)
		 printf("\n\t\tFile bestaat niet, of kan niet geopend worden..");
	else {
		while ((fgets(opvang,128,fptr)) != NULL) {
			if(teller != regelnr) 
				fputs(opvang, fptr2);
			else {
				printf("\nhoeba:");
				nieuweregel = stringIn();
				fprintf(fptr2,"%s\n",nieuweregel);
			}
			teller++;
		}
	}
	free(nieuweregel);  /* Geheugen van de string terug vrijgeven */
	fclose(fptr);
	fclose(fptr2);
	fileToWorkdoc("tempor.txt");
	if(remove("tempor.txt") == -1)
		perror("\nFout bij verwijderen temp-bestand:");
}



void inputToWorkdoc (char * input) {
	FILE *fptr;
	if ((fptr = fopen("workdoc.txt","a"))==NULL)
		printf("\n\t\tWorkdoc kan niet geopend worden..");
	else {
		fprintf(fptr,"%s\n",input);
	}
	fclose(fptr);
}

void printWorkdoc (void) {
	FILE *fptr;
	char opvang[128];
	if ((fptr = fopen("workdoc.txt","r"))==NULL)
		printf("\n\t\tWorkdoc kan niet geopend worden..");
	else {
		while ((fgets(opvang,128,fptr)) != NULL)
			printf("%s",opvang);
	}
}



int checkGetal(char *getal){

int ok = 1;
int loc = 0;

if(getal[0] == '-') // negatief getal ook geldig
    loc++;

while(getal[loc] != '\0' && ok){
    ok = getal[loc] <= '9' && getal[loc] >= '0';
    loc++;    
}
return ok;
}
int checkPosGetal(char *getal){

int ok = 1;
int loc = 0;

while(getal[loc] != '\0' && ok){
    ok = getal[loc] <= '9' && getal[loc] >= '0';
    loc++;    
}
return ok;
}


int checkHaakjes(char *getal){

int ok = 1;
int loc = 1; // starten net na de '('
if(getal[0] != '(')
    ok = 0;
else if(getal[strlen(getal)-1] != ')')
    ok = 0;

while(getal[loc] != ')' && ok){
    ok = getal[loc] <= '9' && getal[loc] >= '0';
    loc++;    
}
return ok;
}



int setLDA(char* regel){

    if (regel[3] != ' ' ){
        printf("Ongeldige syntax");
        return -1;
    }
    else {

        if ((strlen(regel) >=5 )&& regel[4] == '#' && checkGetal(&regel[5])){
                setGeheugen(4,0,atoi(&regel[5]),&lijst);
                return 1;
        }
        else if((strlen(regel) >=4) &&checkGetal(&regel[4])){
                setGeheugen(4,1,atoi(&regel[4]),&lijst);
                return 1;        
        }
        else if((strlen(regel) >=4) && checkHaakjes(&regel[4])){
                setGeheugen(4,2,atoi(&regel[5]),&lijst);
                return 1;        
        }
        else
                return -1;

    }
}

int setLDB(char* regel){

    if (regel[3] != ' '){
        printf("Ongeldige syntax");
        return -1;
    }
    else {

        if ((strlen(regel) >=5 )&& regel[4] == '#' && checkGetal(&regel[5])){
                setGeheugen(5,0,atoi(regel[5]),&lijst);
                return 1;
        }
        else if((strlen(regel) >=4 )&& checkGetal(&regel[4])){
                setGeheugen(5,1,atoi(&regel[4]),&lijst);
                return 1;        
        }
        else if((strlen(regel) >=4 )&& checkHaakjes(&regel[4])){
                setGeheugen(5,2,atoi(&regel[5]),&lijst);
                return 1;        
        }
        else
                return -1;

    }
}
int setSTA(char* regel){

    if (regel[3] != ' '){
        printf("Ongeldige syntax");
        return -1;
    }
    else {
        if((strlen(regel) >=4 )&& checkGetal(&regel[4])){
                setGeheugen(8,1,atoi(&regel[4]),&lijst);
                return 1;        
        }
        else if((strlen(regel) >=4 )&& checkHaakjes(&regel[4])){
                setGeheugen(8,2,atoi(&regel[5]),&lijst);
                return 1;        
        }
        else
                return -1;

    }
}
int setSTB(char* regel){

    if (regel[3] != ' '){
        printf("Ongeldige syntax");
        return -1;
    }
    else {
        if((strlen(regel) >=4 )&& checkGetal(&regel[4])){
                setGeheugen(9,1,atoi(&regel[4]),&lijst);
                return 1;        
        }
        else if((strlen(regel) >=4 )&& checkHaakjes(&regel[4])){
                setGeheugen(9,2,atoi(&regel[5]),&lijst);
                return 1;        
        }
        else
                return -1;

    }
}


int setINP(char* regel){
    if(strlen(regel) !=  3)
        return -1;
    else{
        setGeheugen(24,0,16777215,&lijst);
        return 1;
    }
}

int setOUT(char* regel){
    if(strlen(regel) !=  3)
        return -1;
    else{
        setGeheugen(28,0,16777215,&lijst);
        return 1;
    }
}
int setNOP(char* regel){
    if(strlen(regel) !=  3)
        return -1;
    else{
        setGeheugen(0,0,16777215,&lijst);
        return 1;
    }
}
int setHLT(char* regel){

    if(strlen(regel) != 3)
        return -1;
    else{
        setGeheugen(63,0,16777215,&lijst);
        return 1;
    }
}

int setADD(char* regel){

    if(strlen(regel) != 3)
        return -1;
    else{
    setGeheugen(32,0,16777215,&lijst);
    return 1;
    }
}
int setSUB(char* regel){

    if(strlen(regel) != 3)
        return -1;
    else{
    setGeheugen(36,0,16777215,&lijst);
    return 1;
    }
}
int setDIV(char* regel){

    if(strlen(regel) != 3)
        return -1;
    else{
    setGeheugen(44,0,16777215,&lijst);
    return 1;
    }
}

int setMUL(char* regel){
    if(strlen(regel) != 3)
        return -1;
    else{
    setGeheugen(40,0,16777215,&lijst);
    return 1;
    }
}

int setJMP(char *regel){

if (regel[3] != ' '){
        printf("Ongeldige syntax");
        return -1;
    }
    else {

        if ((strlen(regel) >=4 )&& checkGetal(regel[4])){
                setGeheugen(48,0,atoi(regel[4]),&lijst);
                return 1;
        }
        else
            return -1;
    }
}
int setJSP(char *regel){

if (regel[3] != ' '){
        printf("Ongeldige syntax");
        return -1;
    }
    else {

        if ((strlen(regel) >=4 )&& checkGetal(regel[4])){
                setGeheugen(50,0,atoi(regel[4]),&lijst);
                return 1;
        }
        else
            return -1;
    }
}
int setJSN(char *regel){

if (regel[3] != ' '){
        printf("Ongeldige syntax");
        return -1;
    }
    else {

        if ((strlen(regel) >=4 )&& checkGetal(regel[4])){
                setGeheugen(52,0,atoi(regel[4]),&lijst);
                return 1;
        }
        else
            return -1;
    }
}
int setJIZ(char *regel){

if (regel[3] != ' '){
        printf("Ongeldige syntax");
        return -1;
    }
    else {

        if ((strlen(regel) >=4 )&& checkGetal(regel[4])){
                setGeheugen(54,0,atoi(regel[4]),&lijst);
                return 1;
        }
        else
            return -1;
    }
}
int setJOF(char *regel){

if (regel[3] != ' '){
        printf("Ongeldige syntax");
        return -1;
    }
    else {

        if ((strlen(regel) >=4 )&& checkGetal(regel[4])){
                setGeheugen(56,0,atoi(regel[4]),&lijst);
                return 1;
        }
        else
            return -1;
    }
} 


int setJSB(char *regel){ 

	if(strlen(regel) == 3){
	printf("Syntaxerror");
	return -1;
	}
	else {
		if((strlen(regel) >=4 )&& checkPosGetal(&regel[4])){
                setGeheugen(1,1,atoi(&regel[4]),&lijst); //code staat niet in boek, voor 000001 gekozen
                return 1;        
        }
        else
			return -1;
	
	}

}




int setRTS(char *regel){

if(strlen(regel) != 3)
	return -1;
else {
	setGeheugen(2,0,16777215,&lijst);
	return 1;
}
}
int verwerkLijn(char * commando) {
	char * commandotrimmed = trim(commando); /* De overbodige spaties worden getrimmed */
	char test[4];
	int i;
	for (i=0;i<3;i++)
		test[i]=toupper(commandotrimmed[i]);
	test[i] = '\0';
	if (strcmp(test,"LDA")==0) {
		setLDA(commandotrimmed);
	}
	else if (strcmp(test,"LDB")==0) {
		setLDB(commandotrimmed);
	}
	else if (strcmp(test,"STA")==0) {
		setSTA(commandotrimmed);
	}
	else if (strcmp(test,"STB")==0) {
		setSTB(commandotrimmed);
	}
	else if (strcmp(test,"JSP")==0) {
		setJSP(commandotrimmed);
	}
	else if (strcmp(test,"RTS")==0) {
		setRTS(commandotrimmed);
	}
	else if (strcmp(test,"JSB")==0) {
		setRTS(commandotrimmed);
	}
	else if (strcmp(test,"NOP")==0) {
		setNOP(commandotrimmed);
	}
	else if (strcmp(test,"ADD")==0) {
		setADD(commandotrimmed);
	}
	else if (strcmp(test,"SUB")==0) {
		setSUB(commandotrimmed);
	}
	else if (strcmp(test,"MUL")==0) {
		setMUL(commandotrimmed);
	}
	else if (strcmp(test,"DIV")==0) {
		setDIV(commandotrimmed);
	}
	else if (strcmp(test,"JMP")==0) {
		setJMP(commandotrimmed);
	}
	else if (strcmp(test,"JSP")==0) {
		setJSP(commandotrimmed);
	}
	else if (strcmp(test,"JSN")==0) {
		setJSN(commandotrimmed);
	}
	else if (strcmp(test,"JIZ")==0) {
		setJIZ(commandotrimmed);
	}
	else if (strcmp(test,"JOF")==0) {
		setJOF(commandotrimmed);
	}
	else if (strcmp(test,"INP")==0) {
		setINP(commandotrimmed);
	}
	else if (strcmp(test,"OUT")==0) {
		setOUT(commandotrimmed);
	}
	else if (strcmp(test,"HLT")==0) {
		setHLT(commandotrimmed);
	}
	free(commandotrimmed);
	return 0;
}



int doLDA(struct regel *lijn){

		struct regel* blok = (struct regel*) malloc (sizeof(struct regel*));
		blok->type = GETAL;
		blok->volgend = NULL;
		if(lijn->cel.instructie.adressering == ONMIDDELIJK){ //LDA #5
			blok->cel.getal = decode(lijn->cel.instructie.operand);
			regs.a = zetInA(decode(lijn->cel.instructie.operand));
			return 1;
		}
		else if(lijn->cel.instructie.adressering == DIRECT){//LDA 5
			struct regel* opvang = zoekCel(lijst,decode(lijn->cel.instructie.operand));
			regs.a = zetInA(opvang->cel.getal);
			return 1;
		}
		else if(lijn->cel.instructie.adressering == INDIRECT){ //LDA (500)
		
			struct regel *opvang = zoekCel(lijst,decode(lijn->cel.instructie.operand));		
			opvang = zoekCel(lijst,decode(opvang->cel.instructie.operand));
			regs.a = zetInA(opvang->cel.getal);
			return 1;
		}
		else {
			printf("\nOngeldige adressering...");
			return -1;
		}
			

}

int doLDB(struct regel *lijn){

		struct regel* blok = (struct regel*) malloc (sizeof(struct regel*));
		blok->type = GETAL;
		blok->volgend = NULL;
		if(lijn->cel.instructie.adressering == 0){ // onmiddelijk LDB #5
			blok->cel.getal = decode(lijn->cel.instructie.operand);
			regs.b = decode(lijn->cel.instructie.operand);
			return 1;
		}
		else if(lijn->cel.instructie.adressering == 1){// direct adresering  vb( LDB 5)
			struct regel* opvang = zoekCel(lijst,decode(lijn->cel.instructie.operand));
			regs.b = opvang->cel.getal;
			return 1;
		}
		else if(lijn->cel.instructie.adressering == 2){ // LDB (500)
		
			struct regel *opvang = zoekCel(lijst,decode(lijn->cel.instructie.operand));		
			opvang = zoekCel(lijst,decode(opvang->cel.instructie.operand));
			regs.b = opvang->cel.getal;
			return 1;
		}
		else {
			printf("\nOngeldige adressering...");
			return -1;
		}
			

}


int doSTA(struct regel *lijn){
struct regel *blok = (struct regel*) malloc(sizeof(struct regel*));
	blok->type = GETAL;
	blok->volgend = NULL;
	blok->cel.getal = regs.a;
	
	if(lijn->cel.instructie.adressering == DIRECT){ // STA 5
		blok->nr = decode(lijn->cel.instructie.operand);	
		addCel(blok,&lijst);
		return 1;
	}
	else if(lijn->cel.instructie.adressering == INDIRECT) { //STA (5)
		struct regel *opvang = zoekCel(lijst,decode(lijn->cel.instructie.operand));
		blok->nr = opvang->cel.getal;
		addCel(blok,&lijst);
		return 1;
	}
	else {
		printf("\nOngeldige adressering");
		return -1;
	}


}


int doSTB(struct regel *lijn){
struct regel *blok = (struct regel*) malloc(sizeof(struct regel*));
	blok->type = GETAL;
	blok->volgend = NULL;
	blok->cel.getal = regs.b;
	
	if(lijn->cel.instructie.adressering == DIRECT){ // STB 5
		blok->nr = decode(lijn->cel.instructie.operand);	
		addCel(blok,&lijst);
		return 1;
	}
	else if(lijn->cel.instructie.adressering == INDIRECT) { //STB (5)
		struct regel *opvang = zoekCel(lijst,decode(lijn->cel.instructie.operand));
		blok->nr = opvang->cel.getal;
		addCel(blok,&lijst);
		return 1;
	}
	else {
		printf("\nOngeldige adressering");
		return -1;
	}


}

int doNOP(struct regel *lijn){

	return 1;
}

int doADD(struct regel *lijn){
	zetInA(regs.a+regs.b);
return 1;
}
int doSUB(struct regel *lijn){
	zetInA(regs.a - regs.b);
	return 1;
}
int doMUL(struct regel *lijn){
	zetInA(regs.a * regs.b);
	return 1;
}
int doDIV(struct regel *lijn){

	if(regs.b != 0){
		zetInA(regs.a / regs.b);
		return 1;
	}
	else
		return -1;
}



int doJMP(struct regel *lijn){

	if(decode(lijn->cel.instructie.operand) < 1 || decode(lijn->cel.instructie.operand > telRegels(lijst)){
		printf("\nFoutieve jumpregel");
		return -1;
	}
	else {
		regs.teller = decode(lijn->cel.instructie.operand) -1;
		return 1;
	}
}

int doJSP(struct regel *lijn){

	if(decode(lijn->cel.instructie.operand) < 1 || decode(lijn->cel.instructie.operand > telRegels(lijst)){
		printf("\nFoutieve jumpregel");
		return -1;
	}
	else if(regs.nega == 0 && regs.zero == 0){
		regs.teller = decode(lijn->cel.instructie.operand) -1;
		return 1;
	}
}
int doJSN(struct regel *lijn){

	if(decode(lijn->cel.instructie.operand) < 1 || decode(lijn->cel.instructie.operand > telRegels(lijst)){
		printf("\nFoutieve jumpregel");
		return -1;
	}
	else if(regs.nega == 1 && regs.zero == 0){
		regs.teller = decode(lijn->cel.instructie.operand);
		return 1;
	}
}

int doJIZ(struct regel *lijn){

	if(decode(lijn->cel.instructie.operand) < 1 || decode(lijn->cel.instructie.operand > telRegels(lijst)){
		printf("\nFoutieve jumpregel");
		return -1;
	}
	else if(regs.zero == 1){
		regs.teller = decode(lijn->cel.instructie.operand) -1;
		return 1;
	}
}
int doJOF(struct regel *lijn){

	if(decode(lijn->cel.instructie.operand) < 1 || decode(lijn->cel.instructie.operand > telRegels(lijst)){
		printf("\nFoutieve jumpregel");
		return -1;
	}
	else if(regs.over == 1){
		regs.teller = decode(lijn->cel.instructie.operand) -1;
		return 1;
	}
}

int doHLT(struct regel *lijn){

regs.teller = telCommandoRegels(lijst); // Zet programma teller op laatste regel
}
void addCel(struct regel * toAdd, struct regel **lijst) {
	struct regel *opvang, *doorloop = *lijst;
	if (lijst == NULL)
		;
	else if ((opvang = zoekCel(*lijst,toAdd->nr)) != NULL) { /* De geheugencel "bestond" al en wordt vervangen*/
		toAdd->volgend = opvang->volgend;
		free(opvang); /* We geven de te verwijderen plaats vrij */ 
		opvang = toAdd;
	}
	else { /* de nieuwe geheugencel wordt "gesorteerd" aan de lijst toegevoegd */
		while (doorloop != NULL && doorloop->nr < toAdd->nr) {
			opvang = doorloop;
			doorloop = doorloop->volgend;
		}
		opvang->volgend = toAdd;
		toAdd->volgend = doorloop;
	}
}



int telCommandoRegels(struct regel* lijst){
int i=0;
struct regel* backup = lijst;
while(lijst != NULL){
	if(lijst->type = INSTRUCTIE) // Alleen de commandoregels testen
		i++;
	lijst->volgend;
	}
lijst = backup;
return i;
}
int main(void ){
	
	struct regel *test = (struct regel *)malloc(sizeof(struct regel));
	struct regel *test2 = (struct regel *)malloc(sizeof(struct regel));
	struct regel *test3 = (struct regel *)malloc(sizeof(struct regel));
	struct regel *test4 = (struct regel *)malloc(sizeof(struct regel));

	test->nr = 1;
	test2->nr = 3;
	test3->nr = 10;
	test4->nr = 7;
	test->cel.instructie.adressering = 0;
	test2->cel.instructie.adressering = 1;
	test3->cel.instructie.adressering = 3;
	test4->cel.instructie.adressering = 2;
	test->volgend = NULL;
	test2->volgend = NULL;
	test3->volgend = NULL;
	test4->volgend = NULL;
	lijst = test;
	addCel(test2,&lijst);
	addCel(test3,&lijst);
	addCel(test4,&lijst);
	printLijst(lijst);
	/*
	lijst = NULL;
	verwerkLijn("");
	printLijst(lijst);
	verwerkLijn("LDA 15");
	printLijst(lijst);
	verwerkLijn("STB 10");
	printLijst(lijst);
	printf("\ndone\n");*/
	/*
	printf("%d\n",opvang);
	if ((opvang & 0x80000) == 0x80000) {
		nega = 1;
		opvang = opvang & 0x7FFFFF;
		opvang = opvang -1;
		printf("%d\n",opvang);
		opvang = opvang ^ 0x7FFFFF;
		opvang *= -1;
	}
	printf("%d\n",nega);
	printf("%d",opvang);
	}*/
	while(1);
	return 0;
}