int concatenaDiretoriosAosComandos (struct Tokens * tokens){
char * diretorioAtual;
struct ListaLigada * novosTokens = calloc (1,sizeof(struct ListaLigada *));
if (!novosTokens)
//será fatal para o sistema
trataFalha();
int i = 0;
while (i < tokens->tokens->total){
int j;
int ok = 0;
for (j = 0; j < ambiente->total; j++){
diretorioAtual = recupera (ambiente,j);
struct dirent ** arquivos;
int result = scandir(diretorioAtual,&arquivos,NULL,NULL);
if (result < 0){
//se der erro aqui o resultado final será completamente alterado
//portanto estou considerando este erro como fatal para o programa
trataFalha();
}
while (result--){
if (strcmp(recupera(tokens->tokens,i),arquivos[result]->d_name) == 0){
char * aux = (char *)calloc (4096 + 1,sizeof(char *));
strcpy(aux,diretorioAtual);
strcat(aux,"/");
strcat(aux,recupera(tokens->tokens,i));
adiciona (novosTokens,aux);
ok = 1;
free (arquivos[result]);
break;
}
free(arquivos[result]);
}
free (arquivos);
if (ok){
//para a procura se ja tiver encontrado no diretorio atual e passa para o proximo token
break;
}
}
if (!ok){
printf ("Comando %s não encontrado) no seu path\n",recupera(tokens->tokens,i));
return 0;
}
//percorre a sequencia de tokens até encontrar um outro comando, que somente podera vir depois de pipe
while (i < tokens->tokens->total - 1 &&(strcmp(recupera(tokens->tokens,i),"|")!= 0 )){
i++;
adiciona(novosTokens,recupera(tokens->tokens,i));
}
//soma mais um para um para o proximo token que será o próximo comando após o operador
i++;
}
struct ListaLigada * apagar = tokens->tokens;
tokens->tokens = novosTokens;
free(apagar);
return 1;
}
int main(int argc, const char * argv[]) {
//Lista * minhaLista = (Lista *) malloc(sizeof(Lista));
Node *p = novo(1);
//addAt(p, 2, 0);
//addAt(p, 3, 3);
p = adiciona(p, 2);
p = adiciona(p, 3);
imprime(p);
return 0;
}
struct Tokens * getTokens (const char * const comando,const char * const del){
struct Tokens * tokens =(struct Tokens *) calloc (1,sizeof(struct Tokens));
if (tokens == NULL)
trataFalha();
//cria uma cópia para que a original não seja alterada
char *aux = strdup (comando);
tokens->tokens =(struct ListaLigada *) calloc (1,sizeof(struct ListaLigada));
if (tokens->tokens == NULL)
trataFalha();
tokens->stringOriginal = (char *) calloc (strlen(aux) + 1,sizeof(char));
if (tokens->stringOriginal == NULL)
trataFalha();
tokens->delimiters = (char * ) calloc (strlen(del) + 1,sizeof(char));
if (tokens->delimiters == NULL)
trataFalha();
strcpy (tokens->stringOriginal,aux);
strcpy(tokens->delimiters,del);
int i = 0;
char * token = (char *)calloc (4096 + 1,sizeof(char));
token = strtok(aux,del);
do{
adiciona(tokens->tokens,token);
i++;
token = strtok(NULL,del);
}
while (token != NULL);
return tokens;
}
int main(int argc, char *argv[]){
//Estruturas
BuscaRetorno* r;
Arvore* raiz;
//Inicializacao da arvore
resetActualTree();
raiz = initializeTree();
//Parametros
char* nameEntrada = argv[1];
char* nameBusca = argv[2];
char* nameSaida = argv[3];
//Arquivo
FILE *arq;
FILE *write;
char info[MAX_LENGHT_WORD];
// ==================== INSERINDO =========================
printf("Inserindo na arvore\n");
fopen_s(&arq,nameEntrada,"r");
if(arq == NULL)
printf("Erro, nao foi possivel abrir o arquivo\n");
else
while( (fgets(info, sizeof(info), arq))!=NULL )
raiz = adiciona(raiz,novoNo(info));
fclose(arq);
//raiz = adiciona(raiz,novoNo("1"));
// ==================== BUSCANDO =========================
printf("\nBUSCANDO\n");
fopen_s(&arq,nameBusca,"r");
if(arq == NULL)
printf("Erro, nao foi possivel abrir o arquivo de leitura\n");
else{
fopen_s(&write,nameSaida,"w");
if(arq == NULL)
printf("Erro, nao foi possivel abrir o arquivo de escrita\n");
else
while( (fgets(info, sizeof(info), arq))!=NULL ){
r = busca(raiz,info);
info[strlen(info)-1] = '\0';
if(encontrouNaBusca(r))
fprintf(write,"%s presente %d\n",info,profDaBusca(r));
else
fprintf(write,"%s ausente %d\n",info,profDaBusca(r));
}
}
fclose(arq);
fclose(write);
}
void DisplayFile::addObj(Object* obj){
if(obj->getName() == "")
throw MyException("Adicione um nome para este objeto.\n");
if(!contem(obj)){
adiciona(obj);
}else
throw MyException("Ja existe um objeto com o nome '"+ obj->getName() +"'.\n");
}
/**
* @brief Adiciona dado em uma posição especifica da lista
*
* @param[in] dado Dado a ser adicionado
* @param[in] pos Posição onde o dado vai ser adicionado
*/
void adicionaNaPosicao(const T& dado, int pos) {
if (pos < 0 || pos > size) throw 20;
if (pos == 0) return adicionaNoInicio(dado);
if (pos == size) return adiciona(dado);
auto current = head;
auto old = current;
while (--pos) {
old = current;
current = current->getProximo();
}
old->setProximo(std::make_shared<Elemento<T>>(dado, current));
++size;
}
int executaComandoPath (struct Tokens * tokens){
//se tiver mais que dois elementos, quer dizer que é para adicionar ou remover variáveis do path
if (tokens->tokens->total > 2){
//verifica se existem operadores após o comando próprio, se sim, nada é executado
if (contem (tokens->tokens,"|") || contem (tokens->tokens,">") || contem (tokens->tokens,"<") || contem (tokens->tokens,"2>"))
return 0;
//se o proximo token for + adiciona tenta adicionar cada argumento ao ambiente
if (strcmp(recupera (tokens->tokens,1),"+") == 0){
int i = 2;
while (i < tokens->tokens->total){
//checa se o diretório existe antes de adicioná-lo...
char * dir = recupera (tokens->tokens,i);
DIR * op = opendir(dir);
if (op == NULL){
printf ("Não foi possível adicionar diretório %s ao path: %s\n",dir,strerror(errno));
closedir(op);
}
else{
closedir(op);
adiciona(ambiente,dir);
}
i++;
}
return 1;
}
//se o comando for do tipo path - ... tenta remover os elementos ... do ambiente
else if (strcmp(recupera (tokens->tokens,1),"-") == 0){
int i = 2;
while (i < tokens->tokens->total && ambiente->total >= 1){
removeValores(ambiente,recupera(tokens->tokens,i));
i++;
}
return 1;
}
}
//se tiver somente um argumento, quer dizer que é pra imprimir as variáveis em path
else if (tokens->tokens->total == 1){
int i = 0;
while (i < ambiente->total - 1){
printf ("%s:",recupera(ambiente,i++));
}
if (ambiente->total >= 1)
printf ("%s\n",recupera (ambiente,i));
return 1;
}
return 0;
}
/*!
Adiciona um dado em ordem na lista.
\param endereço do dado do tipo T que sera inserido em ordem na lista.
*/
void adicionaEmOrdem(const T& data) {
printf("Adiciona em ordem errado!\n");
if (listaVazia())
adicionaNoInicio(data);
Elemento<T>* aux;
int pos;
aux = head;
pos = 0;
while (aux->getProximo() != NULL && maior(data, aux->getInfo())) {
aux = aux->getProximo();
pos++;
}
if (maior(data, aux->getInfo()))
adiciona(data);
adicionaNaPosicao(data, pos);
}
/**
* @brief Adiciona dado de forma que a lista fique ordenada
*
* @param[in] dado Dado a ser adicionado
*/
void adicionaEmOrdem(const T& dado) {
if (listaVazia()) return adicionaNoInicio(dado);
auto current = head;
auto old = current;
int i = 0;
while (current) {
if (current->getInfo() > dado) break;
old = current;
current = current->getProximo();
++i;
}
if (!i) return adicionaNoInicio(dado);
if (i == size) return adiciona(dado);
old->setProximo(std::make_shared<Elemento<T>>(dado, current));
++size;
}
void main() {
int op;
do {
clrscr();
printf("MENU - LISTA ENCADEADA\n");
printf("----------------------\n");
printf("1. Adicionar\n");
printf("2. Remover\n");
printf("3. Listar\n");
printf("4. Limpar\n");
printf("5. Sair\n\n");
printf("Opcao: "); scanf("%d",&op);
clrscr();
switch (op) {
case 1: {
printf("Digite o dado: ");
int dado;
scanf("%d",&dado);
adiciona(dado);
break;
}
case 2: {
if (inicio!=NULL) {
printf("Removendo... ");
apaga();
getch();
}
break;
}
case 3: {
lista();
getch();
break;
}
case 4: {
printf("Limpando...");
limpar();
getch();
break;
}
}
} while (op!=5);
limpar();
}
/**
* @brief Adiciona o dado na posição
*
* @param[in] dado Dado a ser inserido
* @param[in] pos Posição para inserir o dado
*/
void adicionaNaPosicao(const T& dado, int pos) {
if(pos > size || pos < 0)
throw std::runtime_error("posicao must be smaller than "
"ultimo+1 and greater than zero");
if (pos == 0)
return adicionaNoInicio(dado);
if (pos == size+1)
return adiciona(dado);
auto e = head;
for (int i = 0; i < pos-1; ++i)
e = e->getProximo();
e->setProximo(std::make_shared<Elemento<T>>(dado, e->getProximo()));
++size;
}
/**
NOME DA FUNÇÃO: adicionarContato
ALUNOS: Pedro Paulo e Felipe dos Santos
PROPÓSITO:
É responsável por obter o contato a ser armazenado e encaminhá-lo à lista de maneira apropriada e por fim
informar se tudo aconteceu de maneira correta.
PARÂMETROS:
nenhum
VALOR DE RETORNO:
nenhum
CHAMA: exibeMenuSecundario, adiciona, adicionaNoInicio, adicionaNaPosicao, exibirMensagemErro
CHAMADA DE: main
*/
void adicionarContato() {
int opcao, posicao, resultado;
tAgenda elemento;
puts("Forneça o nome do contato: ");
getchar();
scanf("%[^\n]", &elemento.nome);
puts("Forneça o número de telefone: ");
scanf("%d", &elemento.numero);
exibeMenuSecundario("Adicionar no");
puts("3 - Adicionar em ordem");
scanf("%d", &opcao);
switch (opcao) {
case 0:
resultado = adiciona(elemento);
break;
case 1:
resultado = adicionaNoInicio(elemento);
break;
case 2:
puts("Forneça a posição a ser adicionada");
scanf("%d", &posicao);
resultado = adicionaNaPosicao(elemento, posicao);
break;
case 3:
resultado = adicionaEmOrdem(elemento);
break;
default:
puts("Opção Inválida");
break;
}
if (resultado != 0)
exibirMensagemErro(resultado);
}
int main(int agrc, char *argv[]) {
int sock, sock_req, addr_in_size, bytes_recv;
sockaddr_in req_addr, serv_addr;
char package[400];
funcionario *f;
if((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
perror("socket");
exit(1);
}
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(atoi(argv[1]));
serv_addr.sin_addr.s_addr = INADDR_ANY;
memset(&(serv_addr.sin_zero), '\0', 8);
sem_init(&sem_fifo, 0, 1);
sem_init(&sem_db, 0, 1);
if(bind(sock, (sockaddr *)&serv_addr, sizeof(sockaddr)) == -1) {
perror("bind");
exit(1);
}
if(listen(sock, BACKLOG_SERV) == -1) {
perror("listen");
exit(1);
}
inicia_fifo(fifo_name);
init_db(db);
if(!fork()) {
ler_fifo();
exit(0);
}
while(1) {
addr_in_size = sizeof(sockaddr_in);
if((sock_req = accept(sock, (sockaddr *)&req_addr, &addr_in_size)) == -1) {
perror("accept");
continue;
}
if(!fork()) {
close(sock);
while((bytes_recv = recv(sock_req, package, sizeof(package), 0)) == -1) {
perror("recv");
}
printf("Signal received from %s\n", inet_ntoa(req_addr.sin_addr));
package[bytes_recv] = '\0';
sem_wait(&sem_fifo);
adiciona(fifo_name, package, req_addr);
sem_post(&sem_fifo);
close(sock_req);
exit(0);
}
close(sock_req);
}
while(wait(NULL) > 0);
return 0;
}
void roundrobin(int pid, int cpu, int io){
struct reg *atual;
atual=inicio;
while (atual != NULL){
if(atual->pid < pid->prox)
main() {
int op;
do {
printf("MENU - ESCALONADOR DE PROCESSOS\n\n");
printf("----------------------\n");
printf("Processos-----\n");
printf("1. Adicionar\n");
printf("2. Remover\n");
printf("3. Listar\n");
printf("4. Limpar\n\n");
printf("Escalonadores ------\n");
printf("5. Round Robin\n\n\n");
printf("0. Sair\n\n");
printf("Opcao: "); scanf("%d",&op);
switch (op) {
case 1: {
int pid, pri, tipo, cpu, io;
printf("Digite o PID: ");
scanf("%d",&pid);
printf("Digite o PRI: ");
scanf("%d",&pri);
while((tipo>3)||(tipo<1))
{
printf("Digite o TIPO (1-system/2-user/3-batch): ");
scanf("%d",&tipo);
}
printf("Digite o CPU: ");
scanf("%d",&cpu);
printf("Digite o I/O: ");
scanf("%d",&io);
adiciona(pid, pri, tipo, cpu, io);
break;
}
case 2: {
if (inicio!=NULL) {
printf("Removendo... ");
apaga();
getch();
}
break;
}
case 3: {
lista();
getch();
break;
}
case 4: {
printf("Limpando...");
limpar();
getch();
break;
}
case 5: {
roundrobin(pid, cpu, io);
getch();
break;
}
}
} while (op!=0);
limpar();
}
void main(){
char nome[10];
char nome1[10];
char nome2[10];
int d;
char i,h;
struct ponteiro p;
struct ponteiro q;
struct pessoa *raiz=(struct pessoa *)malloc(sizeof(struct pessoa));//Alocamos memoria para a raiz da arvore
printf("Qual a primeira pessoa da arvore genealógica?\n");
gets(nome);
raiz->nome=nome;
raiz->geracao = 0;
printf("%s\n", raiz->nome);
insira(raiz);//Começamos a raiz propriamente aqui
printf("Adicionar mais alguem? <S/N>");
scanf("%c", &h);
if(h=='S' || h=='s'){
adiciona(raiz);
}
printf("Deseja fazer mais alguma coisa? \n1-)imprimir os membros por geracao \n2-)imprimir os antepassados de alguem \n ");
printf("3-) imprimir labelled bracketing \n4-) calcular grau de parentesco \n5-) encerrar programa\n");//Aqui temos o menu
scanf("%c",&i);
if(i='1'){
printf("Qual geracao?");
scanf("%i", &d);
print_gen(raiz,d);
}
else if(i='2'){
printf("De quem?");
gets(nome);
emordem(raiz);
}
else if(i='3'){
imprimir_lb(raiz);
}
else if(i='4'){
printf("Pessoa 1:");
gets(nome1);
printf("Pessoa 2");
gets(nome2);
if(p.ponteiro->geracao > q.ponteiro->geracao){
grau(q.ponteiro, p.ponteiro, q.ponteiro->geracao);
}else{
grau(p.ponteiro,q.ponteiro, p.ponteiro->geracao);
}
}
else{
printf("Bye Bye");
}
}
void atribui (voids *left, void *right) {
adiciona (left, -1);
*left = *right;
adiciona (right, +1);
}
void ListaElementosGeometricos::adicionaEmOrdem(const ElementoGeometrico*& data){
adiciona(data);
}
