コード例 #1
0
ファイル: t1lp.c プロジェクト: gnsantos/hashing
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);
}
コード例 #2
0
ファイル: nave.c プロジェクト: hinokakera/RawrRaid
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;
}
コード例 #3
0
ファイル: mondrian_com_print.c プロジェクト: renatocf/MAC0122
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;
}
コード例 #4
0
ファイル: t2enc.c プロジェクト: ruan0408/EP4-ED
/*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;
}
コード例 #5
0
ファイル: t1lp.c プロジェクト: gnsantos/hashing
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;
  }
}
コード例 #6
0
ファイル: filmes.c プロジェクト: renatocf/MAC0122
/*
------------------------------------------------------------------------
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;
}
コード例 #7
0
ファイル: linkedList.c プロジェクト: fabiokaspar/Ondas
void insertItem(Link head, double altura) {
    Link novo = (Link) mallocSafe(sizeof(Node));
    novo->altura = altura;

    novo->next = head->next;
    head->next = novo;
    head->total++;
}
コード例 #8
0
ファイル: t2lp.c プロジェクト: ruan0408/EP4-ED
/*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;
}
コード例 #9
0
ファイル: t2enc.c プロジェクト: ruan0408/EP4-ED
/*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;
}
コード例 #10
0
ファイル: filmes.c プロジェクト: renatocf/MAC0122
/*
------------------------------------------------------------------------
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", &nota);
        
        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;

}
コード例 #11
0
ファイル: filmes.c プロジェクト: renatocf/MAC0122
Lista *criaLista()
{
  Lista *lista;

  lista =  mallocSafe(sizeof(Lista));

  lista->ini = NULL;
  lista->fim    = NULL;

  return lista;
}
コード例 #12
0
ファイル: t2lp.c プロジェクト: ruan0408/EP4-ED
/*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);
}
コード例 #13
0
ファイル: t1lp.c プロジェクト: gnsantos/hashing
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);
}
コード例 #14
0
ファイル: item.c プロジェクト: Turtledorm/rpg
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;
}
コード例 #15
0
ファイル: filmes.c プロジェクト: renatocf/MAC0122
/*
----------------------------------------------------------------------
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;
}
コード例 #16
0
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 */
}
コード例 #17
0
ファイル: mondrian_com_print.c プロジェクト: renatocf/MAC0122
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;
}
コード例 #18
0
ファイル: t2enc.c プロジェクト: ruan0408/EP4-ED
/*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);
}
コード例 #19
0
ファイル: t1lp.c プロジェクト: gnsantos/hashing
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);
}
コード例 #20
0
ファイル: filmes.c プロジェクト: renatocf/MAC0122
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;
}
コード例 #21
0
ファイル: t2enc.c プロジェクト: ruan0408/EP4-ED
/*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;
}
コード例 #22
0
ファイル: t2lp.c プロジェクト: ruan0408/EP4-ED
/*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;
}
コード例 #23
0
ファイル: filmes.c プロジェクト: renatocf/MAC0122
/*
----------------------------------------------------------------------
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;
}
コード例 #24
0
ファイル: linkedList.c プロジェクト: fabiokaspar/Ondas
Link initializeList() {
    Link head = (Link)mallocSafe(sizeof(Node));
    head->total = 0;
    head->next = NULL;
    return head;
}
コード例 #25
0
ファイル: ep1sh.c プロジェクト: yoshiomori/ep1so
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;
}
コード例 #26
0
ファイル: distancias.c プロジェクト: renatocf/MAC0122
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 */
コード例 #27
0
ファイル: mondrian_com_print.c プロジェクト: renatocf/MAC0122
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);
}
コード例 #28
0
ファイル: item.c プロジェクト: Turtledorm/rpg
void mochilaInit()
{
	inventario = mallocSafe(sizeof (Mochila));
	inventario->prox = NULL;
	fim = inventario;
}