#include <stdio.

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

#define MAX_PROCESS 10

typedef struct DescProc {

char estado_atual;
int prioridade;
unsigned inicio_memoria;
unsigned tamanho_memoria;
unsigned tempo_cpu;
unsigned proc_pc;
unsigned proc_sp;
unsigned proc_acc;
unsigned proc_rx;
struct DescProc *proximo;
} DescProc;

typedef struct DescProcLista {

DescProc* primeiro;
DescProc* ultimo;
} DescProcLista;

void cria_processo();
void define_info(DescProc* processo);

DescProc tab_desc[MAX_PROCESS];
DescProcLista desc_livre;
DescProcLista espera_cpu;
DescProcLista usando_cpu;
DescProcLista bloqueados;

int main() {
int i;

srand(time(NULL)); // Initialize random number generator

for(i = 0; i < MAX_PROCESS - 1; i++)

tab_desc[i].proximo = &tab_desc[i + 1];

tab_desc[i].proximo = NULL;
desc_livre.primeiro = &tab_desc[0];
desc_livre.ultimo = &tab_desc[MAX_PROCESS - 1];

espera_cpu.primeiro = NULL;
espera_cpu.ultimo = NULL;
usando_cpu.primeiro = NULL;
usando_cpu.ultimo = NULL;
bloqueados.primeiro = NULL;
bloqueados.ultimo = NULL;

for (i = 0; i < 10; i++) {

printf("Criando o processo %d...\n", i + 1);
cria_processo();
}

printf("Done!\n");
return 0;
}

void cria_processo() {
if (desc_livre.primeiro == NULL) {
printf("Não há mais descritores disponíveis.\n");
return;
}

DescProc* processo = desc_livre.primeiro;

printf("Definindo informacoes do processo (PCB)\n");
desc_livre.primeiro = desc_livre.primeiro->proximo;

define_info(processo);
printf("Atualizando a fila desc_livre... O processo em execucao esta usando um
dos descritores.\n");
printf("Processo criado... migramos ele para a fila espera_cpu.\n");
if(espera_cpu.primeiro == NULL) {
espera_cpu.primeiro = espera_cpu.ultimo = processo;
} else {
espera_cpu.ultimo->proximo = processo;
espera_cpu.ultimo = processo;
processo->proximo = NULL;
}

printf("Processo criado:\n");
printf("Estado: %c\n", processo->estado_atual);
printf("Prioridade: %d\n", processo->prioridade);
printf("Inicio de Memória: %u\n", processo->inicio_memoria);
printf("Tamanho de Memória: %u\n", processo->tamanho_memoria);
printf("Tempo de CPU: %u\n", processo->tempo_cpu);
printf("PC: %u\n", processo->proc_pc);
printf("SP: %u\n", processo->proc_sp);
printf("ACC: %u\n", processo->proc_acc);
printf("RX: %u\n", processo->proc_rx);
printf("\n");
}

void define_info(DescProc* processo) {

processo->estado_atual = 'N'; // Novo processo
processo->prioridade = rand() % 10; // Prioridade aleatória de 0 a 9
processo->inicio_memoria = rand() % 1024; // Início de memória aleatório
processo->tamanho_memoria = 64 + rand() % 4096; // Tamanho de memória aleatório
entre 64 e 4159
processo->tempo_cpu = rand() % 1000; // Tempo de CPU aleatório
processo->proc_pc = rand() % 65536; // Program Counter aleatório
processo->proc_sp = rand() % 1024; // Stack Pointer aleatório
processo->proc_acc = rand() % 256; // Accumulator aleatório
processo->proc_rx = rand() % 256; // Register X aleatório
}