十七、文件和目录——minishell（1）

　　

　　主函数运行要去读取从标准输入或终端上输入的整个命令行，然后再去解析命令行参数，解析出来之后，要将其封装成一个 program，然后再将 program 放入 job 中，然后再去执行 job 中的命令行的内容。

17.1 job.o

　　job.h 文件

 #ifndef __JOB_H__
 #define __JOB_H__

 typedef struct
 {
     char **args; //shell 当中输入的命令参数;对应主函数中的 char *argv[] 参数
 }Program;

 //作业结构体，表示若干个要执行的参数
 typedef struct
 {
     char         *cmd;
     int         progs_num;
     Program     *progs;//Program 的结构体指针
 }Job;

 extern Job * create_job(char *cmd);
 extern void destroy_job(Job *job);
 extern Program* create_program(char **arg);//创建一个程序
 extern void destroy_program(Program *prog);
 extern int add_program(Job *job, Program *prog);//将程序加入到 job 中

 #endif

　　job.c 文件

 #include "job.h"
 #include <malloc.h>
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <memory.h>

 /* 根据 commond 命令创建 job */
 Job * create_job(char *cmd)
 {
     Job *job = (Job *)malloc(sizeof(Job));
     assert(job != NULL);

     job->cmd = (char *)malloc(sizeof(char) * strlen(cmd));
     assert(job->cmd != NULL);

     strcpy(job->cmd, cmd);
     job->progs_num = ;
     job->progs = NULL;

     return job;
 }

 void destroy_job(Job *job)
 {
     assert(job != NULL);
     free(job->progs);
     free(job->cmd);
     free(job);
 }

 /* 统计命令行参数的个数 */
 static int arg_num(char **arg)
 {
     int i = ;
     char *start = arg[];

     while(start != NULL) {
         i++;
         start = arg[i];
     }

     return i;
 }

 /*
  *     函数功能：    构建一个 program
  *     函数参数：
  *         @arg：命令行传入的参数
  *     返回值：
  */
 Program* create_program(char **arg)//创建一个程序
 {
     //在堆当中创建 program 内存块
     Program *prog = (Program *)malloc(sizeof(Program));
     assert(prog != NULL);

     int counter = arg_num(arg);

     //多 new 一个空间存放 NULL ，所以 counter 要 +1
     prog->args = (char **)calloc(counter + , sizeof(char *));

     int i;
     for(i = ; i < counter; i++) {
         int len = strlen(arg[i]);
         prog->args[i] = (char *)malloc(len);
         assert(prog->args[i] != NULL);
         strcpy(prog->args[i], arg[i]);
     }
     prog->args[i] = NULL;
     return prog;
 }

 void destroy_program(Program *prog)
 {
     assert(prog != NULL);
     int i = ;

     /* 命令行释放 */
     while(prog->args[i] != NULL) {
         free(prog->args[i]);
         i++;
     }
     free(prog->args);//数组释放
     free(prog);
 }

 /*    1.通过动态分配创建一个结构体数组
  *    2.将 job 中原先的 progs 复制给 ps 结构体数组
  *    3.在向 ps 结构体数组中加上新的 prog
  *    4.把  job 中原先的 progs 释放掉
  *    5.将 job 中的 progs 指向 ps
  */
 int add_program(Job *job, Program *prog)//将程序加入到 job 中
 {
     Program *ps = (Program *)malloc(sizeof(Program) * (job->progs_num + ));//1 为NULL的初始化

     memcpy(ps, job->progs, job->progs_num * sizeof(Program));
     ps[job->progs_num++] = *prog;
     free(job->progs);
     job->progs = ps;
 }

　　编译成 .o 文件

　　gcc -o obj/job.o -Iinclude -c src/job.c

17.2 命令行参数的解析

17.2.1 主函数

　　mshell.c

 #include "job.h"
 #include "cmd_func.h"
 #include <unistd.h>
 #include <string.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <memory.h>
 #include <assert.h>
 #include <malloc.h>

 /* shell 中的提示符 */
 char *prompt = "mshell > ";

 /* 指定命令行中传递的最大命令行的长度 */
 #define MAX_COMMAND_LEN 256

 /* 对命令行进行解析 */
 void parse_cmd(Job *job, char *line)
 {
     char **args = (char **)malloc( * sizeof(char *));//创建的 program 里面的args
     assert(args != NULL);

     /* 分割命令行 */
     char *cmd = strtok(line, " ");
     args[] = (char *)malloc(strlen(cmd) * sizeof(char)); //第一个参数为命令本身
     strcpy(args[], cmd);

     int i = ;
     char *s;
     while((s = strtok(NULL, " ")) != NULL) {
         args[i] = (char *)malloc(strlen(s) * sizeof(char));
         strcpy(args[i], s);
         i++;
     }

     //根据  args 创建 program
     Program * prog = create_program(args);
     add_program(job, prog);

     int j;
     for(j = ; j < i; j++) {
         free(args[j]);
     }

     free(args);
 }

 /* 执行命令 */
 void excute_cmd(Job *job)
 {
     int i;
     for(i = ; i < job->progs_num; i++) {
         if(!strcmp(job->progs[i].args[], "cd")) {
             cd_func(&job->progs[i]);
             return;
         }

         if(!strcmp(job->progs[i].args[], "pwd")) {
             pwd_func(&job->progs[i]);
             return;
         }

         if(!strcmp(job->progs[i].args[], "exit")) {
             exit_func(&job->progs[i]);
             return;
         }
     }
 }

 int main(int argc, char *argv[])
 {
     char buff[MAX_COMMAND_LEN];//存放从命令行中输入的整个命令行
     memset(buff, , MAX_COMMAND_LEN);
     ssize_t size = strlen(prompt) * sizeof(char);//提示符占用的总的大小

     write(STDOUT_FILENO, prompt, size);//输出 shell 的提示符

     ssize_t len;
     while() {
         /* 从标准输入读取命令行的内容 */
         len = read(STDIN_FILENO, buff, MAX_COMMAND_LEN);
         buff[len - ] = ; //结束符

         if(strlen(buff) > ) {//命令行要大于0
             Job *job = create_job(buff);//创建 job

             parse_cmd(job, buff); //对命令行进行解析

             excute_cmd(job); // 执行命令
             destroy_job(job); // 销毁

         }

         write(STDOUT_FILENO, prompt, size);
         memset(buff, , MAX_COMMAND_LEN);
     }

     return ;
 }

17.2.2 命令功能函数

　　cmd_func.h

 #ifndef __CMD_FUNC_H__
 #define __CMD_FUNC_H__

 #include "job.h"

 #define BUFF_SIZE_256         256

 extern void cd_func(Program *prog);
 extern void pwd_func(Program *prog);
 extern void exit_func(Program *prog);

 #endif

　　cmd_func.c

 #include "cmd_func.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include "job.h"
 #include <fcntl.h>
 #include <string.h>
 #include <unistd.h>

 /* 切换目录 */
 void cd_func(Program *prog)
 {
     if(chdir(prog->args[]) < ) {
         perror("cd error");
     }
 }

 /* 显示当前工作目录路径 */
 void pwd_func(Program *prog)
 {
     char buff[];
     memset(buff, , sizeof(buff));

     /* 获取当前工作目录的绝对路径 */
     if(getcwd(buff, sizeof(buff)) == NULL) {
         perror("pwd error");
     }

     printf("%s\n", buff);
 }

 /* 退出 */
 void exit_func(Program *prog)
 {
     exit();
 }

　　编译成.o 文件

　　gcc -o obj/cmd_func.o -Iinclude -c src/cmd_func.c

17.3 编译调试　　

　　gcc -o bin/mshell -Iinclude obj/*.o src/mshell.c