/************************

*************************
****** OBSERVAES ******
*************************
************************/
/*
1. As estrutura de fila, no armazena a prioridade. Toda vez que for armazenar na
FILA DE EXECUTADOS, deve-se concatenar
a prioridade da funo ao nome, conforme no exemplo da Rosseti, e.g. "celso:
0:". Dessa forma mais fcil do que
armazenar em todas as filas esse nmero. Mas essecutar essa tarefa fcil, s t
rabalhar sempre com a prioridade
seja da fila de prioridade, seja da lista de filas de prioridades.

*/
/************************
*************************
********** FIM **********
****** OBSERVAES ******
*************************
************************/

//
//
//
//
//
//
//
//
//
//
//
//
//

/************************
******** FUNES ********
****** estruturas *******
************************/
/*
TNO -> estrutura n da fila
TFila -> fila de estrutura TNO
TFila * cria (void);
int vazia (TFila *f);
void insere (TFila *f, char* owner, char *cmd);
TNO* retira (TFila *f);

void executa_processo (TFila *f, int prioridade, TFila* wow);

void libera(TFila *f);
void imprime (TFila *f);
TLF -> estrutura que armazena as filas de prioridade diferentes de zero
TLF* inicializa_l (void);
TLF* insere_processo_l (TLF *l, char *owner, char *cmd, int priority);
TLF* executa_l (TLF *l, int prioridade, TFila *wow);
void libera_l (TLF *l);

*/
/************************
********** FIM **********
******** FUNES ********
**** fim estruturas *****
************************/

//
//
//
//
//
//
//
//
//
//
//
//
//

/*
/*
/*
/*
/*
/*

//
//
//
//
//
//
//
//
//
//
//

**********************
**********************
**********************
**********************
**********************
**********************

*/
*/
*/
*/
*/
*/

//
//

/************************
****** ESTRUTURAS *******
************************/
//funes de fila
//criando tipo fila
typedef struct no{
char usuario[20];
char codigo[30];
struct no *prox;
}TNO;
typedef struct fila{
TNO *ini, *fim;
}TFila;
//fim da criao tipo fila

/************************
********* FIM ***********
****** ESTRUTURAS *******
************************/
//
/*************************************************************************/
//
/*
/*
/*
/*
/*
/*

**********************
**********************
**********************
**********************
**********************
**********************

*/
*/
*/
*/
*/
*/

//
//
/************************
****** funes Fila *******
************************/
//funo para criar fila

TFila * cria (void){

TFila * f = (TFila*) malloc (sizeof(TFila));
f->ini = NULL;
f->fim = NULL;
return f;
}
//funo para verificar fila vazia
int vazia (TFila *f){
return (!f->fim);
}
//funo para inserir na fila
void insere (TFila *f, char* owner, char *cmd){
TNO* novo = (TNO*) malloc (sizeof(TNO));
strcpy(novo->usuario, owner);
strcpy(novo->codigo, cmd);
novo->prox = NULL;
if (f->fim)
f->fim->prox = novo;
f->fim = novo;
if (!f->ini)
f->ini = novo;
}
//talvez pode dar erro aqui
//funo para retirar da fila
TNO* retira (TFila *f){
if (vazia(f)){
printf("A fila ja esta vazia\n");
return NULL;
}
TNO* resp = (TNO*) malloc (sizeof(TNO));
strcpy(resp->usuario, f->ini->usuario);
strcpy(resp->codigo, f->ini->codigo);
TNO *p = f->ini
f->ini = f->ini->prox;
if (!f->ini)
f->fim = NULL;
free (p);
return resp;
}
//funo para executar um processo da fila de prioridade zero
void executa_processo (TFila *f, TFila *wow){
if(vazia(f)){
printf("No existe processo de tempo real para ser executado\n");
return;
}
else{
TNO* resp = (TNO*) malloc (sizeof(TNO));
resp = retira(f);
/**************************************************
//falta inserir na lista de processos executados
**************************************************/

insere (wow, resp->usuario, resp->codigo);

printf("O processo de codigo %s do usuario %s foi executado\n",
resp->codigo, resp->usuario);
free(resp);
}
}
//funo para imprimir a fila
void imprime (TFila *f){
TFila *aux = cria();
while (!vazia(f)){
TNO * x = retira(f);
printf("O processo do usuario %s de codigo %s foi impresso\n", x
->usuario, x->codigo);
insere(aux, x);
}
printf("\n\n");
while(!vazia(aux)){
x = retira(aux);
insere(f, x->usuario , x->codigo);
}
libera(aux);
free(x);
}

//funo para liberar a fila da memoria

void libera(TFila *f){
TNO *p = f->ini, *q;
while(p){
q = p;
p = p->prox;
free(q);
}
free(f);
}
/************************
********** FIM **********
**** fim funes Fl *****
************************/
//
//
/*************************************************************************/
//
//
//criao da estrutura de lista contendo filas de prioridade
typedef struct lista_filas{
int prioridade;
struct lista_filas * prox;

TFila *processos;
//TFila *processos = cria();
}TLF;
//termino da parte que cria a lista de contem filas de prioridade
//
//
//funes de lista//
/************************
****** funes Lista ******
************************/
//Funo para iniciar lista
TLF* inicializa_l (void){
return NULL;
}
//funo para inserir novos processos
//temos que verificar se j existe um n para a prioridade do processo
//se existir, inserimos no final da fila desse n
//caso no exista, criamos o n da prioridade e inserimos na fila de processos
TLF* insere_processo_l (TLF *l, char *owner, char *cmd, int priority){
//caso a lista de prioridade esteja vazia
if (!l){
TLF* novo = (TLF*) malloc (sizeof(TLF));
novo->prox = NULL;
novo->prioridade = priority;
novo->processos = cria();
insere (novo->processos, owner, cmd);
return novo;
}
//busca se j existe um n para a prioridade
TLF *p = l, *q = NULL;
while((p)&&(p->prioridade <=priority)){
q = p;
p = p->prox;
}
/*if ((p) && (p->prioridade <= priority)){
q = p;
p = p->prox;
}*/
//se entrar aqui, quer dizer que ir ser criado um n no final da lista
//a prioridade a ser criada ser a menos privilegiada
if (!p){
TLF* novo = (TLF*) malloc (sizeof(TLF));
novo->prox = NULL;
novo->prioridade = priority;

novo->processos = cria();
insere (novo->processos, owner, cmd);
q->prox = novo;
return l;
}
//se entrar aqui sinal que no existe a prioridade ainda mas no o fim da fi
la
//ou insere na primeira posicao a prioridade
if ((q->prioridade < priority)||(!q)){
TLF* novo = (TLF*) malloc (sizeof(TLF));
novo->prox = q->prox;
novo->prioridade = priority;
novo->processos = cria();
insere (novo->processos, owner, cmd);
q->prox = novo;
return l;
}
//se entrar aqui sinal que j existe a prioridade
if (q->prioridade == priority){
insere (novo->processos, owner, cmd);
return l;
}
printf("Se exibir isso, deu problema!!!!!!\n");
return l;
}
//falta colocar uma funo para colocar o processo executado na lista de processos e
xecutados
//funo para executar os processos de prioridade diferente de zero (0)
TLF* executa_l (TLF *l, TFila *wow){
if (!l){
printf("No existe processos para serem executados\n UFAAAA!\n");
return l;
}
else{
TNO* process = retira (l->processos);
system(process->codigo);
printf("O processo de codigo %s do usuario %s foi executado\n",
process->codigo, process->usuario);
/*************************************************
//falta codigo aqui para inserir na lista de executados
/*************************************************
//falta inserir na lista de processos executados
*************************************************/
insere (wow, process->usuario, process->codigo);
//rotina para remover o no de prioridade x, caso ele no possua pr
ocessos para serem executados
if (vazia(l->processos)){
TLF *aux = l->prox;

libera(l->processos);
free (l);
l = aux;
}
free(process);
}
return l;
}

/************************
********** FIM **********
**** fim funes Lt *****
************************/

//
//
//
//
//
//
//
//
//
//
//
//
//

/*
/*
/*
/*
/*
/*

**********************
**********************
**********************
**********************
**********************
**********************

*/
*/
*/
*/
*/
*/

/*
/*
/*
/*
/*
/*

**********************
**********************
**********************
**********************
**********************
**********************

*/
*/
*/
*/
*/
*/

/* ********************** */

/*
/*
/*
/*
/*

//
//
//
//
//
//
//
//
//
//
//
//
//

**********************
**********************
**********************
**********************
**********************

*/
*/
*/
*/
*/

MAIN
MAIN
MAIN

int menu (void){

//Criando a tela de menu
int menu;
printf("***************** MENU PRINCIPAL ******************\n");
printf("1- Entrar com um arquivo de processos\n");
printf("2- Executar um processo\n");
printf("3- Imprimir filas com processos pendentes\n");
printf("4- Imprimim os processos executados\n");
printf("0- Sair do programa\n");
printf("***************************************************\n\n");
scanf("%d", &menu);
return menu;
}
/************************
********** MAIN *********
************************/
/*
TNO -> estrutura n da fila
TFila -> fila de estrutura TNO
TFila * cria (void);
int vazia (TFila *f);
void insere (TFila *f, char* owner, char *cmd);
TNO* retira (TFila *f);
TNO* executa_processo (TFila *f, int prioridade, TFila *wow);
void libera(TFila *f);
void imprime (TFila *f);
TLF -> estrutura que armazena as filas de prioridade diferentes de zero
TLF* inicializa_l (void);
TLF* insere_processo_l (TLF *l, char *owner, char *cmd, int priority);
TLF* executa_l (TLF *l, TFila *wow);
void libera_l (TLF *l);
*/

int main (void){

printf("Welcome to process scalability program. \n\tby Barbosa WLO and Q
uinet M.\n\n");
//Criacao de estruturas
TFila * processo_zero = cria();
TFila *executado = cria();
TLF *processo = inicializa_l();
//Chamando a funcao que lista o menu
/******************************************************************/
int choose = menu();
/******************************************************************/
while (choose){
if (choose == 1){
//funcao para ler arquivo de entrada
FILE *f = fopen("entrada.txt", rt);
char linha[81];
char nome[20];
char codigo[50];
char c;
int prioridade;
int i = 0;
while(!feof){
if (feof) break;
fscanf(f, linha);
c = linha[0];
i = 0;
while((c!=\n)||(c!=\0)){
if(c==':') break;
nome[i++] = c;
}
prioridade = (int) linha[i+1];
c = linha[i+3];
i = 0;
while((c!=\n)||(c!=\0)){
if(c==':') break;
codigo[i++] = c;
}
if (prioridade == 0)
insere (processo_zero, nome, comando);
else
processo = insere_processo_l (processo,
nome, comando, prioridade);

}
fclose(f);
//Fim da funcao para ler os processos do arquivo
//Se tudo estiver correto, o arquivo acabou de ler todo
o arquivo e preencher corretamente todas as filas de execuo de acordo com a priori
dade
//Aps as listas estarem preenchidas, vamos retornar ao me
nu, para que o usuario possa escolher uma nova opcao entre executar, imprimir as
listas
}
/*************************************************************/
if (choose == 2){
//Funcao para executar o processo
if(!vazia(processo_zero)
executa_processo(processo_zero, executado);
else
processo executa_l (processo, executado);
//Fim da funcao para executar o processo
}
/***************************************************************
/
if (choose == 3){
//Funcao para ler as filas de processos de todas as prio
ridades
if(vazia(processo_zero))
printf("Nao temos processo de prioridade ZERO pa
ra ser executado\n");
else
imprime(processo_zero);
TLF *p = processo;
while(!p){
printf("Processos de prioridade %d: \n", p->prio
ridade);
imprime(p->processos);
p = p->prox;
}
//Fim da funcao para imprimir as filas de processos
}
/***********************************************************/

if (choose == 4){
//Funcao para imprimir os processo executados
printf("Imprimindo os processos que ja foram executados\
n");
if(vazia(executado))
printf("Ainda nao foi executado nenhum processo"
);
else
imprime(executado);
//Fim da funcao para imprimir os processos executados
}
/**********************************************************/
else{
printf("Codigo invalido\n");
}
choose = menu();
}
return 0;
}

/************************
******* fim MAIN ********
************************/