int main(int argc, char **argv) { if (argc != 4) return erro("./servidor <nome_servidor> <porta> <expr>"); char *nome_host = argv[1], *porta = argv[2], *expr = argv[3]; timestamp(); printf("[C] Sou o cliente e minhas mensagens terao prefixo [C].\n"); /* abre conexão. */ int con_serv = sock_cliente(nome_host, porta); if (con_serv <= 0) return erro("abrir_conexao()"); if (write(con_serv, msg_para_buffer(nova_expressao(expr)), sizeof(msg)) < 0) return erro("Nao consegui enviar..."); timestamp(); printf("[C] Enviei a expressao\n"); char buffer[BUFSIZ]; bzero(buffer, BUFSIZ); read(con_serv, buffer, BUFSIZ); msg *m = buffer_para_msg(buffer); timestamp();; printf("[C] Recebi: ( %s )\n", m->expressao); /* quem sai por último, apaga a luz. */ return fecha_socket(con_serv); }
int main() { int fd, client; struct sockaddr_in addr, client_addr; int client_addr_size; bzero((void *) &addr, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_addr.s_addr = htonl(INADDR_ANY); addr.sin_port = htons(SERVER_PORT); if ( (fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) erro("na funcao socket"); if ( bind(fd,(struct sockaddr*)&addr,sizeof(addr)) < 0) erro("na funcao bind"); if( listen(fd, 5) < 0) erro("na funcao listen"); while (1) { client_addr_size = sizeof(client_addr); client = accept(fd,(struct sockaddr *)&client_addr,(socklen_t *)&client_addr_size); if (client > 0) { if (fork() == 0) { close(fd); process_client(client); exit(0); } close(client); } } return 0; }
int main(void) { struct sockaddr_in si_minha, si_outra; int s, i, slen = sizeof(si_outra) , recv_len; char buf[BUFLEN]; // Cria um socket para recepção de pacotes UDP if((s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) { erro("Erro na criação do socket"); } si_minha.sin_family = AF_INET; si_minha.sin_port = htons(PORT); si_minha.sin_addr.s_addr = htonl(INADDR_ANY); // Associa o socket à informação de endereço if(bind(s,(struct sockaddr*)&si_minha, sizeof(si_minha)) == -1) { erro("Erro no bind"); } // Espera recepção de mensagem (a chamada é bloqueante) if((recv_len = recvfrom(s, buf, BUFLEN, 0, (struct sockaddr *) &si_outra, &slen)) == -1) { erro("Erro no recvfrom"); } // Para ignorar o restante conteúdo (anterior do buffer) buf[recv_len]='\0'; printf("Recebi uma mensagem do sistema com o endereço %s e o porto %d\n", inet_ntoa(si_outra.sin_addr), ntohs(si_outra.sin_port)); printf("Conteúdo da mensagem: %s\n" , buf); // Fecha socket e termina programa close(s); return 0; }
Grafo *prism_MST(Grafo *G, Indice *arestaT){ int *st; /* vetor com os pais de cada vertice (st[0=raiz] = 0)*/ double *wt; /* vetor com o peso das arestas para os pais */ Grafo *T; /* Grafo T que e Minimum Spanning Tree (MST) */ int v; st = malloc(GRAFOvertices(G)*sizeof(int)); if(st == NULL) erro(MALLOC_v); wt = malloc((GRAFOvertices(G)+1)*sizeof(double)); if(wt == NULL) erro(MALLOC_v); GRAFOprim_MST(G,st,wt); T = GRAFOInit(n); for(v = 1; v < n; v++) { GRAFOinsereE(T,v,st[v],wt[v]); /* Guardo as arestas em um vetor para o uso futuro na ordenacao */ arestaT[v-1].peso = wt[v]; arestaT[v-1].objeto_linha = v; arestaT[v-1].objeto_coluna = st[v]; } free(st); free(wt); return T; }
/* Carregra grafo. */ int carrega_grafo(const char *arquivo) { FILE *fp = fopen(arquivo, "r"); if (!fp) return 1; unsigned int n; if (fscanf(fp, "%u", &n) < 0) return erro("Não consegui ler a dimensão da matriz"); /* constrói o grafo montando os conjuntos de vértices e arestas */ if (!grafo_constroi(n)) return erro("Não consegui montar o grafo (V, G)"); /* constrói a tabela de menores caminhos entre cada par de vértices */ if (!menor_caminho_inicializa(n)) return erro("Não consegui inicializar atabela de menores caminhos"); /* lê o arquivo */ unsigned int i, j; for (i = 1; i <= n; i++) for (j = 1; j <= n; j++) if (i != j) { if (fscanf(fp, "%lf", &ARESTAS[i][j]) < 0) return erro("Formato do arquivo inesperado"); } else ARESTAS[i][j] = INF; fclose(fp); return 0; }
void comando_repetitivo(void) { //Verifica se o proximo token й um WHILE if((tk.cat == PR) && (tk.p_reservada == WHILE)){ tk = analex(); //Verifica se o proximo token й '(' if((tk.cat == SN) && (tk.cod == OPP)){ tk = analex(); expressao(); //Verifica se o proximo token й um ')' if((tk.cat == SN) && (tk.cod == CLP)){ tk = analex(); //Verifica se o proximo token й '{' if((tk.cat == SN) && (tk.cod == OPB)){ tk = analex(); comando(); //Verifica se o proximo token й '}' if((tk.cat == SN) && (tk.cod == CLB)){ tk = analex(); comando(); } else erro(lin, 5);//Chama erro caso nгo venha '}' } else erro(lin, 4); //chama erro caso nгo venha '{' } else erro(lin, 3); //Chama erro caso nгo venha ')' } else erro(lin, 2);//Chama erro caso nгo venha '(' } }
void declaracao_funcao_principal(void) { if ((tk.cat == PR) && (tk.p_reservada == MAIN)){ tk = analex(); novo.escopo = escopo; novo.classe = FUNC; strcpy(novo.lexema, "main"); insere_simbolo(novo); escopo = LO; //Verificando se o token й um '{' if((tk.cat == SN) && (tk.cod == OPB)){ tk = analex(); bloco_de_funcao(); //verifica se o proximo tken й um '}' if((tk.cat == SN) && (tk.cod == CLB)){ printf("Tabela Declaracao Final \n\n"); exit(0);//Finaliza a execuзгo do programa } else erro(lin, 5); //Chama mensagem de erro caso nгo venha '}' } else erro(lin, 4); //Chama mesangem de erro caso nгo venha um '{' } else erro(lin, 6); // Chama uma mensagem de erro caso nгo venha o MAIN }
int main(int argc, char *argv[]) { char endServer[100]; char buffer[BUF_SIZE]; int nread = 0; int fd; struct sockaddr_in addr; struct hostent *hostPtr; if (argc != 4) { printf("cliente <host> <port> <string>\n"); exit(-1); } strcpy(endServer, argv[1]); if ((hostPtr = gethostbyname(endServer)) == 0) erro("Nao consegui obter endereço"); bzero((void *) &addr, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_addr.s_addr = ((struct in_addr *)(hostPtr->h_addr))->s_addr; addr.sin_port = htons((short) atoi(argv[2])); if((fd = socket(AF_INET,SOCK_STREAM,0)) == -1) erro("socket"); if( connect(fd,(struct sockaddr *)&addr,sizeof (addr)) < 0) erro("Connect"); write(fd, argv[3], 1 + strlen(argv[3])); nread = read(fd, buffer, BUF_SIZE-1); buffer[nread] = '\0'; printf("%s\n",buffer); close(fd); exit(0); }
int main(void) { struct sockaddr_in si_minha, si_outra; int s; unsigned int slen = sizeof(si_outra) , recv_len; char buf[BUFLEN]; // Cria um socket para recepção de pacotes UDP if((s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) { erro("Erro na criação do socket"); } si_minha.sin_family = AF_INET; si_minha.sin_port = htons(PORT); si_minha.sin_addr.s_addr = htonl(INADDR_ANY); // Associa o socket à informação de endereço if(bind(s, (struct sockaddr*)&si_minha, sizeof(si_minha)) == -1) { erro("Erro no bind"); } // Espera recepção de mensagem (a chamada é bloqueante) if((recv_len = recvfrom(s, buf, BUFLEN, 0, (struct sockaddr *) &si_outra, &slen)) == -1) erro("Erro no recvfrom"); // Para ignorar o restante conteúdo (anterior do buffer) buf[recv_len]= '\0'; printf("Recebi uma mensagem do sistema com o endereço %s e o porto %d\n", inet_ntoa(si_outra.sin_addr), ntohs(si_outra.sin_port)); printf("Conteúdo da mensagem: %s\n" , buf); char* traducao = (char*) malloc(10 * sizeof(char)); if (strcmp(buf, "Hello") == 0) { traducao = "Ola"; } else if (strcmp(buf, "Bye") == 0) { traducao = "Adeus"; } else if (strcmp(buf, "Thanks") == 0) { traducao = "Obrigada"; } printf("Mensagem traduzida: %s\n", traducao); // Envio de mensagem if(sendto(s, traducao, BUFLEN, 0, (struct sockaddr *) &si_outra, slen) == -1) erro("Erro no sendto"); // Fecha socket e termina programa close(s); return 0; }
simbolo_t* declare_simbolo (char* nome, const TIPO_QUALIFICADOR qual, const vetor_t* valores) { simbolo_t* temp = (simbolo_t*) malloc (sizeof(simbolo_t)); if (qual == QUADWORD) { erro(0, parser_lineno, "(oursym.c) tipo quadword nao implementado"); free(temp); /* libera ponteiro inicializado */ return (simbolo_t*)NULL; } /* ok, vou retornar o simbolo */ temp->qualidade = qual; temp->npos = valores->nval; temp->nome = nome; temp->valor = valores->value; temp->proximo = NULL; temp->endereco_byte = NULL; temp->endereco_word = NULL; temp->apontado = NULL; temp->lineno = parser_lineno; /* guarda o numero da linha da declaracao */ return insira_simbolo(temp); }
int benchmark_salvar(const char *nome) { struct mallinfo info; int i; i = procurar_benchmark(nome); if (i == NOT_FOUND) { if (bm.tamanho == MAX_BENCHMARKS) { erro("Erro: Número máximo de benchmarks atingido.\n"); return 0; } i = bm.tamanho++; { struct benchmark_data *nbm; nbm = TALLOC(struct benchmark_data); bm.lista[i] = nbm; strcpy(bm.lista[i]->nome, nome); } } info = mallinfo(); bm.lista[i]->clock = clock(); bm.lista[i]->alocado = info.uordblks; bm.lista[i]->time = time(NULL); return 1; }
/*------------------------------------------------------------------------------ --- Principal. ---------------------------------------------------------------- -----------------------------------------------------------------------------*/ int main(int argc, char **argv) { if (argc != 2) return erro("Especifique o nome do arquivo"); if (carrega_grafo(argv[1]) != 0) return erro("Erro ao construir o grafo"); if (!backtracking(0)) return erro("Não consegui fazer backtracking"); imprime_tudo(); return EXIT_SUCCESS; }
int main (int argc, char *argv[]) { Indice *Ml,*Mh,*CW; Indice *arestaT; /* Armazena as arestas de T ao inves do grafo */ Grafo *Gh, *T; Arvoreb *R, *U; int i; Ml = NULL; Mh = NULL; if(argc < 2) erro(SEM_ARQUIVO); ler_entrada(argv[1],&Ml,&Mh); if(!checa_entrada(Ml,Mh)) erro(MLMAIOR); /** Construir GH a partir de MH **/ Gh = GRAFOInit(n); for(i = 0; i < tamanho_M; i++) { GRAFOinsereE(Gh,get_M_objeto_linha(Mh,i),get_M_objeto_coluna(Mh,i),(double)get_M_peso(Mh,i)); } free(Mh); /* Construir T a partir de GH */ arestaT = malloc((n-1)*sizeof(Indice)); if(arestaT == NULL) erro(MALLOC_lh); T = prism_MST(Gh,arestaT); if(!checa_existencia_U(T,arestaT,Ml)) erro(UNAOEXISTE); GRAFODel(Gh); GRAFODel(T); /* Construir R a partir de T(ArestaT)*/ R = construir_R(arestaT); /* Computar CW a partir de ML, T, e R*/ CW = computacao_CW(Ml,arestaT,R); free(arestaT); free(Ml); ARVOREBDel(R); /* Computar U a partir de CW(R,T e CW inbutido)*/ U = construir_U(CW); printf("Impressao de U:\n[NO] ------------- PESO -------------- [NO_PAI]\n"); ARVOREBImprimeW(U); /** FREES **/ free(CW); ARVOREBDel(U); return 0; }
void comando(void) { atribuicao(); chamada_de_funcao2(); //Verificar a possibilidade de testar diretamente em comando...para evitar erros. comando_condicional(); comando_repetitivo(); //Verifica se o proximo token й GET if((tk.cat == PR) && (tk.p_reservada == GET)){ tk = analex(); //Verifica se o proximo token й '(' if((tk.cat == SN) && (tk.cod == OPP)){ tk = analex(); if(tk.cat == ID){ tk = analex(); if((tk.cat == SN) && (tk.cod == CLP)){ tk = analex(); if((tk.cat == SN) && (tk.cod == SMC)){ tk = analex(); comando(); } else erro(lin, 8); //Chama erro caso nгo venha ';' } else erro(lin, 3); //Chama erro caso nгo venha ')' } else erro(lin, 1); } else erro(lin, 2); } else if((tk.cat == PR) && (tk.p_reservada == PUT)){ tk = analex(); if((tk.cat == SN) && (tk.cod == OPP)){ tk = analex(); literal(); expressao_simples(); //Verifica se o proximo token й um ')' if((tk.cat == SN) && (tk.cod == CLP)){ tk = analex(); if((tk.cat == SN) && (tk.cod == SMC)){ tk = analex(); comando(); } else erro(lin, 8); //Chama erro caso nгo venha ';' } else erro(lin, 3); //Chama erro caso nгo venha ')' } else erro(lin, 2);//Chama erro caso nгo venha '(' }else if((tk.cat == SN) && (tk.cod == SMC)){ tk = analex(); comando(); } }
void le_nome(num_matriz *k) /* Lê um nome de matriz, pulando brancos, e devolve o número correspondente. */ { char c; scanf(" %c", &c); if ((c < min_nome) || (c > max_nome)) { erro("nome de matriz invalido"); } (*k) = c - min_nome; }
int main() { int n, opcao; double a, b; printf("Entre com a: "); scanf("%lf",&a); printf("Entre com b: "); scanf("%lf",&b); do { printf(" Metodo De Integracao de Simpson\n"); printf("\n\n\n\t(1)..........................Calcular com n intervalos\n"); printf("\t(2)..........................Entrar Com Novos Valores de a e b\n"); printf("\t(0)..........................Sair\n"); printf("\nOpcao Desejada: "); scanf("%d",&opcao); switch (opcao) { case 1: do { printf("\nEntre com n: "); scanf("%d",&n); if(n%2) { printf("N deve Ser Par!!!\n"); } } while(n%2); printf("Resultado %lf\n",simpson(a,b,n)); printf("Erro Cometido: %lf\n",erro(a, b, n, simpson(a,b,n))); break; case 2: main(); break; case 0: exit(0); break; } } while(opcao); return 0; }
int main(int argc, char *argv[]) { int s, x[MAX_SUPERS], y[MAX_SUPERS], i, teste=1, caso_aluno, x_aluno, y_aluno; char linha_aluno[10000]; FILE * sol_aluno; sol_aluno = fopen(argv[1], "rt"); while (scanf("%d", &s) == 1 && s > 0) { /* le solucao do aluno */ if ((fscanf(sol_aluno,"%s",linha_aluno) != 1) || (strcmp(linha_aluno,"Teste"))) erro("Palavra 'Teste' nao encontrada"); if ((fscanf(sol_aluno,"%d",&caso_aluno) != 1) || (caso_aluno != teste++)) erro("Nro do teste incorreto"); if (fscanf(sol_aluno, "%d %d", &x_aluno, &y_aluno) != 2) erro("Final inesperado da resposta"); /* calcula resposta correta */ for (i = 0; i < s; i++) scanf("%d %d", &x[i], &y[i]); qsort(x, s, sizeof(int), compara); qsort(y, s, sizeof(int), compara); if (s % 2 == 1) { if (x_aluno != x[s/2] || y_aluno != y[s/2]) erro("Resposta errada (localizacao nao eh otima)"); } else { if (x_aluno < x[(s-1)/2] || x_aluno > x[s/2] || y_aluno < y[(s-1)/2] || y_aluno > y[s/2]) erro( "Resposta errada (localizacao nao eh otima)"); } } printf("10\n"); fclose(sol_aluno); return 0; }
void parser(char *expr) { struct Pilha pilha; int x, a, nProd, i, *producao; int pos = 0; inicializa(&pilha); insere(&pilha, FIM); insere(&pilha, EXPR); if ((a = lex(expr, &pos)) == ERRO) erro("Erro lexico", expr, pos); do { x = consulta(&pilha); if (!(x&NTER)) { if (x == a) { remover (&pilha); if ((a = lex(expr, &pos)) == ERRO) erro("Erro lexico", expr, pos); } else{ erro("Erro sintatico2",expr, pos); } } if (x&NTER) { nProd = STAB[(x&NNTER)-1][(a>>8)-3]; if (nProd) { remover (&pilha); producao = PROD[nProd]; for (i = producao[0]; i > 0; i--){ insere (&pilha, producao[i]); } } else erro ("Erro sintatico1", expr, pos); } } while (x != FIM); }
/* Retorna uma aproximação do valor da raiz quadrada de n. * A quantidade de iterações e a precisão dadas limitam o esforço gasto na * aproximação. */ float Newton_Raphson(float n, int iteracoes, float precisao) { float r = valor_inicial(n); for(; iteracoes > 0; --iteracoes) { r = aproxima(r, n); if(precisao >= erro(r, n)) break; } return r; }
void chamada_de_funcao1(void) { if(aux.sit == PEN){ if((tk.cat == SN) && (tk.cod == OPP)){ tk = analex(); lista_de_expressoes(); //Verifica se o proximo token й um ')' if((tk.cat == SN) && (tk.cod == CLP)){ tk = analex(); //Verifica se o proximo token й um ';' if((tk.cat == SN) && (tk.cod == SMC)){ tk = analex(); aux.sit = LIV; comando(); } else erro(lin, 8); // Chmama mensagem de erro caso nгo venha ';' } else erro(lin, 3); // Chama mensagem de erro caso nгo venha ')' } else erro(lin, 2); } else { if(tk.cat == ID){ tk = analex(); //Verifica se o procximo token й um '(' if((tk.cat == SN) && (tk.cod == OPP)){ tk = analex(); lista_de_expressoes(); //Verifica se o proximo token й um ')' if((tk.cat == SN) && (tk.cod == CLP)){ tk = analex(); //Verifica se o proximo token й um ';' if((tk.cat == SN) && (tk.cod == SMC)){ tk = analex(); comando(); } else erro(lin, 8); // Chmama mensagem de erro caso nгo venha ';' } else erro(lin, 3); // Chama mensagem de erro caso nгo venha ')' } } } }
int inicioInteracaoConcorrente(MATRIZES *matrizes,FILE *arq_save){ double ERRO = erro(matrizes,0); int k,i; /* Iterações até atingir o critério de parada */ for ( k = 0; ERRO > matrizes->J_ERROR && k < matrizes->J_ITE_MAX ; ++k) { for( i = 0 ; i < matrizes->J_ORDER; ++i) { matrizes->OLD_X[i] = matrizes->X[i]; } omp_set_num_threads(matrizes->n_threads); #pragma omp parallel { int size = matrizes->J_ORDER / matrizes->n_threads; int inicio = omp_get_thread_num() * size; int fim = inicio + size; if(omp_get_thread_num() == matrizes->n_threads-1) { fim += (matrizes->J_ORDER % matrizes->n_threads); } interacaoConcorrente(matrizes, inicio, fim); //for(i=0 ; i < matrizes->n_threads ; ++i){ /*if(pthread_create(&(matrizes->array_threads[i]), NULL, interacaoConcorrente, (void*)matrizes)) { fprintf(stderr, "Error creating thread\n"); return 1; } */ //} } /* for(i = 0; i < matrizes->n_threads ; ++i) { pthread_join(matrizes->array_threads[i],NULL); } */ ERRO = erro(matrizes, 1); fprintf(arq_save,"%d\t\t%lf\n", k, ERRO); } return k; }
intizinho salvar_jogo(Jogo *jogo){ FILE* jogos_salvos = fopen("jogos_salvos.DAT", "r+b"); if(jogos_salvos == NULL){ jogos_salvos = fopen("jogos_salvos.DAT", "w+b"); }else{ //nothing } if(jogos_salvos != NULL || jogo != NULL){ intizinho i = 0; intizinho quantidade_de_jogos = 0; intizinho posicao_salvar=0; char nome_jogo[TAMANHO_NOME_JOGO]; Jogo *jogos = carrega_jogos(jogos_salvos, &quantidade_de_jogos); visualizar_jogos_salvos(jogos); do{ fflush(stdin); scanf ("%d", &posicao_salvar); if (valida_salvar(posicao_salvar)== FALSE){ printf("Posi%c%co Inv%clida", CHAR_CEDILHA, CHAR_ATIO, CHAR_AAGUDO); } }while(valida_salvar(posicao_salvar) == FALSE); fflush(stdin); fgets (nome_jogo, TAMANHO_NOME_JOGO, stdin); strcpy(jogo->nome, nome_jogo); jogos[posicao_salvar-1] = *jogo; rewind (jogos_salvos); if((fwrite(jogos, (sizeof(Jogo)), MAX_JOGOS, jogos_salvos)) == FALSE){ erro("salvar_jogo()", "Nao foi possivel salvar o jogo!"); return FALSE; }else{ printf("passou!"); } }else{ erro("salvar_jogo()", "Nao foi possivel abrir o arquivo!"); return FALSE; } fclose(jogos_salvos); return TRUE; }
int main(int argc, char *argv[]){ struct sockaddr_in si_minha, si_outra; char endServer[100]; int s,recv_len; struct hostent *hostPtr; socklen_t slen = sizeof(si_outra); char buf[BUFLEN]; strcpy(buf,argv[3]); strcpy(endServer, argv[1]); if ((hostPtr = gethostbyname(endServer)) == 0) erro("Nao consegui obter endereço"); // Cria um socket para recepção de pacotes UDP if((s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) { erro("Erro na criação do socket"); } si_minha.sin_family = AF_INET; si_minha.sin_port = htons(PORT); si_minha.sin_addr.s_addr = ((struct in_addr *)(hostPtr->h_addr))->s_addr; // Envio de mensagem if(sendto(s, buf, BUFLEN, 0, (struct sockaddr *) &si_minha,slen)==-1){ erro("Erro no sendto"); } printf("Mensagem enviada: %s\n" , buf); // Fecha socket e termina programa close(s); return 0; }
/* abre uma conexão TCP na `porta' e devolve o socket. */ int sock_cliente(char *nome_servidor, char *porta) { struct hostent *dns = gethostbyname(nome_servidor); if (!dns) return erro("servidor DNS inalcançável."); struct sockaddr_in endereco_servidor; bcopy(dns->h_addr, &(endereco_servidor.sin_addr), dns->h_length); endereco_servidor.sin_family = AF_INET; endereco_servidor.sin_port = htons(atoi(porta)); /* abre o socket. */ int cliente_servidor = socket(AF_INET, SOCK_STREAM, 0); if (cliente_servidor < 0) return erro("socket()."); timestamp(); printf("[C] Tentando conectar com %s em %s\n", nome_servidor, porta); if (connect(cliente_servidor, (struct sockaddr *) &endereco_servidor, sizeof(endereco_servidor)) < 0) return erro("connect()."); return cliente_servidor; }
void atribuicao(void) { int tipo1, tipo2; char id[50]; tipo1 = tipo2 = 0; if(tk.cat == ID){ strcpy(id, tk.lexema); strcpy(aux.id, tk.lexema); tk = analex(); //Verifica se o proximo token й um '=' if((tk.cat == SN) && (tk.cod == ATB)){ tipo1 = verifica_tabela(id); tk = analex(); tipo2 = expressao(); if(tipo1 != tipo2){ erro(lin, 12); } //Verifica se o proximo token й um ';' if((tk.cat == SN) && (tk.cod == SMC)){ tk = analex(); comando(); } else erro(lin, 8); //Chama mensagem de erro caso nгo venha um ';' } else{ aux.sit = PEN; } } }
int main (int argc, char *argv[]) { char endServer[100]; int fd; struct hostent *hostPtr; struct sockaddr_in addr, serv_addr; if (argc != 4) { printf("cliente <host> <port> <string>\n"); exit(-1); } strcpy(endServer, argv[1]); if ((hostPtr = gethostbyname(endServer)) == 0) erro("Nao consegui obter endereço"); bzero((void *) &addr, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_addr.s_addr = ((struct in_addr *)(hostPtr->h_addr))->s_addr; addr.sin_port = htons((short) atoi(argv[2])); if((fd = socket(AF_INET,SOCK_DGRAM,0)) == -1) //SOCK_DGRAM em vez de SOCK_STREAM erro("socket"); if(sendto(fd, argv[3], strlen(argv[3])+1, 0,(struct sockaddr*)&addr,sizeof(addr))<0){ erro("sendto");} close(fd); exit(0); }
int inicioInteracaoSequencial(MATRIZES *matrizes,FILE *arq_save){ double ERRO = erro(matrizes,0); int k,i,j; for ( k = 0; ERRO > matrizes->J_ERROR && k < matrizes->J_ITE_MAX ; ++k) { for(i = 0 ; i < matrizes->J_ORDER; ++i) { matrizes->OLD_X[i] = matrizes->X[i]; } for(i = 0; i < matrizes->J_ORDER; ++i) { matrizes->X[i] = matrizes->MB[i]; for(j=0; j<matrizes->J_ORDER; ++j) { matrizes->X[i]-=(matrizes->OLD_X[j]*matrizes->MA[i][j]); } } ERRO = erro(matrizes,1); fprintf(arq_save,"%d\t\t%lf\n", k, ERRO); } return k; }
void qf(char palavra[], int cont) { if(palavra[cont] == '\0') { printf("Palavra Aceita!"); } else if(palavra[cont] == '2') { qf(palavra, cont+1); } else { erro(); } }
int termo(void) { int tipo1, tipo2; tipo1 = tipo2 = 0; tipo1 = fator(); while((tk.cod == MUL) || (tk.cod == DIV) || (tk.cod == MOD) || (tk.cod == AND)){ tk = analex(); tipo2 = fator(); if(tipo1 != tipo2){ erro(lin, 12); } } return tipo1; }
//--------------------------------------------------------------------------------------------------------------------------------------------------- Jogo *carrega_jogos(FILE* jogos_salvos, intizinho *quantidade_de_jogos){ intizinho quantidade_de_jogos_lida = 0; register intizinho i = 0; fseek(jogos_salvos, sizeof(Jogo), SEEK_END); quantidade_de_jogos_lida = (ftell(jogos_salvos)/(sizeof(Jogo)))-1; rewind(jogos_salvos); Jogo *jogos = (Jogo*)calloc(MAX_JOGOS, sizeof(Jogo)); for(i = 0; i < MAX_JOGOS; i++){ jogos[i] = cria_jogo(NULL, START, NULL); } if(fread(jogos, (sizeof(Jogo)), MAX_JOGOS, jogos_salvos) != quantidade_de_jogos_lida){ erro("carrega_jogos()", "Nao foi possivel carregar jogo!"); }else{ //ok } *quantidade_de_jogos = quantidade_de_jogos_lida; return jogos; }