精华内容
下载资源
问答
  • 实验十 简单shell命令行解释器设计与实现 1、实验目的 本实验主要目的在于进一步学会如何在 Linux 系统下使用进程相关的系统调用,了解 shell 工作 的基本原理,自己动手为 Linux 操作系统设计一个简单的命令接口...

    实验十 简单shell命令行解释器的设计与实现

    完整课程设计源码及其报告查看陈陈的操作系统课程设计

    1、实验目的

    本实验主要目的在于进一步学会如何在 Linux 系统下使用进程相关的系统调用,了解 shell 工作

    的基本原理,自己动手为 Linux 操作系统设计一个简单的命令接口。

    2、背景知识

    本实验要使用创建子进程的 fork()函数,执行新的命令的 exec()系列函数,通常 shell 是等待子

    进程结束后再接受用户新的输入,这可以使用 waitpid()函数。以上相关的系统函数调用的说明请参

    见实验二的背景知识。

    3、设计内容与要求

    要设计的 shell 类似于 sh,bash,csh 等,必须支持以下内部命令:

    cd <目录>更改当前的工作目录到另一个<目录>。如果<目录>未指定,输出当前工作目录。如果<目录>不存在,应当有适当的错误信息提示。这个命令应该也能改变 PWD 的环境变量。

    environ 列出所有环境变量字符串的设置(类似于 Linux 系统下的 env 命令)。

    echo <内容> 显示 echo 后的内容且换行

    help 简短概要的输出你的 shell 的使用方法和基本功能。

    jobs 输出 shell 当前的一系列子进程,必须提供子进程的命名和 PID 号。

    quit,exit,bye 退出 shell。

    提示:shell 的主体就是反复下面的循环过程
    while(1){
    		接收用户输入的命令行;
    		解析命令行;
    	if(用户命令为内部命令)
    		直接处理;
    	else if(用户命令为外部命令)
     		创建子进程执行命令;
     	else
    	提示错误的命令;
    }
    

    实验源码:下面源码直接做成.c文件直接在虚拟机上运行即可

    #include <stdio.h>
    #include <string.h>
    #include <sys/types.h>
    #include <unistd.h>
     
    int main()
    {
        char cmd[2100];
        while(1)
        {
        	printf("\n --------------------------------------------------\n");
    	printf("                 shell 命令行解释器");
    	printf("\n --------------------------------------------------\n\n");
    	printf("\n -----------------------------------\n");
    	printf("              操作选择                \n");
    	printf(" -----------------------------------\n");
    	printf("|1、echo            		     |\n");
    	printf("|2、quit exit bye    		     |\n");
    	printf("|3、cd      			     |\n");
    	printf("|4、jobs			     |\n");
    	printf("|5. environ                          |\n");
    	printf("|6. help                             |\n");
    	printf(" -----------------------------------\n");
    	printf("\n");
            printf("请输入你的操作:");
            scanf("%s",cmd);
            int len=strlen(cmd),i;
            if(cmd[0] == 'e' && cmd[1] == 'c') // echo
            {
                int flag=0;
                for( i=5; i<len-1; i++)
                {
                    if(cmd[i]!=' ') flag=1;
                    if(flag)
                    {
                        putchar(cmd[i]);
                    }
                }
                if(flag) putchar('\n');
            }
            else if(cmd[0]=='q' || cmd[1]=='x' || cmd[0]=='b') // quit,exit,bye
            {
                printf("Bye\n");
                return 0;
            }
            else if(cmd[0]=='h') // help
            {
                printf("/**********************************/\n");
                printf("echo <content>\tprint a line content\n");
                printf("quit,exit,bye\tend produce\n");
                printf("cd <catalog>\techo catalog\n");
                printf("jobs\techo process name and pid...\n");
                printf("environ\techo environment variable\n");
                printf("/**********************************/\n");
            }
            else
            {
                char cata[100];
                int cnt=0;
                if(cmd[0]=='c') // cd
                {
                    int flag=0;
                    for( i=3; i<len; i++)
                    {
                        if(cmd[i]!=' ') flag=1;
                        if(flag)
                        {
                            cata[cnt++] = cmd[i];
                        }
                    }
                    if(cnt==0)
                    {
                        cata[0]='.';
                        cata[1]='\0';
                    }
                }
                /* fork a child process */
                pid_t pid = fork();
                if (pid < 0)
                {
                    /* error occurred */
                    fprintf(stderr, "Fork Failed");
                    return 1;
                }
                else if(pid==0)
                {
                    if(cmd[0]=='c') // cd
                    {
                        execlp("/bin/ls",cata,NULL);
                    }
                    else if(cmd[0]=='j') // jobs
                    {
                        execlp("pstree","-p",NULL);
                    }
                    else if(cmd[0]=='e') // environ
                    {
                        execlp("env","",NULL);
                    }
                }
                else
                {
                    /* wait wait,until child process exit*/
                    wait();
                }
            }
            printf("\n");
        }
        return 0;
    }
    

    实验结果截图及其分析:
    在这里插入图片描述

    更多课程设计源码请进主页查看搜索陈陈不会敲代码

    完整课程设计报告请下载陈陈的操作系统课程设计源码及其报告

    完整报告包含以下内容的源码以及实验报告:
    image-20211209141046247
    资源展示如下:
    image-20211209111320397
    image-20211209111500829
    image-20211209111433497

    展开全文
  • 设计的shell 类似于sh,bash,csh 等,必须支持以下内部命令:cd 更改当前的工作目录到另一个。如果未指定,输出当前工作目录。如果不存在,应当有适当的错误信息提示。这个命令应该也能改变PWD 的环境变量。environ...

    要设计的shell 类似于sh,bash,csh 等,必须支持以下内部命令:cd 更改当前的工作目录到另一个。如果未指定,输出当前工作目录。如

    果不存在,应当有适当的错误信息提示。这个命令应该也能改变PWD 的环境变量。

    environ 列出所有环境变量字符串的设置(类似于Unix 系统下的env 命令)。

    echo 显示echo 后的内容且换行

    help 简短概要的输出你的shell 的使用方法和基本功能。

    jobs 输出shell 当前的一系列子进程,必须提供子进程的命名和PID 号。

    quit,exit,bye 退出shell。

    平台:Centos

    如何用linux系统编写c程序https://blog..net/qq_36328643/article/details/52794876#include

    #include

    #include

    #include

    int main()

    {

    char cmd[2100];

    while(1)

    {

    printf("请输入操作:");

    scanf("%s",cmd);

    int len=strlen(cmd),i;

    if(cmd[0] == 'e' && cmd[1] == 'c') // echo

    {

    int flag=0;

    for( i=5; i

    {

    if(cmd[i]!=' ') flag=1;

    if(flag)

    {

    putchar(cmd[i]);

    }

    }

    if(flag) putchar('\n');

    }

    else if(cmd[0]=='q' || cmd[1]=='x' || cmd[0]=='b') // quit,exit,bye

    {

    printf("Bye\n");

    return 0;

    }

    else if(cmd[0]=='h') // help

    {

    printf("/**********************************/\n");

    printf("echo \tprint a line content\n");

    printf("quit,exit,bye\tend produce\n");

    printf("cd \techo catalog\n");

    printf("jobs\techo process name and pid...\n");

    printf("environ\techo environment variable\n");

    printf("/**********************************/\n");

    }

    else

    {

    char cata[100];

    int cnt=0;

    if(cmd[0]=='c') // cd

    {

    int flag=0;

    for( i=3; i

    {

    if(cmd[i]!=' ') flag=1;

    if(flag)

    {

    cata[cnt++] = cmd[i];

    }

    }

    if(cnt==0)

    {

    cata[0]='.';

    cata[1]='\0';

    }

    }

    /* fork a child process */

    pid_t pid = fork();

    if (pid < 0)

    {

    /* error occurred */

    fprintf(stderr, "Fork Failed");

    return 1;

    }

    else if(pid==0)

    {

    if(cmd[0]=='c') // cd

    {

    execlp("/bin/ls",cata,NULL);

    }

    else if(cmd[0]=='j') // jobs

    {

    execlp("pstree","-p",NULL);

    }

    else if(cmd[0]=='e') // environ

    {

    execlp("env","",NULL);

    }

    }

    else

    {

    /* wait wait,until child process exit*/

    wait();

    }

    }

    printf("\n");

    }

    return 0;

    }

    展开全文
  • 满意答案atmcleaner2013.08.26采纳率:48%等级:12已帮助:9682人#include #include #define MAXARGS 20 /* cmdline args */#define ARGLEN 100 ...

    满意答案

    00e27ab806e4881f8254fe7ae8741834.png

    atmcleaner

    2013.08.26

    00e27ab806e4881f8254fe7ae8741834.png

    采纳率:48%    等级:12

    已帮助:9682人

    #include

    #include

    #define MAXARGS 20 /* cmdline args */

    #define ARGLEN 100 /* token length */

    main()

    {

    char *arglist[MAXARGS+1]; /* an array of ptrs */

    int numargs; /* index into array */

    char argbuf[ARGLEN]; /* read stuff here */

    char *makestring(); /* malloc etc */

    numargs = 0;

    while ( numargs < MAXARGS )

    {

    printf("Arg[%d]? ", numargs);

    if ( fgets(argbuf, ARGLEN, stdin) && *argbuf != '/n' )

    arglist[numargs++] = makestring(argbuf);

    else

    {

    if ( numargs > 0 )

    {

    arglist[numargs]=NULL; /* close list*/

    execute( arglist ); /* do it */

    numargs = 0; /* and reset*/

    }

    }

    }

    return 0;

    }

    execute( char *arglist[] )

    {

    int pid,exitstatus; /* of child */

    pid = fork(); /* make new process */

    switch( pid ){

    case -1:

    perror("fork failed");

    exit(1);

    case 0:

    execvp(arglist[0], arglist); /* do it */

    perror("execvp failed");

    exit(1);

    default:

    while( wait(&exitstatus) != pid );

    printf("child exited with status %d,%d/n",

    exitstatus>>8, exitstatus&0377);

    }

    }

    char *makestring( char *buf )

    /*

    * trim off newline and create storage for the string

    */

    {

    char *cp, *malloc();

    buf[strlen(buf)-1] = '/0'; /* trim newline*/

    cp = malloc( strlen(buf)+1 ); /* get memory*/

    if ( cp == NULL ){ /* or die */

    fprintf(stderr,"no memory/n");

    exit(1);

    }

    strcpy(cp, buf); /* copy chars */

    return cp; /* return ptr */

    }

    01分享举报

    展开全文
  • 简单shell命令行解释器设计与实现思路&分析结果代码(linux执行下) 思路&分析 1.背景知识 本实验要使用创建子进程的fork()函数,执行新的命令的exec ()系列函数,通常shell是等待子进程结束后再接受用户新...

    简单shell命令行解释器的设计与实现

    思路&分析

    1.背景知识
    本实验要使用创建子进程的fork()函数,执行新的命令的exec ()系列函数,通常shell是等待子进程结束后再接受用户新的输入,这可以使用waitpid()函数。
    2.设计步骤
    提示:shell的主体就是反复下面的循环过程
    while(1){
    接收用户输入的命令行;
    解析命令行;
    if(用户命令为内部命令)
    直接处理;
    elseif(用户命令为外部命令)
    创建子进程执行命令;
    else
    提示错误的命令;
    }
    3.根据设计步骤逐步完成各个命令

    1. 首先是接受键盘的输入数据,这里我们采用一个字符串数组,一个一个字符读入,赋值给该字符串数组。

    2. 解析命令行:将输入数据按照空格分开,第一个字符串为命令,之后几个为参数。

    3. 根据第一个字符串参数判断是什么命令。

    4. 若为echo,后面有数据则输出。

    5. 若为cd,则利用chdir()函数切换目录,然后通过自己写的pwd()函数获取当前目录输出。

    6. 若为help命令,直接输出相关内容。

    7. environ,则通过fork()创建子进程,利用函数exec()执行,env命令。

    8. jobs,自己写一个函数获取当前shell的进程名和进程ID,Linux下的当前正在运行的进程信息均存放在/proc目录下,有一系列以数字为名的子目录,每一个子目录对应一个进程,子目录名就是进程的pid。子目录下的status文件内容就是进程的基本信息,包括进程名、pid、ppid等。因此,若要扫描系统当前正在运行的所有进程,只需要遍历/proc目录下所有以数字为名的子目录下的status即可。据此,可得到获取当前系统所有进程快照、根据pid获得进程名和根据进程名获得pid的程序。该命令参照博客链接

    9. quit,bye,exit,直接用exit()即可。

    结果

    结果截图一:help,echo,cd,pwd
    在这里插入图片描述
    结果截图二:jobs,envirn,bye
    在这里插入图片描述

    代码(linux执行下)

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <unistd.h>
    #include <pwd.h>
    #include <dirent.h>
    
    #define BUF_SIZE 1024
    #define MAX_PROCESS_PATH 1024
    #define PROC_NAME_FIELD ("name:")
    #define PARENT_PID_FIELD ("ppid:")
    #ifndef __cplusplus
    typedef enum {false, true} bool;
    #endif // __cplusplus
    
    typedef struct __tagProcessEntry
    {
       pid_t pid;
       pid_t ppid;
       char processName[MAX_PROCESS_PATH];
    } ProcessEntry;
    
    void string2lower(const char src[], char dest[])
    {
       int length = strlen(src);
       int index;
       for(index = 0; index < length; index ++)
       {
          dest[index] = ((src[index] >= 'A') && (src[index] <= 'Z')) ? src[index] + 0x20 : src[index];
       }
       dest[length] = '\0';
    }
    
    int createProcessSnapshot(ProcessEntry pes[], int maxCount)
    {
       int processCount = 0;
       DIR *dir;
       struct dirent *dirEntry;
       FILE *fp;
       char filePath[MAX_PROCESS_PATH];
       char fieldName[32];
       char fieldValue[MAX_PROCESS_PATH];
       char buf[BUF_SIZE];
    
       dir = opendir("/proc");
       if (NULL != dir)
       {
          while((dirEntry = readdir(dir)) != NULL) //循环读取路径下的每一个文件/文件夹
          {
             //如果读取到的是"."或者".."则跳过,读取到的不是文件夹名字也跳过
             if ((strcmp(dirEntry->d_name, ".") == 0) || (strcmp(dirEntry->d_name, "..") == 0) || (DT_DIR != dirEntry->d_type))
             {
                continue;
             }
    
             sprintf(filePath, "/proc/%s/status", dirEntry->d_name); //生成要读取的文件的路径
             fp = fopen(filePath, "r");
             if (NULL != fp)
             {
                do {
                   if (fgets(buf, BUF_SIZE - 1, fp) == NULL)
                   {
                      break;
                   }
                   sscanf(buf, "%s %s", fieldName, fieldValue);
                   string2lower(fieldName, fieldName);
                   if (strcmp(fieldName, PROC_NAME_FIELD) == 0)
                   {
                      strcpy(pes[processCount].processName, fieldValue);
                   }
                   else if (strcmp(fieldName, PARENT_PID_FIELD) == 0)
                   {
                      pes[processCount].ppid = atoi(fieldValue);
                   }
                } while(!feof(fp));
                fclose(fp);
    
                pes[processCount].pid = atoi(dirEntry->d_name);
                processCount ++;
                if (processCount >= maxCount)
                {
                   break;
                }
             }
          }
          closedir(dir);
       }
       return processCount;
    }
    
    int getPidByName(const char *procName, pid_t pids[], int maxCount)
    {
       DIR *dir;
       struct dirent *dirEntry;
       FILE *fp;
       char filePath[MAX_PROCESS_PATH];
       char currProcName[MAX_PROCESS_PATH];
       char buf[BUF_SIZE];
       int pidCount = 0;
    
       dir = opendir("/proc");
       if (NULL != dir)
       {
          while((dirEntry = readdir(dir)) != NULL) //循环读取路径下的每一个文件/文件夹
          {
             //如果读取到的是"."或者".."则跳过,读取到的不是文件夹名字也跳过
             if ((strcmp(dirEntry->d_name, ".") == 0) || (strcmp(dirEntry->d_name, "..") == 0) || (DT_DIR != dirEntry->d_type))
             {
                continue;
             }
    
             sprintf(filePath, "/proc/%s/status", dirEntry->d_name); //生成要读取的文件的路径
             fp = fopen(filePath, "r"); //打开进程描述文件
             if (NULL != fp)
             {
                if (fgets(buf, BUF_SIZE - 1, fp) == NULL)
                {
                   fclose(fp);
                   continue;
                }
                sscanf(buf, "%*s %s", currProcName);
    
                if (strcmp(procName, currProcName) == 0)
                {
                   pids[pidCount] = atoi(dirEntry->d_name);
                   pidCount ++;
                   if (pidCount >= maxCount)
                   {
                      break;
                   }
                }
                fclose(fp);
             }
          }
          closedir(dir);
       }
       return pidCount;
    }
    
    bool getNameByPid(pid_t pid, char procName[])
    {
       char pidPath[BUF_SIZE];
       char buf[BUF_SIZE];
       bool success = false;
    
       sprintf(pidPath, "/proc/%d/status", pid);
       FILE *fp = fopen(pidPath, "r");
       if (NULL != fp)
       {
          if (fgets(buf, BUF_SIZE - 1, fp) != NULL)
          {
             sscanf(buf, "%*s %s", procName);
             success = true;
          }
          else
          {
             success = false;
          }
          fclose(fp);
       }
    
       return success;
    }
    void print()
    {
    	struct passwd *usrname;
    	usrname = getpwuid(getuid());
    	char buf[256];
    	memset(buf,0,sizeof(buf));
    	printf("[my_shell:%s]",getcwd(buf,256));
    	if(strcmp(usrname->pw_name,"root")==0)
    		printf("#");
    	else
    		printf("$");
    }
    
    int shellJudgment(char *arglist[],int args_num)
    {
        if(strcmp(arglist[0],"cd")==0||strcmp(arglist[0],"pwd")==0)
            return 1;//cd
        else if(strcmp(arglist[0],"help")==0&&(args_num==1))//help
            return 2;
        else if(strcmp(arglist[0],"environ")==0&&(args_num==1))//environ
            return 3;
        else if(strcmp(arglist[0],"echo")==0)//echo
            return 4;
        else if(strcmp(arglist[0],"jobs")==0)//jobs
            return 5;
        else if((strcmp(arglist[0],"quit")==0)||(strcmp(arglist[0],"exit")==0)||(strcmp(arglist[0],"bye")==0)&&(args_num==1))//bye
            return 6;
        else
            return 0;
        return 0;
    }
    void pwd()
    {
        char buf[1024];
        char *cwd =getcwd(buf, sizeof(buf));
        if (NULL == cwd) {
            perror("Get cerrent working directory fail.\n");
            exit(-1);
        } else {
            printf("Current working directory is : %s\n", cwd);
        }
    }
    void printPID()
    {
       char procName[MAX_PROCESS_PATH];
       pid_t pids[32];
       ProcessEntry pes[1024];
    
       pid_t currPid = getpid();
       printf("pid of this process:%d\n", currPid);
       getNameByPid(currPid, procName);
       printf("task name is %s\n", procName);
       strcpy(procName, "eclipse");
       int pidCount= getPidByName(procName, pids, sizeof pids / sizeof pids[0]);
       int index=0;
       for(index = 0; index < pidCount; index ++)
       {
          printf("pid of process %s: %d\n", procName, pids[index]);
       }
    
       int procCnt = createProcessSnapshot(pes, sizeof pes / sizeof pes[0]);
       printf("%d processes found.\n", procCnt);
       for(index = 0; index < procCnt; index ++)
       {
          printf("processName: %-16s, pid: %6d\n", pes[index].processName, pes[index].pid);
       }
    }
    int main()
    {
        char cmd[512];
        int flag,i,k,pid;
        char c;
        while(1){
            print();
            k=0;
            //-----------------read command-----------------
            while(1)
            {
                c=getchar();
                if(c!='\n')
                    cmd[k++]=c;
                else
                {
                    cmd[k++]='\0';
                    break;
                }
            }
            //-----------------read command-----------------------
           //------------------Parsing command--------------------
            char *arglist[20]={0};
            char *cp=cmd;
            int args_num=0;
            int len;
            char *start;
            while(*cp!='\0')
            {
                while(*cp==' '||*cp=='\t')
                    cp++;
                start=cp;
                len=1;
                c=*++cp;
                while(c!='\0'&&c!='\t'&&c!=' ')
                {
                    len++;
                    c=*++cp;
                }
                arglist[args_num]=(char *)malloc(len+1);
                strncpy(arglist[args_num],start,len);
                arglist[args_num][len]='\0';
                args_num++;
            }
            //---------Parsing command-----------------------------
            flag=0;
            flag=shellJudgment(arglist,args_num);
    	//cd
            if(flag==1)
            {
    	    if(strcmp(arglist[0],"cd")==0)
    	    {
    		if(args_num==1)
    		    pwd();
           		else if(args_num==2)
    		 {
    		   if(chdir(arglist[1])==-1)
    			printf("error directory\n");
    		 }
    
      	    }
    	    else
    		pwd();
            }
            //---------help----------------------------------------
            else if(flag==2)
            {
                printf("______________________________________________________________________________\n");
                printf("The following are the commands and functions of my shell\n");
                printf("command              function\n");
    	    printf("______________________________________________________________________________\n");
                printf("cd                   Change the current working directory to another directory\n");
                printf("environ              List all environment variable string settings\n");
                printf("echo<content>        Display the content after echo and wrap\n");
                printf("help                 Display the ways and functions of my shell\n");
                printf("jobs                 Output the current series of sub-processes of the shell, the command and PID of the sub-process must be provided\n");
                printf("quit/exit/bye        Exit the shell\n");
                printf("______________________________________________________________________________\n");
    
            }
            //-----------------echo---------------------------------------
            else if(flag==4)
            {
                if(args_num==2){
                    printf("%s",arglist[1]);
                }
                printf("\n");
    
            }
            //-----------------Bye----------------------------------------------
            else if(flag==6)
            {
                printf("Bye\n");
                for(i=0;i<args_num;i++)
                {
                    free(arglist[i]);
                }
                return 0;
            }
            else if(flag==0)
                printf("error command!\n");
            //-----------------  environ  jobs-----------------------------
            else if(flag==5)//jobs
            {
                printPID();
            }
            else
            {
                pid_t pid;
                /* fork a child process */
                pid = fork();
                if (pid < 0)
                {   /* error occurred */
                    fprintf(stderr, "Fork Failed!");
                    return 1;
                }
                else if (pid == 0)
                {
                    if(flag==3)//environ
                    {
                        execlp("env","",NULL);
                        return 0;
                    }
                }
                else
                {
                    wait(NULL);
                }
            }
    
        }
        return 0;
    }
    
    
    展开全文
  • 简单 shell 命令行解释器设计与实现 linux上创建一个文件,复制下面代码,改文件名为.c编译运行即可. #include <stdio.h> #include <unistd.h> #include <string.h> #include <sys/wait.h>...
  • 操作系统实验:简单 shell 命令行解释器设计与实现 #include <stdio.h> #include <unistd.h> #include <string.h> //help方法 void help() { char str[100]; scanf("%s", str); if(strcmp(...
  • 声明为提高教学质量,我所在的学院正在筹划编写C语言教材。《用C语言写解释器》系列文章经整理后将收入书中...起因近期,我们学院老师联系我,希望我能提供一段用 C 语言编写的 BASIC 解释器,用于 C 语言课程设计教...
  • 在Linux环境下模拟实现命令解释器一.程序概述1.进入系统概述本次课程设计是在红帽Linux发行版(Red Hat Enterprise Linux AS release 4 (Nahant Update 4)))环境下运行,内核为:Kernel 2.6.9-42.ELsmp on an i686。...
  • 满意答案uqjwfrkgh2013.12.17采纳率:42%等级:7已帮助:163人#include#include#includeintmain(){FILE*pfp;charcmd[512];charret[1025];while(1){printf("$");memset(cmd,0,sizeof(cmd));fgets(cmd,511,stdi...
  • 自编简单的shell命令解释器要求及代码发布时间:2009-09-04 08:16:37来源:红联作者:傻蛋要求:第0步:写一个最简单的shell命令解释器,本程序取自APUE例1-5,命令不能带参数。学员需要完成的内容如下:命令解释器首先...
  • python设计模式之解释器模式对每个应用来说,至少有以下两种不同的用户分类。[ ] 基本用户:这类用户只希望能够凭直觉使用应用。他们不喜欢花太多时间配置或学习应用的内部。对他们来说,基本的用法就足够了。[ ] ...
  • c语言模拟shell命令行解释程序北京联合大学《操作系统课程设计》实验一:命令行解释程序学 院: 信息学院 专 业: 计算机科学与技术 课 程:操作系统 班 级: 1 1 0 3 B 姓 名: 傅笔贵学 号: 20090803053022014年...
  • 一 需求分析程序实现的功能如下:显示当前所在目录的路径名列出指定目录中所有的目录和文件改变当前工作目录新建一个目录即新建一个文件夹删除一个目录即删除一个文件夹退出命令解释程序重命名一个文件或目录复制...
  • 目 录摘 要1前言21 绪论31.1 Shell的定义31.1.1 UNIX Shell31.2 shell的历史41.3 shell的职责42开发环境和开发工具介绍62.1开发环境--Ubuntu62.2开发工具-GCC63 模拟shell设计73.1简单shell设计思想73.2复杂shell...
  • 目 录摘 要1前言21 绪论31.1 Shell的定义31.1.1 UNIX Shell31.2 shell的历史41.3 shell的职责42开发环境和开发工具介绍62.1开发环境--Ubuntu62.2开发工具-GCC63 模拟shell设计73.1简单shell设计思想73.2复杂shell...
  • 目 录摘 要1前言21 绪论31.1 Shell的定义31.1.1 UNIX Shell31.2 shell的历史41.3 shell的职责42开发环境和开发工具介绍62.1开发环境--Ubuntu62.2开发工具-GCC63 模拟shell设计73.1简单shell设计思想73.2复杂shell...
  • 在Windows环境中,进行golang程序的开发,配置好go环境变量后,使用vscode编辑开发、调试golang程序过程中,发现使用vscode的命令行终端无法识别环境变量参数。 查阅资料,发现大多写的都是设置vscode为“以管理...
  • CCF真题之命令行选项

    2021-01-14 10:09:17
    201403-3问题描述请你写一个命令行分析程序,用以分析给定的命令行里包含哪些选项。每个命令行由若干个字符串组成,它们之间恰好由一个空格分隔。这些字符串中的第一个为该命令行工具的名字,由小写字母组成,你的程序...
  • python简介Python 是一种解释型、面向对象、动态数据类型的高级程序设计语言,语法简介、清晰,具有丰富和强大的类库,它常被称为胶水语言,能够很轻松的将其他语言制作的模块结合在一起。结合自己的感受而谈,...
  • 5.exit退出命令解释器。 6.myrename将文件或文件夹重命名。 7.mycp复制当前已存在的文件。 8.myfind在指定的目录查找指定的文件或文件夹,并输出绝对路径。 9.mylist列出目录名中全部的目录和文件。 1.mydate显示与...
  • 包含: 解释器、即时编译器、垃圾回收器 作用: 执行引擎(Execution Engine)的任务就是将字节码指令解释/编译为对应平台上的本地机器指令才可以。简单来说,JVM中的执行引擎充当了将高级语言翻译为机器语言的译者。 ...
  • 借鉴 C 语言的历史,学习如何用 Python 编写...最初……首先,从 Unix 的角度谈谈命令行界面设计。Unix 是一种计算机操作系统,也是 Linux 和 macOS(以及许多其他操作系统)的祖先。在图形用户界面之前,用户通过命令...
  • WinRAR命令行参数整理

    2020-12-22 07:45:32
    -as: 这是一个开关,指添加方式是“同步压缩文件内容” -r: 表示“包含子文件夹” -sfx: 表示建立的是一个自解压文件 -zsfxpara.txt: 从文件sfxpara.txt读取压缩文件注释,这注释有什么用后面解释 -ep1: 表示不把...
  • 相关推荐随着开源软件在世界范围...发表于 2018-04-26 15:32•33次阅读 我们现在知道 fc 命令不带任何参数的话会将上一个命令载入编辑。但有时你可能不想编辑,仅仅是想再次...发表于 2018-04-26 15:29•25次阅读 ...
  • 【转载】FPGA功耗的那些事儿 在项目设计初期,基于硬件电源模块的设计考虑,对FPGA设计中的功耗估计是必不可少的. 笔者经历过一个项目,整个系统的功耗达到了100w,而单片FPGA的功耗估计得到为20w左右, 有点过高了,功耗...
  • 初始后端实现框架后端支持编译器和解释器。现在框架抽象类Backend有两个极简版实现,一个为编译器另一个为解释器。图2-7 展示了它们的UML类图。图2-7 子类CodeGenerator和Executor分别是后端的编译器和解析器实现。...
  • 更改Python命令行交互提示符的方法

    千次阅读 2021-03-06 18:44:08
    更改Python命令行交互提示符的方法发布于 2015-10-16 08:55:40 | 127 次阅读 | 评论: 0 | 来源: 网友投递Python编程语言Python 是一种面向对象、解释型计算机程序设计语言,由Guido van Rossum于1989年底发明,第一...
  • 命令解释器shell

    2021-03-18 18:32:27
    shell就是一个命令*,它为用户提供了一个向Linux内核发送请求以便运行程序界面系统级程序。* 标准输入输出文件描述符 标准输入的文件描述符为0 标准输出的文件描述符为1 标准错误文件的描述符为2 commannd>file...
  • 一、为什么要学linux命令Linux是由命令行组成的操作系统,精髓在命令行,无论图形界面发展到什么水平,命令行方式的操作永远是不会变的。Linux命令有许多强大的功能:从简单的磁盘操作、文件存取,到进行复杂的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 71,448
精华内容 28,579
关键字:

命令行解释器的设计