Fórum geral de discussão

A strcmp(char *a, char *b) é uma função que recebe dois strings e devolve 0 se são iguais e != 0 se forem diferentes. Esse diferente de 0 pode ser negativo se a string a for menor que b na ordem lexicográfica (ou seja a vem antes de b no dicionário) e positivo se a for maior que b na ordem lexicográfica (a vem depois de b no dicionário).

Exemplos:

• strcmp("bola","bola") devolverá 0
• strcmp("aola","bola") devolverá um int < 0
• strcmp("bola","cola") devolverá um int > 0

Parte 2

1 int run_viewer_and_get_option(char command[], char message[])
2 {
3   pid_t pid;
4    int retval;
5    if ((pid = fork()) == 0) {
6       setpgrp();
7       system(command);
8       exit(0);
9    }
10    retval = get_option(message);
11    killpg(pid, SIGQUIT);
12   return retval;
13 }

Essa função cria com o fork (linha 5) um processo "filho" no sistema e roda o "eog tmp_file" que é o command para você ver a imagem. 

Com a killpg (linha 11) você mata esse processo.

Parte III

Isso mesmo. A horizontal_flip cria uma outra matriz b com a matriz a invertida e depois copia todos esses valores em a e assim ela faz o horizontal_flip.

int run_viewer_and_get_option(char command[], char message[])
{
    pid_t pid;
    int retval;

    if ((pid = fork()) == 0) {
        setpgrp();
        system(command);
        exit(0);
    }
    retval = get_option(message);
    killpg(pid, SIGQUIT);
    return retval;
}

Esse código serve para, quando o visualizador é aberto, o EP poder mostrar o menu e o usuário selecionar uma opção. Depois de selecionada a opção o visualizador é fechado.

Para fazer isso o programa usa um fork(), que divide a execução em duas frentes. Uma delas é a que executa o visualizador e a outra mostra o menu do EP. No processo filho pid = 0, no pai o pid é igual ao id do processo filho. O setpgrp() faz com que, se a segunda frente do EP for fechada o visualizador feche também.(na verdade ele cria um grupo de processos).  o killpg (com signal SIGQUIT) é usado para terminar um grupo de processos. Com isso, depois que o usuário seleciona um opção no menu o visualizador é fechado, junto com a segunda frente de execução do programa.

O código abaixo faz a mesma coisa, mas sem usar grupos de processos:
(o execvp executa um programa no linux. o arg são os argumentos do programa. por definição, o primeiro argumento sempre é o nome do programa e o último é um \0)
(o kill envia sinais para um processo. o sinal 9 é SIGKILL, que termina um processo)
#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
   
int kill(pid_t pid, int sig);

int main(){
    pid_t p;   
    char t[256];
    char *arg[] = {"gcalctool", '\0'};
    p = fork();
    if (p == 0){
        execvp("gcalctool", arg);
        exit(0);
    }else {
        printf("Digite alguma coisa para sair da calculadora do gnome:");
        scanf("%s", t);
        kill(p, 9);
    }
    return 0;
}

Eu não testei muito esse código, mas ele funciona para os testes que fiz.

desculpa rodrigo, não ví que você já tinha respondido

Como pode ter gente assustada com esta discussão sobre chamadas fork, setpgrp, killpg, execvp e kill, processos pai e filho, grupos de processos, etc., é bom eu deixar uma coisa bem clara: nenhuma dessas coisas faz parte da matéria de MAC0110! Como eu disse no enunciado do EP4, o código que faz a  visualização de uma imagem e a leitura da próxima opção acontecerem em paralelo (e, ao mesmo tempo, faz com que a escolha da próxima opção feche a janela do visualizador) é bem curto, mas envolve conceitos que fogem ao escopo desta disciplina. Vocês vão aprender tudo sobre processos e sobre as chamadas fork/kill/exec/... no devido tempo. O código que usa essas coisas está na função run_viewer_and_get_option do arquivo esqueleto2.c. Vocês não são obrigados a usar essa função. Quem preferir, pode basear seu programa na outra versão do esqueleto. (Essa sim, deve ser completamente entendida.) Quem optar pelo esqueleto2.c não é obrigado a entender os detalhes internos da função run_viewer_and_get_option.

Claro que o objetivo deste comentário não é censurar a discussão (muito interessante, por sinal!) e a troca de informações sobre processos e sobre as funções do Unix/Linux que criam ou manipulam processos. Quero apenas esclarecer que nada disso faz parte da matéria de MAC0110 e, portanto, ninguém é obrigado a saber essas coisas a esta altura.

O conceito de processo é bastante profundo. Quem quisar se adiantar e aprender um pouco sobre processos agora, ótimo. Mas sugiro que não gaste tempo demais, pois mais para a frente no BCC vocês terão condições muito melhores para realmente entender o conceito.

Pode sim, é para isso que eu publiquei os esqueletos.