void ST1countdiffer(int *palavrasTotais, int* palavrasDistintas, int *tokensDistintos)
{
int i = 0, j = 0, pD = 0, pT = 0 ;
Item *ordem = mallocSafe(N*sizeof(*ordem));
Key p;
sentence *s;
for(i = 0; i < M; i++)
if(st[i] != NULLitem){
ordem[j] = mallocSafe(sizeof(*(ordem[j])));
ordem[j] = st[i];
if( isLetter(ordem[j]->literal[0] ))
for(s = ordem[j]->occurencies; s != NULL; s = s->next)pT++;
j++;
}
mergeSort(ordem, 0, N);
p = ordem[0]->literal;
if( isLetter(p[0]) )
pD++;
for(j = 1; j < N; j++){
if(!eq(p, ordem[j]->lema)){
p = ordem[j]->lema;
if(isLetter(p[0]))
for(s = ordem[j]->occurencies; s != NULL; s = s->next) pD++;
}
}
*palavrasDistintas = pD;
*palavrasTotais = pT;
*tokensDistintos = ST1count()+1;
free(ordem);
}
Nave* newNave(float rEsfera, float posX, float posY, float posZ,
float velocity, float dirX, float dirY, float dirZ,
float life, float shield_energy, float weapon_damage, float weapon_rate)
{
Nave* nave = mallocSafe(sizeof(Nave));
nave->rEsfera = rEsfera;
nave->pos[X] = posX;
nave->pos[Y] = posY;
nave->pos[Z] = posZ;
nave->vel = velocity;
nave->dir[X] = dirX;
nave->dir[Y] = dirY;
nave->dir[Z] = dirZ;
nave->life = life;
nave->shield_energy = shield_energy;
nave->weapon_damage = weapon_damage;
nave->weapon_rate = weapon_rate;
nave->ultimoTiro = 0;
nave->atira = FALSE;
nave->shield_active = FALSE;
nave->isDead = FALSE;
return nave;
}
int juntaPixels(Imagem *img, int x, int y, float corNova, CelPixel *cabeca)
/* A função juntaPixels recebe uma imagem e 2 posições. Captura re-
cursivamente todas as células com COR_FUNDO e as pinta com corNova.
Armazena a posição desse pixel numa lista encadeada iniciada por
'cabeça'. Retorna o total de pixels da região. */
{
/** ALOCAÇÃO DE VARIÁVEIS *****************************************/
int r; /*contador*/
CelPixel *nova;
/** BASE DA RECURSÃO **********************************************/
if(getPixel(img, x, y) == corNova) return 0;
if(getPixel(img, x, y) == COR_BORDA) return 0;
/** AÇÕES *********************************************************/
nova = mallocSafe(sizeof(CelPixel));
setPixel(img, x, y, corNova);
nova->x = x;
nova->y = y;
nova->prox = cabeca->prox;
cabeca->prox = nova;
r=1; /* Conta a chamada recursiva atual para o total */
/** NOVAS CHAMADAS RECURSIVAS *************************************/
r += juntaPixels(img, x+1, y, corNova, nova); /* direita */
r += juntaPixels(img, x, y+1, corNova, nova); /* baixo */
r += juntaPixels(img, x-1, y, corNova, nova); /* esquerda */
r += juntaPixels(img, x, y-1, corNova, nova); /* cima */
return r;
}
/*Cria novo nó da tabela*/
static link NEW(Item_lema item, link next)
{
link x = mallocSafe(sizeof *x);
x->item = item;
x->next = next;
return x;
}
void ST1insert(Item item)
{ Key v = key(item);
int i = hash(v, M), j = 0;
while (!null(i)){
if( eq(st[i]->literal, item->literal) ){
item->occurencies->next = st[i]->occurencies;
st[i]->occurencies = item->occurencies;
return;
}
i = (i+1) % M;
}
st[i] = item;
N++;
if(N >= M/2){ /*resize dinamico*/
Item *aux;
int oldsize = M;
M = prime_m(2*M);
aux = mallocSafe(M*sizeof(Item));
for(i = 0; i < M; i++) aux[i] = NULLitem;
for(i = 0; i < oldsize; i++){
if(st[i] != NULLitem){
Key v = key(st[i]);
j = hash(v, M);
while( aux[j] != NULLitem ) j = (j+1)%M;
aux[j] = st[i];
}
}
free(st);
st = aux;
}
}
/*
------------------------------------------------------------------------
Funcao removeFilme
Questiona o usuario sobre as caracteristicas do filme. Procura se
ele existe e, em caso negativo, o adiciona ao fim da lista.
*/
void removeFilme(Lista *lista)
{
/** VARIÁVEIS *****************************************************/
Filme *aux; /* Auxiliar para percorrer a lista */
char *nome_procurado; /* Filme buscado pelo usuário */
char *caracterAtual; /* Auxiliar para contar 'tNome' */
char opcao[3]; /* Identifica o filme encontrado */
int tNome; /* Auxiliar para tamanho do nome da
função auxiliar 'achaPalavra' */
nome_procurado = (char *) mallocSafe((TAMNOME+1)*sizeof(char));
aux = lista->ini;
/** INFORMAÇÕES DO FILME PROCURADO ********************************/
printf("Digite parte do nome a ser procurado: ");
leString(nome_procurado, TAMNOME+1);
for(caracterAtual = nome_procurado, tNome = 0;
*caracterAtual != '\0'; tNome++, caracterAtual++);
/** LISTA VAZIA ***************************************************/
if(lista->ini == NULL)
{
printf("A lista esta vazia!");
return;
}
/** BUSCA DO FILME ************************************************/
for(aux = lista->ini; aux != lista->fim->prox; aux = aux->prox)
{
if(achaPalavra((unsigned char *) nome_procurado, tNome,
(unsigned char *) aux->nome, TAMNOME) == TRUE)
{
mostraUmFilme(aux);
printf("Esse eh o filme procurado? [s/n] ");
leString(opcao, 3);
if(!strcmp(opcao, "s"))
{
if(aux->prox != NULL)
aux->prox->ant = aux->ant;
else lista->fim = aux->ant;
if(aux->ant != NULL)
aux->ant->prox = aux->prox;
else lista->ini = aux->prox;
free(nome_procurado); free(aux);
nome_procurado = NULL; aux = NULL;
return;
}
}
}
if(aux == lista->fim->prox)
printf("\n\nFilme nao encontrado\n");
/** LIBERAÇÃO DE MEMÓRIA ******************************************/
free(nome_procurado); nome_procurado = NULL; aux = NULL;
}
void insertItem(Link head, double altura) {
Link novo = (Link) mallocSafe(sizeof(Node));
novo->altura = altura;
novo->next = head->next;
head->next = novo;
head->total++;
}
/*Inicia tabela com M primo pequeno e arbitrrio*/
void st_lema_init()
{
int i;
N = 0;
M = 1021;
st_lema = mallocSafe(M*sizeof(Item_lema));
for (i = 0; i < M; i++) st_lema[i] = NULLitem_lema;
}
/*Inicia tabela com M primo pequeno e arbitrrio*/
void st_lema_init()
{
int i;
N = 0;
M = 1021;
heads = mallocSafe(M*sizeof(link));
z = NEW(NULLitem_lema, NULL);
for (i = 0; i < M; i++) heads[i] = z;
}
/*
------------------------------------------------------------------------
Funcao adicionaFilme
Questiona o usuario sobre as caracteristicas do filme. Procura se
ele existe e, em caso negativo, o adiciona ao fim da lista.
*/
void adicionaFilme(Lista *lista)
{
/** VARIÁVEIS *****************************************************/
Filme *novo; /* Apontador para o novo filme que será criado */
char *nome; char *dist; int votos; float nota; int ano;
nome = (char *) mallocSafe(sizeof(TAMNOME+1));
dist = (char *) mallocSafe(11*sizeof(char));
/** INFORMAÇÕES DO FILME ******************************************/
printf("Digite o nome do filme: ");
leString(nome, TAMNOME+1);
printf("Digite o ano: ");
scanf("%d", &ano);
printf("Digite a nota: ");
scanf("%f", ¬a);
printf("Digite o numero de votos: ");
scanf("%d", &votos);
printf("Digite a distribuicao: ");
leString(dist, 11);
/** INSERÇÃO ******************************************************/
novo = criaFilme(dist, votos, nota, nome, ano);
/* Filmes repetidos não são inseridos */
if(achaFilme(lista, novo) == TRUE)
{
free(novo); novo = NULL;
return;
}
/* Coloca o filme não-listado no final */
insereFilme(lista, novo);
mostraUmFilme(novo);
/** LIBERAÇÃO DE VARIÁVEIS ****************************************/
nome = NULL; dist = NULL; novo = NULL;
}
Lista *criaLista()
{
Lista *lista;
lista = mallocSafe(sizeof(Lista));
lista->ini = NULL;
lista->fim = NULL;
return lista;
}
/*Executa a função visit em cada item, sendo que eles estão ordenados*/
void st_lema_sort(void (*visit)(Item_lema))
{
int i, j;
Item_lema *v = mallocSafe(N*sizeof(Item_lema));
for (j = 0, i = 0; i < M; i++)
if (!null(i)) v[j++] = st_lema[i];
qsort(v, N, sizeof(Item_lema), lema_cmp);
for(i = 0; i < N; i++)
visit(v[i]);
free(v);
}
void ST1sort(int mod){
Item* ordem = mallocSafe(N*sizeof(*ordem));
Key p;
int i = 0, j = 0;
for(i = 0; i < M; i++)
if(st[i] != NULLitem){
ordem[j] = mallocSafe(sizeof(*(ordem[j])));
ordem[j++] = st[i];
}
mergeSort(ordem, 0, N);
if(mod == ALL){
p = ordem[0]->literal;
puts(p);
for(j = 1; j < N; j++){
if(!eq(p, ordem[j]->literal)){
p = ordem[j]->literal;
puts(p);
}
}
}
if(mod == WORDS){
p = ordem[0]->literal;
if( isLetter(p[0]) )
puts(p);
for(j = 1; j < N; j++){
if(!eq(p, ordem[j]->literal)){
p = ordem[j]->literal;
if(isLetter(p[0]))
puts(p);
}
}
}
free(ordem);
}
void mochilaAdd(Item item, int quant)
{
Mochila *aux;
aux = mochilaFind(item.indice);
/* Caso item não esteja no inventário, criamos ele */
if (aux == NULL) {
Mochila *novo = mallocSafe(sizeof (Item));
novo->quant = 0;
fim->prox = novo;
aux = fim = novo;
}
aux->quant += quant;
}
/*
----------------------------------------------------------------------
Funcao quickSort(Lista *l)
Ordena a lista em ordem decrescente de nota utilizando o
algoritmo Quicksort adaptado para listas encadeadas.
*/
void quickSort(Lista *lista)
{
/** VARIÁVEIS *****************************************************/
Lista *esquerda; /* Lista para os elementos maiores que 'i' */
Lista *direita; /* Lista para os elementos menores que 'i' */
Filme *ini; /* Apontador para primeiro filme da lista */
Filme *fim; /* Apontador para o último filme da lista */
Filme *i; /* Filme com nota pivô para as sublistas
devolvido pelo algoritmo de separação */
ini = lista->ini; fim = lista->fim;
/** BASE DA RECURSÃO **********************************************/
if(ini == NULL || fim == NULL) return; /* Lista vazia */
if(ini == fim) return; /* Apenas 1 elemento */
if(fim->prox == ini) return; /* Começo precede fim */
/** SEPARAÇÃO *****************************************************/
i = separa(lista);
/** PASSO DA RECURSÃO *********************************************/
esquerda = (Lista *) mallocSafe(sizeof(*esquerda));
direita = (Lista *) mallocSafe(sizeof(*direita));
esquerda->ini = lista->ini; esquerda->fim = i->ant;
direita->ini = i->prox; direita->fim = lista->fim;
quickSort(esquerda); /* Filmes com nota maior que i->nota */
quickSort(direita); /* Filmes com nota menor que i->nora */
/* Atualiza início e fim */
lista->ini = esquerda->ini; lista->fim = direita->fim;
/** LIBERAÇÃO DE MEMÓRIA ******************************************/
free(esquerda); esquerda = NULL;
free(direita); direita = NULL;
}
void nRainhas(int n)
{
int i; /*linha*/
int j; /*coluna*/
int *s; /*fila*/
int nSolucoes = 0;
s = mallocSafe((n+1)*sizeof(int));
/* NÃO usaremos o índice 0, mas começaremos com '1' */
i = j = 1;
while(i > 0) /* Até o backtrack voltar até o '0', que significa
que ele percorreu todas as possibilidades */
{
int achouPos = FALSE;
while(j <= n+1 && achouPos == FALSE)
/* Enquanto não chegamos ao final do 'tabuleiro' e não
achamos uma posição válida, realizamos a ação */
{
s[i] = j;
if(solucaoParcial(i, s) == TRUE)
achouPos = TRUE;
/* Se a solução parcial for válida, achamos a posição */
else j += 1;
/* Caso não conseguimos ainda uma posição válida, avan-
çamos para a coluna */
}
if(j <= n) /*AVANÇA*/
{
i += 1;
j = 1;
if(i == n+1)
{
/*achou solução*/
nSolucoes++;
imprimaTabuleiro(n, s);
}
j = s[--i] + 1; /*i -= 1; j = s[i];*/
}
else /*BACKTRACK - VOLTA*/
{
i -= 1; s[i] + 1;
/* Fomos até o final do caminho, e aí voltamos */
}
printf("n-Solucoes %d\n", nSolucoes);
}
free(s); /* Libera a pilha */
}
Imagem *criaImagem(int nLins, int nCols)
/* A função recebe o número de linhas e de colunas e cria uma estru-
tura do tipo 'Imagem', na qual será criada uma matriz de tamanho
nLins x nCols */
{
/** ALOCAÇÃO DE VARIÁVEIS ****************************************/
int i; /* Variável auxiliar */
Imagem *novaImagem; /* Imagem a ser alocada */
novaImagem = mallocSafe(sizeof(Imagem));
/* Alocamos com malloc para a variável não ser descartada
com o fim da função */
/** CRIAÇÃO DA IMAGEM ********************************************/
novaImagem->nL = nLins;
novaImagem->nC = nCols;
/* Alocando a matriz 'pixel' na estrutura novaImagem */
novaImagem->pixel = mallocSafe(nLins * sizeof(int *));
for(i = 0; i < nLins; i++)
novaImagem->pixel[i] = mallocSafe(nCols * sizeof(int));
/** RETORNO ******************************************************/
return novaImagem;
}
/*Executa a função visit em cada item, sendo que eles estão ordenados*/
void st_lema_sort(void (*visit)(Item_lema))
{
int i,j;
link t;
Item_lema *v = mallocSafe(N*sizeof(Item_lema));
for (j = 0, i = 0; i < M; i++)
if (heads[i] != z)
for (t = heads[i]; t != z; t = t->next)
v[j++] = t->item;
qsort(v, N, sizeof(Item_lema), lema_cmp);
for(i = 0; i < N; i++)
visit(v[i]);
free(v);
}
void
intercala( int p, int q, int r, Item* v)
{
int i, j, k;
Item *w;
w = mallocSafe( (r-p) * sizeof (*w));
for (i = 0, k = p; k < q; ++i, ++k)
w[i] = v[k];
for (j = r-p-1, k = q; k < r; --j, ++k)
w[j] = v[k];
i = 0; j = r-p-1;
for (k = p; k < r; ++k)
if (w[i] != NULLitem && w[j] != NULLitem){
if ((eq(w[i]->lema, w[j]->lema) || less(w[i]->lema, w[j]->lema))) v[k] = w[i++];
else v[k] = w[j--];
}
free( w);
}
Filme *criaFilme(char *d, int v, float n, char *nm, int a)
{
Filme *f;
f = mallocSafe(sizeof(Filme));
strncpy(f->dist, d, 10);
f->dist[10] = '\0';
strncpy(f->nome, nm, TAMNOME);
f->nome[TAMNOME] = '\0';
f->votos = v;
f->nota = n;
f->ano = a;
f->prox = f->ant = NULL; /* paranoia */
return f;
}
/*Função que torna o hash dinamico.
Dobra o tamanho da tabela e reinsere os elementos*/
static void reHash()
{
int K, i;
link *aux, t;
K = prime_m(2*M);
aux = mallocSafe(K*sizeof(link));
for (i = 0; i < K; i++) aux[i] = z;
for (i = 0; i < M; i++)
while ((t = heads[i]) != z)
{
int h = hash(key_lema(t->item), K);
heads[i] = heads[i]->next;
t->next = aux[h];
aux[h] = t;
}
free(heads);
heads = aux;
aux = NULL;
M = K;
}
/*Função que torna o hash dinamico.
Dobra o tamanho da tabela e reinsere os elementos*/
static void reHash()
{
int K, i;
Item_lema *aux;
K = prime_m(2*M);
aux = mallocSafe(K*sizeof(Item_lema));
for (i = 0; i < K; i++) aux[i] = NULLitem_lema;
for (i = 0; i < M; i++)
if(!null(i))
{
int h = hash(key_lema(st_lema[i]), K);
while (aux[h].lema != NULLitem_lema.lema) h = (h+1) % K;
aux[h] = st_lema[i];
}
free(st_lema);
st_lema = aux;
aux = NULL;
M = K;
}
/*
----------------------------------------------------------------------
Funcao separa
Recebe uma lista de elementos e devolve um ponteiro para o filme
'i' que separa os filmes à esquerda com notas maiores ou iguais
à nota de 'i' e os filmes à direita com notas menores.
*/
static Filme *separa(Lista *lista)
{
/** VARIÁVEIS *****************************************************/
Filme *i; /* Posição que mantêm a relação invariante */
Filme *j; /* Batedor para percorrer a analisar a lista */
Filme *cab; /* Auxiliar para manter a relação invariante */
Filme *ini; /* Apontador para o primeiro filme da lista */
float nota; /* Guarda a nota que separa os filmes */
cab = (Filme *) mallocSafe(sizeof(*cab));
ini = lista->ini; cab->prox = ini;
i = cab; nota = lista->fim->nota;
/** SEPARA ********************************************************/
for(j = ini; /*ι*/ j != NULL; j = j->prox)
{
if(j->nota >= nota)
{
i = i->prox;
troca(&i, &j, &lista);
}
}
/*------------------------------------------------------------
RELAÇÃO INVARIANTE:
Em ι, vale que todos os elmentos da lista até 'i' têm notas
maiores ou iguais a 'i'. De 'i->prox' até 'fim', todos têm
notas menores. Resumidamente:
(ini->...)->nota >= i->nota > (..->fim)->nota
------------------------------------------------------------*/
/** LIBERAÇÃO DE MEMÓRIA ******************************************/
free(cab); cab = NULL; j = NULL; ini = NULL;
return i;
}
Link initializeList() {
Link head = (Link)mallocSafe(sizeof(Node));
head->total = 0;
head->next = NULL;
return head;
}
int main(){
char *pcwd;
char *arg[ARG_MAX];
pid_t childPid;
char *entrada = mallocSafe(NUM_MAX_CARAC_A_LER * sizeof(char));
char *str;
int i, ii; /* Iterador */
while(1){
/* 1. Imprimir o diretório */
pcwd = getcwd(NULL, 0);
printf("[%s] ", pcwd);
/* 2. Ler entrada do usuário */
leLinha(entrada, NUM_MAX_CARAC_A_LER, stdin); /* le ateh NUM_MAX_CARAC_A_LER - 1 caracteres,
jogando fora os demais caracteres */
/* 3. Parsear entrada */
i = 0;
str = strtok(entrada, " \n");
while(str && i < ARG_MAX - 1){
arg[i++] = str;
str = strtok(NULL, " \n");
}
arg[i] = NULL;
/* neste ponto, vale
* arg[0] == comando ou binario, arg[1] == primeiro argumento, ...,
* arg[i-1] == (i-1)-esimo argumento, ..., arg[i] == NULL
*/
/* 4. Executar comando/binario */
/* 4.1 Comando cd */
if(!strcmp("cd", arg[0])) {
/* TESTE COMECA
printf("Executa cd ");
for(ii = 0; ii < i; ii++)
printf("%s ", args[ii]);
printf("\n");
TESTE TERMINA */
chdir(arg[1]);
}
/* 4.2 Comando pwd */
else if(!strcmp("pwd", arg[0])) {
printf("%s\n", pcwd);
}
/* 4.3 Binario (/bin/ls ou ./ep1) */
else {
switch (childPid = fork()){
case -1:
perror("fork falhou");
exit(1);
break;
case 0: /* Processo filho */
/* 4.3.1 Binario /bin/ls -1 */
if(!strcmp("/bin/ls", arg[0]) && !strcmp("-1", arg[1])){
printf("vou executar /bin/ls com o seguinte arg:");
for(ii = 0; ii <= i; ii++) {
printf("%s,", arg[ii]);
}
printf("\n");
execve(arg[0], arg, 0);
perror("execve");
exit(EXIT_FAILURE);
}
/* 4.3.2 Binario ./ep1 */
else if(!strcmp("./ep1", arg[0])){ // TODO: Interpretação do ./ep1
/* TESTE COMECA
printf("Executa ep1 ");
for(ii = 0; ii < i; ii++)
printf("%s ", args[ii]);
printf("\n");
TESTE TERMINA */
}
exit(0); /* nao achamos o que executar, entao nos matamos */
break;
default:
/* Processo pai */
free(entrada);
wait(NULL);
break;
}
}
}
return 0;
}
int *distancias(int n, int **A, int c)
/* Recebe o número de cidades,
uma matriz com os caminhos e
a cidade a ser analisada (c).
Devolve um vetor com as dis-
tâncias até todas as cidades */
{
int *d = mallocSafe(n*sizeof(int));
/* Matriz das distâncias */
int j; /* contador */
queueInit(n);
/* Criamos a fila */
for(j = 0; j < n; j++)
d[j] = n;
/* Inicializa a matriz das distân-
cias com 'n' - o número de ci-
dades, que representa a dis-
tância "infinita" */
d[c] = 0;
/* A cidade a ser analisada tem
distância dela a ela mesma
com 0. */
queuePut(c);
/* O primeiro elemento da fila,
que será analisada, é a ci-
dade passada como parâmetro. */
while(!queueEmpty())
/* Este laço é feito no MÁXIMO
'n' vezes, pois cada cidade
é colocada na fila, para ter
as distâncias analisadas, uma
vez apenas */
{
int i = queueGet();
/* Pegamos o primeiro elemento
da fila */
for(j = 0; j < n; j++)
/* Executamos este laço 'n'
vezes no MÁXIMO, pois
este é o número d checa-
gens para os caminhos que
faremos na matriz. */
if(s[i][j] == 1 && d[j] == n) {
/* Se já tiver sido posto,
no passado, é porque
já houve um caminho mais
curto até lá. Caso con-
trário, se houver liga-
ção (s[i][j] == 1) e
não tiver sido posto ain-
da (d[j] == n), fazemos
as operações abaixo */
d[j] = d[i] + 1;
/* A distância da cidade
será a distância até
a cidade atual (d[j])
somada de 1. */
queuePut(j);
/* Se não tiver entrado
ainda, ele é colocado
na fila para ser ana-
lisado posteriormen-
te. */
} /* fim do if */
} /* fim do for */
} /* fim do while */
void leMondrian(char *nomeArquivo, int *altura, int *largura, Linha *cab)
{
char aux[MAX_LINHA];
int npars;
FILE *entrada;
int p, i, f;
Linha *nova;
int cont = 0;
entrada = fopen(nomeArquivo, "r");
if (entrada == NULL)
{
fprintf(stderr, "ERRO!! Nao consegui abrir o arquivo %s\n", nomeArquivo);
exit(-1);
}
fprintf(stdout, "Arquivo de entrada com a definicao do desenho: %s\n",
nomeArquivo);
while (fscanf(entrada, "%s", aux) != EOF)
{
switch (aux[0]) {
case '#':
fgets(aux, MAX_LINHA, entrada);
break;
case 'r':
case 'R':
npars = fscanf(entrada, "%d %d", altura, largura);
if (npars != 2) {
fprintf(stderr, "ERRO na leitura da dimensao da"
" imagem no arquivo de entrada %s\n", nomeArquivo);
exit (-1);
}
else {
fprintf(stdout, "Resolucao da Imagem: %d linhas x %d colunas \n",
*altura, *largura);
}
break;
case 'H':
case 'h':
npars = fscanf(entrada, "%d %d %d", &p, &i, &f);
if (npars != 3) {
fprintf(stderr, "ERRO na leitura de uma linha horizontal"
" no arquivo de entrada %s\n", nomeArquivo);
exit (-1);
}
else {
cont += 1;
nova = mallocSafe(sizeof(Linha));
nova->prox = cab->prox;
nova->tipo = TIPO_HORIZONTAL;
nova->pos = p;
nova->ini = i;
nova->fim = f;
cab->prox = nova;
fprintf(stdout, "Linha %3d: Tipo H com pos = %4d, "
"inicio = %4d e fim %4d\n",
cont, p, i, f);
}
break;
case 'V':
case 'v':
npars = fscanf(entrada, "%d %d %d", &p, &i, &f);
if (npars != 3) {
fprintf(stderr, "ERRO na leitura de uma linha vertical no"
" arquivo de entrada %s\n", nomeArquivo);
exit (-1);
}
else {
cont += 1;
nova = mallocSafe(sizeof(Linha));
nova->prox = cab->prox;
nova->tipo = TIPO_VERTICAL;
nova->pos = p;
nova->ini = i;
nova->fim = f;
cab->prox = nova;
fprintf(stdout, "Linha %3d: Tipo V com pos = %4d, "
"inicio = %4d e fim %4d\n", cont, p, i, f);
}
break;
default:
fgets(aux, MAX_LINHA, entrada);
break;
}
}
fclose(entrada);
}
void mochilaInit()
{
inventario = mallocSafe(sizeof (Mochila));
inventario->prox = NULL;
fim = inventario;
}