Liste.c

// Liste.c
// Name: Eric Hübel, Mat.Nr: 54045, S-Nr: 86462, Gruppe: 041-62

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include "Compiler.h"
#include "Liste.h"
#include "Semroutinen.h"
#include "Lexer.h"
#include "Parser.h"

// globale Variablen
extern tBezEntry* List;
extern short curProcNum;
extern tProc* curProc;

extern size_int* ConstBlock;
extern int numElements;

extern tLabl* LablList; // Keller für Label -> für jmp

// globale Suche: gesamte Liste durchsuchen
// lokale  Suche: gesamte Liste durchsuchen der aktuellen Prozedurnummer -> nur pLocalBez durchsuchen

// ===================== Konstantenblock ====================

void initConst(){
    ConstBlock = NULL; // Start ohne Speicher
    numElements = 0;
}

void addConst(size_int val){
    numElements++;
    size_int* newBlock = realloc(ConstBlock, sizeof(size_int) * (numElements));
	if (newBlock == NULL){
		printf("Konnte Speicher nicht reallokieren!\n");
		exit(1);
	}
    ConstBlock = newBlock;

    ConstBlock[numElements-1] = val; // -1, da Start bei 0
}

int searchConst(size_int val){
    int index = 0;
    while (index < numElements){
        //DEBUG_PRINT("Index: %d\n", index);
        if (ConstBlock[index] == (size_int) val){
			#ifdef DEBUG
			#if (VARSIZE == 8)
            DEBUG_PRINT("Gefunden: %ld\n", ConstBlock[index]);
			#else
			DEBUG_PRINT("Gefunden: %d\n", ConstBlock[index]);
			#endif
			#endif

            return index;
        }
		index++;
    }
    DEBUG_PRINT("Nichts gefunden!\n");
    return -1;
}

void PrintConstBlock(){
	for (int i = 0; i < numElements; i++) {
		#ifdef DEBUG
		#if (VARSIZE == 8)
        DEBUG_PRINT("ConstBlock[%d] = %ld\n", i, ConstBlock[i]);
		#else
		DEBUG_PRINT("ConstBlock[%d] = %d\n", i, ConstBlock[i]);
		#endif
		#endif
        
    }
}

void deleteConstBlock(){
    free(ConstBlock);
    numElements = 0;
}

// ============================= Liste =======================

tBezEntry* append(tBezEntry* head, tKz Kz, short indexProc, void* pObj, char* pName) {
	tBezEntry* newEntry = (tBezEntry*)malloc(sizeof(tBezEntry)); // Speicher für neuen Listeneintrag allokieren

	if (newEntry == NULL) { // Speicherallokierung erfolgreich?
		printf("Konnte Speicher nicht allokieren!\n");
		exit(1);
	}

	// Daten in neuen Eintrag kopieren
	newEntry->indexProc = indexProc;
	newEntry->Kz = Kz;
	newEntry->pObj = (void*) pObj;
	char* newName = malloc(strlen(pName)+1);
	if (newName == NULL) {
		printf("Konnte Speicher nicht allokieren!\n");
		exit(1);
	}
	strcpy(newName, pName);
	newEntry->pName = newName;

	newEntry->next = NULL; // nächsten Eintrag auf NULL setzen, da Ende der Liste


	// Überprüfen, ob die Liste leer ist
	if (head == NULL) {
		head = newEntry;
		// Liste leer -> neuer Eintrag wird der erste Eintrag und damit der Kopf
		return head;
	}
	// Liste nicht leer -> füge am Ende hinzu
	tBezEntry* current = head; // starten am Anfang/Kopf
	int index = 1;
	while (current->next != NULL) { // vorhangeln in der Liste (current: aktueller Eintrag)
		current = (tBezEntry*)current->next;
		index++;
	}
	current->next = (struct tBezEntry*)newEntry;
	return head; // Rückgabe des ursprünglichen Kopfes der Liste
}

tBezEntry* getFirst(void){
	// Namensliste von akt. Prozedur bekommen
	return curProc->pLocalBez;
}

tBezEntry* getNext(tBezEntry* current){
	return (tBezEntry*)current->next;
}

tBezEntry* getLast(void){
	tBezEntry* current = curProc->pLocalBez; // mit Kopf starten der Namensliste akt. Proz
	tBezEntry* prev = NULL;
	while(current != NULL){
		prev = (tBezEntry*)current;
		current = (tBezEntry*)current->next;
	}
	return prev;
}

tBezEntry* deleteLast(tBezEntry* head) {
	if (head == NULL) {
		DEBUG_PRINT("Liste leer\n");
		return head;
	}
	tBezEntry* current = head; // starten am Anfang/Kopf
	tBezEntry* PrevEntry = head;

	
	int iter = 0;
	while (1) { // durch Liste hangeln
		iter++;
		if (current->next == NULL) { // letztes Entry gefunden
			PrevEntry->next = NULL; // Zeiger zum letzten Entry bei vorh. Entry entfernen
			
			free(current->pName); // Pointer auf Name löschen
			free(current->pObj); // Pointer auf Objekt löschen
			free(current); // letztes Entry löschen
			
			break; // Ende Schleife
		}
		PrevEntry = current; // vorheriges ListenEntry speichern
		current = (tBezEntry*)current->next; // nächstes ListenEntry setzen
	}

	if (iter == 1) { //bei einer Iteration wurde also nur 1 Index gefunden, also leere Liste setzen
		head = NULL;
	}

	return head;
}

tBezEntry* deleteFirst(tBezEntry* head) {
	if (head == NULL) {
		DEBUG_PRINT("Liste leer\n");
		return head;
	}
	tBezEntry* newFirst = (tBezEntry*)head->next;

	free(head->pName); // Pointer auf Name löschen
	free(head->pObj); // Pointer auf Objekt löschen
	free(head); // letztes Entry löschen

	return newFirst;
}

void PrintProc(tProc* pProc){
	//tProc* pProc = (tProc*)current->pObj;
	DEBUG_PRINT("=PRC= KZ: %d | IdxProc: %u | SpzzVar: %d\n", pProc->Kz, pProc->IndexProc, pProc->SpzzVar);
}

void PrintList(tBezEntry* head) {
	if (head == NULL) {
		DEBUG_PRINT("Liste leer!\n");
		return;
	}

	int index = 0;
	tBezEntry* current = head;

	while (current != NULL) { // vorhangeln durch die Liste bis zum letzten Entry und ausgeben
		index++;
		DEBUG_PRINT("Idx: %d | KZ: %d | idxProc: %u | pName: %s || ", index, current->Kz, current->indexProc, current->pName);

		// je nach Obj richtig Infos printen
		if (current->Kz == BEZ){
			DEBUG_PRINT("=BEZ= Bez. ohne Objektbeschreibung!\n");
		}
		else if (current->Kz == PRC){
			tProc* pProc = (tProc*)current->pObj;
			DEBUG_PRINT("=PRC= KZ: %d | IdxProc: %u | SpzzVar: %d\n", pProc->Kz, pProc->IndexProc, pProc->SpzzVar);
		}
		else if (current->Kz == CST){
			tConst* pConst = (tConst*)current->pObj;
			DEBUG_PRINT("=CST= KZ: %d | Val: %d | Idx: %d\n", pConst->Kz, pConst->Val, pConst->Idx);
		}
		else if (current->Kz == VAR){
			tVar* pVar = (tVar*)current->pObj;
			DEBUG_PRINT("=VAR= KZ: %d | Dspl: %d\n", pVar->Kz, pVar->Dspl);
		}

		current = (tBezEntry*)current->next;
	}
}

tBezEntry* ClearList(tBezEntry* head){
	// ganze Liste löschen
	tBezEntry* current = head;
	if (head == NULL){
		DEBUG_PRINT("Liste leer!\n");
		return head;
	}
	
	//PrintList(head);
	do {
		current = getNext(head);

		head = deleteFirst(head);
		//head = deleteLast(head);
		//PrintList(head);
	}while (current != NULL);


	return head;
}

// =============== Listeneinträge + Suchfkt. =======================

tBezEntry* createBezEntry(char* pBez){
	// Namensliste von akt. Prozedur bekommen
	List = curProc->pLocalBez;

	// neuer Listeneintrag, noch keine Objektbeschr.
	curProc->pLocalBez = append(List, BEZ, curProcNum, NULL, pBez);
	tBezEntry* LastEntry = getLast(); // letzter Eintrag ist neuer Eintrag
	return LastEntry;
}

tProc* createMainProc(){
	tProc* mainProc = createProc(NULL);
	DEBUG_PRINT("Prozedur %d erstellt:\n", mainProc->IndexProc);
	PrintProc(mainProc);
	return mainProc;
}

tProc* createProc(tProc* pParent){
	// Prozedurenobjekt erstellen
	tProc* newProc = (tProc*)malloc(sizeof(tProc));
	if (newProc == NULL) {
		printf("Konnte Speicher nicht allokieren!\n");
		exit(1);
	}

	newProc->Kz = PRC;
	curProcNum++;
	newProc->IndexProc = curProcNum;  // Prozedurnummer erhöhen
	newProc->SpzzVar = 0; // wird immer um VarSize erhöht
	newProc->pLocalBez = NULL; // unsere lokale Namensliste
	newProc->pParent = pParent;

	return newProc;
}

tVar* createVar(void){
	// Variablenobjekt erstellen
	tVar* newVar = (tVar*)malloc(sizeof(tVar));
	if (newVar == NULL) {
		printf("Konnte Speicher nicht allokieren!\n");
		exit(1);
	}

	newVar->Kz = VAR;

	// Berechnung des Displacements
	// aktuellen Speicherzuordnungszähler aus akt. Prozedurbeschreibung bekommen + (Var.größe dazuaddieren)

	newVar->Dspl = curProc->SpzzVar; // auf das letzte setzen
	// Speicherzuordnungszähler in curProc erhöhen
	curProc->SpzzVar = curProc->SpzzVar + VARSIZE;

	return newVar;
}

tConst* createConst(size_int Val){
	// Konstantenobjekt erstellen
	tConst* newConst = (tConst*)malloc(sizeof(tConst));
	if (newConst == NULL) {
		printf("Konnte Speicher nicht allokieren!\n");
		exit(1);
	}

	newConst->Kz = CST;
	newConst->Idx = 0; // Initialwert später richtig setzen
	newConst->Val = Val;
	return newConst;
}

tBezEntry* addVarPObj(tBezEntry* pBezEntry, tVar* pVar){
	//tVar* addVar = (tVar*)pBezEntry->pObj;
	pBezEntry->Kz = VAR;
	pBezEntry->pObj = pVar;
	return pBezEntry;

}

tBezEntry* addConstPObj(tBezEntry* pBezEntry, tConst* pConst){
	pBezEntry->Kz = CST;
	pBezEntry->pObj = pConst;
	return pBezEntry;
}

tBezEntry* addProcPObj(tBezEntry* pBezEntry, tProc* pProc){
	pBezEntry->Kz = PRC;
	pBezEntry->pObj = pProc;
	return pBezEntry;
}


// lokale Suche nach Bezeichnernamen
tBezEntry* searchBez(tProc* pProc, char* pBez){
	tBezEntry* current = pProc->pLocalBez;
	while (current != NULL){
		if (strcmp(current->pName, pBez) == 0){
			DEBUG_PRINT("Gefunden: %s\n", current->pName);
			return current; // was gefunden!!
		}
			current = getNext(current);
	}
	DEBUG_PRINT("Nichts gefunden!\n");
	return NULL; // nichts gefunden
}

// globale Suche nach Bezeichnernamen
tBezEntry* searchBezGlobal(char* pBez){
	tProc* currentProc = curProc; // bei akt. Proc starten

	while (1){
		//DEBUG_PRINT("PROC: %d\n", currentProc->IndexProc);
		// Namensliste von currentProc bekommen
		tBezEntry* current = (tBezEntry*)currentProc->pLocalBez;

		while (current != NULL){
			if (strcmp(current->pName, pBez) == 0){
				DEBUG_PRINT("Gefunden: %s\n", current->pName);
				return current; // was gefunden!!
			}
				//current = getNext(current);
				current = (tBezEntry*)current->next;
		}
		// Abbruch
		if (currentProc->pParent == NULL){
			DEBUG_PRINT("Abbruch bei Proc: %d\n", currentProc->IndexProc);
			break;
		}
		currentProc = currentProc->pParent;
	}

	DEBUG_PRINT("Nichts gefunden!\n");
	return NULL; // nichts gefunden
}

// ============= Labelliste ============
tLabl* pushLabl(tLabl* head, tKz Kz, short iJmp) {
	tLabl* newEntry = (tLabl*)malloc(sizeof(tLabl)); // Speicher für neuen Listeneintrag allokieren

	if (newEntry == NULL) { // Speicherallokierung erfolgreich?
		printf("Konnte Speicher nicht allokieren!\n");
		exit(1);
	}

	// Daten in neuen Eintrag kopieren
	newEntry->Kz = Kz;
	newEntry->iJmp = iJmp;
    newEntry->next = (struct tLabl*)head; // letzter erster Eintrag wird nächster

	return newEntry; // Rückgabe des neuen Kopfes
}

tLabl* getTopLabl(void){
	return LablList;
}

tLabl* getNextLabl(tLabl* current){
	return (tLabl*)current->next;
}

tLabl* PopLabl(tLabl* head) {
	if (head == NULL) {
		DEBUG_PRINT("Labelliste leer\n");
		return head;
	}
    tLabl* newHead = (tLabl*)head->next;
    free(head);

	return newHead;
}

void PrintLablList(tLabl* head){
    if (head == NULL) {
		DEBUG_PRINT("Labelliste leer!\n");
        return;
	}

    tLabl* current = head;
    int index = 0;
    while (current != NULL){
        index++;
        DEBUG_PRINT("Index: %d | Kz: %d | iJmp: %d\n", index, current->Kz, current->iJmp);
        current = (tLabl*)current->next;
    }
}