Académique Documents
Professionnel Documents
Culture Documents
*************************
****** 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);
*/
/************************
********** 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;
//
//
//
//
//
//
//
//
//
//
//
//
//
**********************
**********************
**********************
**********************
**********************
**********************
*/
*/
*/
*/
*/
*/
/*
/*
/*
/*
/*
/*
//
//
//
//
//
//
//
//
//
//
//
//
//
**********************
**********************
**********************
**********************
**********************
**********************
*/
*/
*/
*/
*/
*/
/************************
****** 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;
}
/************************
********** FIM **********
**** fim funes Fl *****
************************/
//
//
//
//
//
//
//
//
//
//
//
//
//
/*
/*
/*
/*
/*
/*
**********************
**********************
**********************
**********************
**********************
**********************
//
//
//
//
//
//
//
//
//
//
//
//
//
//funes de lista//
/************************
****** funes Lt *******
************************/
*/
*/
*/
*/
*/
*/
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;
}
}
}
/************************
********** FIM **********
**** fim funes Lt *****
************************/
//
//
//
//
//
//
//
//
//
//
//
//
//
/*
/*
/*
/*
/*
/*
//
//
**********************
**********************
**********************
**********************
**********************
**********************
*/
*/
*/
*/
*/
*/
//
//
//
//
//
//
//
//
//
//
//
/*
/*
/*
/*
/*
/*
**********************
**********************
**********************
**********************
**********************
**********************
*/
*/
*/
*/
*/
*/
**********************
**********************
**********************
**********************
**********************
**********************
*/
*/
*/
*/
*/
*/
//
//
//
//
//
//
//
//
//
//
//
//
//
/*
/*
/*
/*
/*
/*
/*
/*
/*
/*
/*
/*
**********************
**********************
**********************
**********************
**********************
**********************
*/
*/
*/
*/
*/
*/
/*
/*
/*
/*
/*
/*
**********************
**********************
**********************
**********************
**********************
**********************
*/
*/
*/
*/
*/
*/
//
//
//
//
//
//
//
//
//
//
//
//
//
MAIN
MAIN
MAIN
/************************
********** MAIN *********
************************/
return 0;
}
/************************