[C] interprete de comandos

br_viseu

Membro
Ola!!gostaria de saber se alguem me pode ajudar a fazer um interprete de comandos para unix com o C semelhante ao "command.com" do MSDOS....se alguem ja tivesse feito alguma coisa parecida ou assim agradecia
 
implementar comandos internos (dir,cd,date,etc....);executar programas;permitir definir variaveis de ambiente tais como PATH, PROMPT.....n sei como começar??
 
Tens de detectar um comando:
- podes por exemplo ler da linha de comandos até que um enter for carregado.
Tens de fazer parse à linha de comandos:
- procuras pelos espaços e vais colocando o comando e os argumentos em strings.
Tens de identificar o comando e chamar o método correspondente:
- Comparas o 1º arg. com uma lista de comandos conhecidos e mapeias para uma função qq qur te faça o resultado esperado em DOS.
 
Algumas direcções:
Se quiseres podes usar a biblioteca readline, que ajuda com a leitura dos comandos (e até manutenção do histórico). Manual do sistema (man readline)... etc...
Para executar programas, fork() e exec(). Vê no manual mais detalhes...
Para aquela parte do "procuras por espaços" e assim podes usar wordexp (mais uma vez, man wordexp). Esta pode parecer um pouco esquisita e/ou complicada à primeira, mas no fundo é bastante simples.
Para as variáveis de ambiente, tens de manter uma lista de estruturas com pares de strings ou assim. Tipo uma hash-table, se souberes o que isso é. Se não souberes o que são hash-tables (e não estiveres praí virado) podes implementar uma simples lista ligada de pares.

Se os manuais não forem suficientemente esclarecedores... pergunta...

Algum código para exemplificar o uso de readline e wordexp:
Código:
#include <readline/readline.h>
#include <readline/history.h>
#include <wordexp.h>

// Variável para guardar um comando
char* cmd;
// Variável para guardar as palavras de um comando (nome do programa e argumentos)
wordexp_t words;
// Variável para guardar o valor de saída do comando
int status;

// Ler um comando
cmd = readline("prompt: ");
// Adicionar ao histórico
add_history(cmd);

// Dividir o comando em palavras
wordexp(cmd, &words, 0);

// Lançar um processo para correr o comando
if(fork())
{
   // Aqui é o interpretador
   wait(&status);
   // Processar o resultado, etc...
}
else
{
    // Aqui é o comando
    execvp(words.we_wordv[0], words.we_wordv);
}

É mais ou menos isto...
 
Última edição:
Fiz isto na última aula de Sistemas Operativos. É um programa que faz pipes.
Código:
#include <stdio.h>
#include <wordexp.h>
#include <sys/types.h>
#include <unistd.h>
#include <malloc.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    int *****;
    int wp[2];
    int i;
    wordexp_t words;

    *****= 0;
    for (i = 1; i < argc - 1; i++)
    {
        pipe(wp);
        if(!fork())
        {
            if(*****)
            {
                dup2(*****, 0);
                close(*****);
            }

            dup2(wp[1], 1);
            close(wp[1]);
            close(wp[0]);

            wordexp(argv[i], &words, 0);
            execvp(words.we_wordv[0], words.we_wordv);

            exit(EXIT_FAILURE);
        }

        close(*****);
        ***** = wp[0];
        close(wp[1]);
    }
    dup2(*****, 0);
    close(*****);

    wordexp (argv[i], &words, 0);
    execvp (words.we_wordv[0], words.we_wordv);
}
 
Back
Topo