在linux中實現一個簡單的命令解釋程式，功能要求：

1）同時支援內部命令和外部命令，內部命令支援兩個（cd、exit）

2）支援後臺命令

首先解釋一下上面的兩個要求，實際上是三種情況：

1.如果是內部命令cd和exit，那麼在父程序裡直接分析執行

2.如果是外部命令，則建立一個子程序，再由子程序從path環境變數中查詢相應的檔案執行，此時shell會阻塞，等待子程序結束。

3.如果是後臺命令，輸入以&結束，它跟外部命令的最大區別是，後臺命令建立了子程序後不需要呼叫wait(*status)，也就是不用等待子程序結束，這樣就變成了後臺程序。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <string.h>
#include <errno.h>

#define MAXLEN 80

char cwd[MAXLEN];//當前工作目錄
char *prompt;

char* parseCmd(char* cmd, char** argarr, int* argc)
{
    enum states {S_START, S_INTOKEN, S_INQUOTES};
    int numArgs = 0;//引數數目
    int loop = 1;//迴圈標誌
    enum states state = S_START;//當前狀態
    int lastch;

    while(loop)
    {
        switch(state)
        {
        case S_START:
            if(*cmd == '"')
            {
                *argarr++ = cmd + 1;
                numArgs++;
                state = S_INQUOTES;
            }
            else if(*cmd == 0 || *cmd == ';')
                loop = 0;
            else if(*cmd <= ' ')//忽略ascii碼錶中的空格符及空格符前面的字元
                *cmd = 0;
            else
            {
                *argarr++ = cmd;
                numArgs++;
                state = S_INTOKEN;
            }
            break;
        case S_INTOKEN:
            if(*cmd == 0 || *cmd == ';')
                loop = 0;
            else if(*cmd <= ' ')
            {
                *cmd = 0;
                state = S_START;
            }
            break;
        case S_INQUOTES:
            if(*cmd == 0)
                loop = 0;
            else if(*cmd == '"')
            {
                *cmd = 0;
                state = S_START;
            }
            break;
        }
        cmd++;//指向下一個字元
    }
    *argarr = NULL;//最後一個引數指向空

    if(argc != NULL) *argc = numArgs;

    lastch = cmd[-1];
    cmd[-1] = 0;
    return lastch == ';' ? cmd : NULL;// 如果遇到分號則返回剩餘的字串作為下一條命令
}

int main(int argc, char** argv)
{
    char cmd[80];
    char* source = NULL;
    char* arg[20];
    int statval;
    int numArgs;

    while(1)
    {
        if(source == NULL)
        {
            getcwd(cwd,MAXLEN);
            printf("%s$ ",cwd);
            //讀取命令
            if((source = gets(cmd)) == NULL)
                exit(0);
        }

        source = parseCmd(source, arg, &numArgs);
        if(numArgs == 0) continue;

        //是否退出程式
        if(strcasecmp(arg[0], "exit") == 0)
        {
            exit(0);//不管exit後面是否還有引數，直接退出
        }

        if(!strcmp(arg[0],"cd"))//切換父程序的工作目錄
        {
            chdir(arg[1]);
            continue;
        }

        if(!strcmp(arg[numArgs-1],"&"))//後臺命令
        {
            char* a[20];//臨時變數
            int k;
            for(k=0;k<numArgs-1;k++)
            {
                a[k] = malloc(strlen(arg[k]) + 1);
                strcpy(a[k],arg[k]);
                //printf("%s ", a[k]);
            }
            a[k] = NULL;
            if(fork() == 0)
            {
                if(execvp(a[0],a) == -1)// 執行失敗
                    fprintf(stderr, "exec %s failed: %s\n",argv[0],strerror(errno));
                exit(1);//退出子程序
            }
            for(k=0;k<numArgs-1;k++);//釋放記憶體
                free(a[k]);
            continue;
        }

        //建立子程序執行命令
        if(fork() == 0)
        {
            if(execvp(arg[0],arg) == -1)// 執行失敗
                fprintf(stderr, "exec %s failed: %s\n",argv[0],strerror(errno));
            exit(1);//退出子程序
        }
        wait(&statval);
    }
}
 

下面看一下執行結果：

內部命令：

外部命令：

可以看到，此時shell發生阻塞。

後臺命令：

可以看到，此時shell並沒有阻塞。

下面說一下程式碼結構，程式碼主要分兩塊：

1.解析命令，將命令列引數進行解析儲存。這裡用到跟編譯原理的詞法分析器一樣的有窮自動機進行分析，將單詞從字元流中取出並儲存。

2.執行命令。判斷是三種命令中的哪一種，如果是內部命令，則在父程序中呼叫相應函式；如果是外部命令，則呼叫execlp()執行，並在父程序中呼叫wait()等待子程序結束；如果是後臺命令，則在第二種情況下只去掉wait()函式，不用等待子程序結束。

羅嗦多一句，在實現後臺命令時，如果關閉shell