aled

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>

#include "cpu.h"
#include "asm.h"
#include "systeme.h"

/**********************************************************
** Démarrage du système (création d'un programme)
***********************************************************/

int current_process = -1; /* nu du processus courant  */

PSW system_init(void)
{
    PSW cpu;

    process[++current_process].cpu = cpu;
    process[current_process].state = READY;

    printf("Booting\n");
    /*** création d'un programme ***/

    begin(20);
    /*** créer un thread ***/
    sysc(R1, R1, SYSC_NEW_THREAD); /* créer un thread  */
    if_gt(10);                     /* le père va en 10 */

    /*** code du fils ***/
    set(R3, 1000);          /* R3 = 1000    */
    sysc(R3, 0, SYSC_PUTI); /* afficher R3  */
    nop();
    nop();

    /*** code du père ***/
    label(10);              /* set label 10   */
    set(R3, 2000);          /* R3 = 1000      */
    sysc(R3, 0, SYSC_PUTI); /* afficher R3    */
    sysc(0, 0, SYSC_EXIT);  /* fin du thread  */
    end();

    /*** valeur initiale du PSW ***/
    memset(&cpu, 0, sizeof(cpu));
    cpu.PC = 0;
    cpu.SB = 20;
    cpu.SS = 30;

    return cpu;
}

void wake(){
    int date = time(NULL);
    for(int i = 0 ; i < MAX_PROCESS ; i++){
        if(process[current_process].state == ENDORMI){
            if(process[current_process].date_reveil <= date){
                process[current_process].state = READY;
            }
        }
    }
}

PSW scheduler(PSW m)
{
wake();
    process[current_process].cpu = m;
    /* sauvegarder le processus courant si il existe */
    do
    {
        current_process = (current_process + 1) % MAX_PROCESS;
    } while (process[current_process].state != READY);
    /* relancer ce processus */
    return process[current_process].cpu;
}

PSW sysc_exit(PSW m)
{
    process[current_process].state = EMPTY;
    for (int i = 0; i < MAX_PROCESS; i++)
    {
        if (process[i].state == READY)
        {
            return scheduler(m); //process[i].cpu;
        }
    }

    printf("\nEXIT\n");
    halt();
    exit(EXIT_SUCCESS);
}

int new_thread_number(PSW cpu)
{
    // ça fait un shallow copy automatiquement parce que c'est dans un langage chelou
    for (int i = 0; i < MAX_PROCESS; i++)
    {
        if (process[i].state == EMPTY)
        {
            process[i].cpu = cpu;
            process[i].state = READY;
            return i;
        }
    }
    return -1;
}

PSW new_thread(PSW cpu)
{

    int thread_number = new_thread_number(cpu);
    PSW new_psw = process[thread_number].cpu;
    new_psw.AC = 1;

    return new_psw;
}

PSW sleep(PSW cpu){
    int sleepDuration = cpu.RI.i;
    int sleepTime = time(NULL) + sleepDuration;

    process[current_process].state = ENDORMI;
    process[current_process].date_reveil = sleepTime;

    return scheduler(cpu);
}

/**********************************************************
** Traitement des interruptions par le système (mode système)
***********************************************************/

PSW handle_int_sysc(PSW m, short arg)
{
    switch (arg)
    {
    case SYSC_EXIT:
        return sysc_exit(m);
    case SYSC_PUTI:
        sysc_puti(m);
        break;
    case SYSC_NEW_THREAD:
        return new_thread(m);
    case SYSC_SLEEP:
        return sleep(m);
    }
    return m;
}

PSW process_interrupt(PSW m)
{
    // dump_cpu(m);
    switch (m.IN)
    {
    case INT_TRACE:
        return scheduler(m);
        // dump_cpu(m);
        break;
    case INT_SYSC:
        printf("\ntraitement de l'intéruption INT_SYSC\n");
        return handle_int_sysc(m, m.RI.ARG);
    case INT_KEYBOARD:
        break;
    case INT_SEGV:
        printf("\nviolation mémoire\n");
        exit(EXIT_FAILURE);
    case INT_INST:
        printf("\ninstruction inconnue\n");
        exit(EXIT_FAILURE);
    default:
        printf("\ndefault\n");
        exit(EXIT_FAILURE);
    }
    // printf("\n%d", m.IN);
    return m;
}

void sysc_puti(PSW m)
{
    printf("\n%d\n", m.DR[m.RI.i]);
}