CodeGen.c

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

#include <ctype.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>

#include "CodeGen.h"
#include "Compiler.h"
#include "Lexer.h"
#include "Liste.h"
#include "Semroutinen.h"
#include "Parser.h"

extern tProc *curProc;
extern size_int* ConstBlock; // Konstantenblock
extern int numElements;  // Zaehler fuer Konstantenindex
extern tLabl* LablList; // Keller für Label -> für jmp
extern tMorph Morph;
extern char* vCode;    // Pointer auf dynamischen Bereich fuer Code
extern char* pCode;    // Pointer auf aktuelle Position
extern short curProcNum;  // Zaehler fuer Prozeduren
extern int LenCode;  // Laenge des Codeausgabebereiches
extern FILE* pOFile;

void wr2ByteToCode(short x){ // Codebefehl in globaler Codeausgabepuffer schreiben
    *pCode++ = (unsigned char)(x & 0xff); // LSB
    *pCode++ = (unsigned char)(x >> 8); // MSB
}

void wr2ByteToCodeAtP(short x, char* pD){ // Codebefehl in übergebenen Codeausgabepuffer schreiben
    *pD = (unsigned char)(x & 0xff); // LSB
    *(pD + 1) = (unsigned char)(x >> 8); // MSB
}

int Code(tCode Code, ...){ // schreibe Befehl mit 1-3 Paramtern in Codeausgabepuffer
    va_list ap;
    short sarg;
    if (pCode - vCode + MAX_LEN_OF_CODE >= LenCode){ // Ueberwachung des Zwischencodegenerierungspuffers, wenn nötig vergrößern
        char* xCode = realloc(vCode, (LenCode += 1024));
        if (xCode == NULL){
            printf("Kein Speicher!\n");
        }
    pCode = xCode + (pCode - vCode);
    vCode = xCode;
    }
    *pCode++ = (char)Code;
    va_start(ap, Code); // Initialisierung der var. Arg liste ab Code in ap

    // Argumente hinzufügen
    switch (Code){
        // Befehle mit 3 Parametern
        case entryProc:
        sarg = va_arg(ap,int); // nächstes Argument aus Liste, Typ dahinter
        wr2ByteToCode(sarg);
        // Befehle mit 2 Parametern
        case puValVrGlob:
        case puAdrVrGlob:
        sarg = va_arg(ap,int); // nächstes Argument aus Liste, Typ dahinter
        wr2ByteToCode(sarg);
        // Befehle mit 1 Parameter
        case puValVrMain:
        case puAdrVrMain:
        case puValVrLocl:
        case puAdrVrLocl:
        case puConst:
        case jmp :
        case jnot:
        case call:
        sarg = va_arg(ap,int); // nächstes Argument aus Liste, Typ dahinter
        wr2ByteToCode(sarg);
        break;
        // ohne Parameter
        default: break;
    }
    va_end(ap); // Argumentlistenverarbeitung beenden
    return 0;
}

// CodePuffer in Ausgabedatei schreiben
int CodeOut(void){
    // Codelänge ausrechnen und in EntryProc nachtragen
    unsigned short Len = (unsigned short)(pCode - vCode);
    DEBUG_PRINT("Codelen: %d\n", Len);
    wr2ByteToCodeAtP((short)Len,vCode+1);
    wr2ByteToCodeAtP((short)curProc->SpzzVar,vCode+5);
    if (Len == fwrite(vCode,sizeof(char),Len,pOFile)){
        return 0;
    }
    else{
        return 1;
    }
}

// Öffnen/Schließen des Codeausgabefiles
int openOFile(char* argName){
    long i = 0L;
    char vName[128+1];

    strcpy(vName,argName);
    if (strstr(vName,".pl0") == NULL){ // ohne Dateiänderung
      strcat(vName,".cl0");
    }
    else {
        *(strchr(vName,'.')+1) = 'c'; // pl0 in cl0 ändern
    }

    if ((pOFile = fopen(vName,"wb")) != NULL){
        fwrite(&i,sizeof(int32_t),1,pOFile);
        return 0;
    }
    else{
        return 1;
    }

}

void writeLittleEndian(char* buffer, unsigned long long value) {
    for (int i = 0; i < VARSIZE; i++) {
        buffer[i] = (unsigned char)(value & 0xFF); // extrahiere das niederwertigste Byte
        value = value >> 8; // um 1 Byte rechts verschieben = nächstes niederwertigste Byte
    }
}

int closeOFile(void){
    char vBuf3[VARSIZE];
    // Constblock am Ende schreiben
    for (int i = 0; i < numElements; i++){
        writeLittleEndian(vBuf3, ConstBlock[i]);
        //wr2ByteToCodeAtP(ConstBlock[i], vBuf3);
        if (fwrite(vBuf3, VARSIZE, 1, pOFile) == 1){
            #ifdef DEBUG
		    #if (VARSIZE == 8)
            DEBUG_PRINT("Constblock[%d] = %ld erfolgreich geschrieben!\n", i, ConstBlock[i]);
		    #else
		    DEBUG_PRINT("Constblock[%d] = %d erfolgreich geschrieben!\n", i, ConstBlock[i]);
		    #endif
		    #endif
        }
        else{
            return 1;
        }
    }

    // Anzahl von Prozeduren am Anfang schreiben
    char vBuf2[2];
    fseek(pOFile,0,SEEK_SET);
    wr2ByteToCodeAtP(curProcNum + 1,vBuf2);
    if (fwrite(vBuf2, 2, 1, pOFile) == 1){
        DEBUG_PRINT("Anzahl Prozeduren erfolgreich geschrieben!\n");
    }
    else{
        return 1;
    }

    // Variablengröße dahinterschreiben
    wr2ByteToCodeAtP((short)VARSIZE, vBuf2);
    if (fwrite(vBuf2, 2, 1, pOFile) == 1){
        DEBUG_PRINT("Variablengröße erfolgreich geschrieben!\n");
    }
    else{
        return 1;
    }
    return 0;
}