Miscellany

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

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);
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 verwerkLijn(char * commando);




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;
};


struct regel *lijst;


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) {
	int gevonden = 0;
	while (lijst != NULL) {
		if (lijst->nr == nummer) {
			return lijst;
			gevonden = 1;
		}
		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(lijst->type == 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,"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 lijst*) malloc (sizeof(struct lijst*));
		blok->type = GETAL;
		blok->volgend = NULL;
		if(lijn->cel.instructie.adressering == 0){ // onmiddelijk LDA #5
			blok->cel.getal = decode(lijn->cel.instructie.operand);
			regs.a = decode(lijn->cel.instructie.operand);
			return 1;
		}
		else if(lijn->cel.instructie.adressering == 1){// direct adresering  vb( LDA 5)
			struct regel* opvang = zoekCel(lijst,decode(lijn->cel.instructie.operand));
			regs.a = opvang->cel.getal;
		}
		else if(lijn->cel.instructie.adressering == 2){ // LDA (500)
		
			struct regel *opvang = zoekCel(lijst,decode(lijn->cel.instructie.operand));		
			opvang = zoekCel(lijst,decode(opvang->cel.instructie.operand));
			regs.a = opvang->cel.getal;
		}
		else
			printf("\nOngeldige adressering...")
			

}

int doLDB(struct regel *lijn){

		struct regel* blok = (struct lijst*) malloc (sizeof(struct lijst*));
		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;
		}
		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;
		}
		else
			printf("\nOngeldige adressering...")
			

}
int main(void ){
	char * testje;

	lijst = NULL;
	verwerkLijn("INP        ");
	printLijst(lijst);
	verwerkLijn("STA (501)");
	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;
}