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

*************************
****** 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);

TNO* executa_processo (TFila *f);

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);
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{
TNOZ *ini, *fim;
}TFila;

//fim da criao tipo fila

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

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

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

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

//criao da estrutura de lista contendo filas de prioridade

typedef struct lista_filas{
int prioridade;
struct lista_filas * prox;
TFila *processos;
}TLF;
//termino da parte que cria a lista de contem filas de prioridade
/************************
****** ESTRUTURAS *******
************************/
//
//
//
//
//
//
//
//
//
//
//
//
//

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

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

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

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

/************************
****** funes Fl *******
************************/
//funo para criar fila
TFila * cria (void){
TFila * f = (TFila*) malloc (sizeof(TFila));
f->ini = 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;
}
//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

TNO* executa_processo (TFila *f){
If(vazia(f)){
printf("No existe processo de tempo real para ser executado\n");
return NULL;
}
else{
TNO* resp = (TNO*) malloc (sizeof(TNO));
resp = retira(f);
//falta inserir na lista de processos executados
printf("O processo de codigo %s do usuario %s foi executado\n",
resp->codigo, resp->usuario);
return resp;
}

//funo para imprimir a fila

void imprime (TFila *f){
TFila *aux = cria();
while (!vazia(f)){
TNO * x = retira(f);
printf("O processo de codigo %s do usuario %s foi impresso\n", a
ux->codigo, resp->usuario);
insere(aux, x);
}
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 *****
************************/

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

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

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

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

//funes de lista//
/************************
****** funes Lt *******
************************/

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

//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 = l;
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
if (q->prioridade < priority){
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){
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
//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;
}

//funo para liberar lista

//ainda falta
void libera_l
TLF *
TFila
while

colocar para remover a fila //acho que j foi feito

(TLF *l){
p = l, q;
*f;
(p){
q = p;
p = p->prox;
f = p->processos;
libera(f);
free(q);

}
}

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

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

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

//
//

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

MAIN
MAIN
MAIN

/************************
********** MAIN *********
************************/

int main (void){

printf("Welcome to process scalability program. \n\tby Barbosa WLO and Q
uinet M.\n\n");

return 0;
}

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

******* fim MAIN ********

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