/* 頭文件head.h*/
#include <stdio.h>
#include <limits.h>
#include <signal.h>
#include <fcntl.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define MAXINPUTLN 120
/*輸出行的最大長度*/
#define MAXARG 15
/*一個簡單命令的最大數目*/
#define PIPELINE 5
/*一個管道的最大簡單命令數*/
#define MAXNAME 100
/*I/O重定向文件名字的最大長度*/

char inputln[MAXINPUTLN+1];
/*用戶的輸入 */
char *inputlnptr;
/* 指向當前inputln[ ]數組的當前位置*/
char avline[MAXINPUTLN+1];
/*從inputln[ ]數組中提取出來的參數字符串 */
char *avptr;
/*指向avline[]數組中的當前位置*/
char infile[MAXINPUTLN+1];
/* 輸入重定向文件的名字*/
char outfile[MAXNAME+1];
/*輸出重定向文件的名字*/
int background;
/*為TRUE時為后臺命令（命令行以&結尾，否則為前臺，*/
int lastpid;
/*管道中最后一條簡單命令的進程標識*/
int append;
/*如果為TRUE表示命令結尾用>>來說明附加在某文件末尾*/

struct cmd
{
	char *av[MAXARG];
		/*存放命令和參數的一維數組*/
	int infd;
	int outfd;
}cmdlin[PIPELINE];
/*一個簡單命令結構*/

/*主過程main.c*/
//#include "head.h"

main(void)
{
	int j;

	init_once( );
		/*對程序進行初始化*/
	for(;;)
	{
		init_command( );
			/*每執行一條命令都要進行一次初始化*/
		if(get_comln( ))
			/*得到命令行輸入*/
			if(j=get_simcom())
				/*分析出簡單命令的個數*/
				execute(j);
					/*執行這j個命令*/
	}
}

/*初始化文件init.c*/
init_once(void)
{
	signal(SIGINT,SIG_IGN);
	signal(SIGQUIT,SIG_IGN);
}

init_command(void)
/*每次輸入命令都要進行初始化*/
{
	int k;
	background=FALSE;
	inputlnptr=inputln;
	avptr=avline;
	infile[0]= '\0';
	outfile[0]= '\0';
	append=FALSE;

	for(k=0;k<OPEN_MAX;++k)
	{
		cmdlin[k].infd=0;
		cmdlin[k].outfd=1;
	}
	for(k=3;k<OPEN_MAX;++k)
		close(k);
	printf("tsh:");
	fflush(stdout);
}

/*語法分析文件get_simcom.c*/
get_simcom(void)
{
	int m;

	get_simarg(0);
	/*先分析第一條簡單命令*/

	if(check( "<"))
	/*如果有輸入文件，就記錄輸入文件名*/
		get_word(infile);
	/*下面是循環分析管道中的每一條簡單命令*/
	for(m=1;m<PIPELINE;++m)
	{
		if(check("|"))
			get_simarg(m);
		else
			break;
	}
		
/*如果有輸出文件，記錄輸出文件名*/
	if(check( ">"))
	{
		if(check( ">"))
		/*輸出到某文件的末尾*/
			append=TRUE;
		get_word(outfile);
	}

		/*后臺運行命令*/
	if(check( "&"))
		background=TRUE;
		/*下面代碼分析完整個命令，返回簡單命令個數*/
	if(check( "\n"))
		return(m);
	else
		/*如果沒分析完畢，說明輸入的命令行有語法錯誤*/
	{
		fprintf(stderr, "Command line syntax error\n");
		return(ERROR);
	}
}

/*得到下一個標識符get_word.c*/
get_word(char *name)
{
	int m;

	/*從inputln[]中得到一個單詞，也就是一個標識符*/
	for(m=0;m<MAXNAME;++m)
	{
		switch(*inputlnptr)
		{
			case ' ':
			case '|':
			case '>':
			case '\n':
			case '<':
			case '&':
			case '\t':
				*name='\0';
				return;
			default:
				name=inputlnptr++;
				name++;
		}
	}
	*name= '\0';
}

/*得到當前命令行get_comin.c*/
get_comln(void)
{
	int m;

	for(m=0;(inputln[m]=getchar( ))!= '\n'&& m<MAXINPUTLN;++m);
	if(m==MAXINPUTLN)
		/*如果輸入的命令超過了最大長度，就報錯*/
	{
		fprintf(stderr, "Command line too long\n");
		return(ERROR);
	}
	inputln[m+1]='\0';
	return(OK);
}

/*執行簡單命令run_com.c*/
run_com(struct cmd *ptr)
{
	int k,pid;

	if(pid=fork( ))
		/*父進程*/
	{
		if(background==TRUE)
			printf( "%d\n",pid);
			/*如果是后臺命令，打印出進程標識*/
		lastpid=pid;
			/*記錄最后一個簡單命令的進程標志*/
	}
	else
	{
			/*如果是后臺進程要關閉鍵盤輸入*/
		if(ptr->infd==0&&background==TRUE)
			ptr->infd=open( "/dev/null",O_RDONLY);
			/*對輸入進行重定向*/
		if(ptr->infd!=0)
		{
			close(0);
			dup(ptr->infd);
		}
			/*對輸出進行重定向*/
		if(ptr->outfd!=1)
		{
			close(1);
			dup(ptr->outfd);
		}

			/*前臺進程可以接受鍵盤輸入的中斷和退出信號*/
		if(background==FALSE)
		{
			signal(SIGINT,SIG_DFL);
			signal(SIGQUIT,SIG_DFL);
		}
			/*關閉其它文件描述符，使得除了標準輸入、標準輸出和錯誤輸出2外設置的管道和I/O重定向*/
		for(k=3;k<OPEN_MAX;++k)
			close(k);
			/*下面代碼執行一條簡單命令*/
		execvp(ptr->av[0],ptr->av);
		exit(1);
	}
}

/*執行輸入的命令的文件execute.c*/
execute(int j)
{
	int m,fd,fds[2];

	if(infile[0]!='\0')
	/*如果命令指定了輸入文件則打開輸入文件*/
		cmdlin[0].infd=open(infile,O_RDONLY);
	if(outfile[0]!= '\0')
		/*如果命令指定了輸出文件則打開相應的輸出文件*/
		if(append==FALSE)
			cmdlin[j-1].outfd=open(outfile,O_WRONLY|O_CREAT|O_TRUNC,0666);
		else
			cmdlin[j-1].outfd=open(outfile,O_WRONLY|O_CREAT|O_APPEND,0666);
		/*對前臺進程和后臺進程進行不同的處理*/
	if(background)
		signal(SIGCHLD,SIG_IGN);
	else
		signal(SIGCHLD,SIG_DFL);
		/*循環執行每個簡單命令*/
	for(m=0;m<j;++m)
	{
			/*對管道進行操作*/
		if(m<j-1)
		{
			pipe(fds);
			cmdlin[m+1].infd=fds[0];
			cmdlin[m].outfd=fds[1];
		}
			/*執行一條簡單命令*/
		run_com(&cmdlin[m]);
			/*關閉該命令的輸入*/
		if(fd=cmdlin[m].infd)
			close(fd);
			/*關閉該命令的輸出*/
		if((fd=cmdlin[m].outfd)!=1)
			close(fd);
	}
		/*如果不是后臺命令，等待直到最后一條簡單命令執行完畢*/
	if(background==FALSE)
		while(wait(NULL)!=lastpid);
}

	/*分析簡單命令get_sirmarg.c*/
get_simarg(int j)
{
	int m,tag,inword;

	for(m=0;m<MAXARG-1;++m)
	{
		while(*inputlnptr== ' '||*inputlnptr== '\t')
			/*跳過空格符合Tab符*/
			++inputlnptr;

			/*在cmd數組中存放的j個量，如果j為0則為命令，否則為參數*/
		cmdlin[j].av[m]=avptr;
		cmdlin[j].av[m+1]=NULL;
		for(tag=0;tag==0;)
		{
			switch(*inputlnptr)
			{
				case ' ':
				case '\t':
					inword=FALSE;
						/*對于這兩種情況指定下一個參數*/
					*avptr++= '\0';
					tag=1;
					break;
				case '>':
				case '\n':
				case '<':
				case '&':
				case '|':
					if(inword==FALSE)
						/*對于以上幾種情況改命令結束*/
						cmdlin[j].av[m]=NULL;
					*avptr++= '\0';
					return;
				default:
					/*否則說明參數的名字還不全*/
					inword=TRUE;
					avptr=inputlnptr;
					avptr++;
					break;
			}
		}
	}
}

	/*字符串匹配check.c*/
check(char *ptr)
{
	char *tptr;
		
	while(*inputlnptr== ' ')
		/*跳過空格符*/
		inputlnptr++;
	tptr=inputlnptr;
	while(*ptr!= '\0'&&*ptr==*tptr)
		/*循環比較兩個字符串是否相等*/
	{
		ptr++;
		tptr++;
	}
	if(*ptr= '\0')
		/*比較結果相等*/
	{
		inputlnptr=tptr;
	/*修改inputlnptr指針*/
		return(TRUE);
	}
	else
	/*比較結果不相等*/
		return(FALSE);
}