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;
}