/* 显示数码管和LED等需要的头文件，其中前面两个是必须的 */
#include "STC15F2K60S2.H"        // 端口地址定义
#include "sys.H"                 // 使用系统的函数定义
#include "displayer.H" 			 // 数码管显示

/* 必须。定义系统工作时钟频率(Hz)，用户要修改成和实际工作频率(下载时)一致，如上图 */
code unsigned long SysClock=11059200;  // code是告诉单片机这个变量的值刷写入ROM，不再改变

/* 用户可以进行自定义数码管显示，主要是通过decode_table */
#ifdef _displayer_H_                         
code char decode_table[]={			/* 值 */
    0x3f,							// 0		
    0x06,							// 1			 
    0x5b,							// 2			 
    0x4f,							// 3			 											
    0x66,							// 4			 									
    0x6d,							// 5			 											
    0x7d,							// 6			 		
    0x07,							// 7			 
    0x7f,							// 8		     
    0x6f,							// 9			 
    0x00,							// 无
    0x08,							// 下-
    0x40,							// 中-
    0x01, 							// 上-
    0x41, 							// 上中-	
    0x48,                 			// 中下-
    0x3f|0x80,						// 带小数点0		
    0x06|0x80,						// 带小数点1			
};  // 也可以采用上面的拼接方式进行段选信息的构造
#endif

/* LED显示函数，可回调 */
void my100mS_callback()
{ 
    // 定义一个LED寄存器类型
    unsigned char a;
    // LED显示左移
    if(a != 0) a=a<<1;
    // 超出了，重置
    else a=0x01;
    // 显示寄存器值
    LedPrint(a);
    /** 
     * 这里仅仅进行一次打印操作 
  	 * 但是每一次a的值从上一次继承下来，实现了移位操作
  	 * a是局部变量
  	 * 从局部变量声明的时候，它就在堆栈空间了，而不是调用函数的时候，才让它入栈的。
     */
}
void main() 
{ 
    // 使用显示设备，需要进行初始化
    DisplayerInit();  
    // 设置显示范围为0-64，实际有效只有0-7，因此有无效地址消耗时间，数码管会出现闪烁变暗
    SetDisplayerArea(0,64);	
    // 八个数码管分别显示1-8
    Seg7Print(1,2,3,4,5,6,7,8);	
    // 利用回调函数，每100ms，就调用一次函数，这么做是为了节省栈空间，因为单片机的栈很小
    SetEventCallBack(enumEventSys100mS, my100mS_callback);
    /* 这里是初始化系统并循环等待事件，如果没有下面这部分，程序运行结束，板子就死了 */
    MySTC_Init();	    
    while(1) { 
        MySTC_OS();    
    }	             
}    

/**********************
    :八位数码管+流水灯
型号:STC15F2K60S2 主频:11.0592MHz
************************/
#include <STC15F2K60S2.h>
#define uint unsigned int
#define uchar unsigned char

uchar arrSeg7Select[] = {0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f}; //显示0-8
uchar arrDigitSelect[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};   	//数码管0-7

/*---------引脚别名定义---------*/
sbit sbtLedSel = P2 ^ 3;   //数码管与LED灯切换引脚

/*---------变量定义---------*/
uchar uiLed = 0x01;        //LED灯值寄存
uint  uiLedCnt = 0;        //LED灯累计计数器
uchar i = 0;               //数码管扫描显示循环

/*---------初始化函数---------*/
void Init()
{
    P0M1 = 0x00;
    P0M0 = 0xff;
    P2M1 = 0x00;
    P2M0 = 0x08;
    sbtLedSel = 0;  //先选择数码管亮
}

/*---------延时函数---------*/
//下为生成1ms的延时函数，通过传入参数n，函数可以延时n毫秒
void delay_ms( uint n )
{
    while( n )
    {
        uchar i, j;
        i = 11;
        j = 190;
        do
        {
            while ( --j );
        }
        while ( --i );
        n--;
    }
}

/*---------主函数---------*/
void main()
{
    Init();
    while( 1 )
    {
        sbtLedSel = 0;
        for( i = 0; i < 8; i++ )
        {
            P0 = 0;
            P2 = arrDigitSelect[i];     //选择数码管的位数
            P0 = arrSeg7Select[i + 1];  //显示对应的数值
            delay_ms( 1 );
        }
        uiLedCnt++;
        sbtLedSel = 1;
        P0 = uiLed;                     //LED显示
        delay_ms( 1 );                  //延时200ms
        if( uiLedCnt == 50 )
        {
            if( uiLed == 0x80 )        //value等于0x80时，重新赋初值0x01
                uiLed = 0x01;
            else
                uiLed = uiLed << 1;    //value值逐一左移
            uiLedCnt = 0;
        }
    }
}

/* 引入端口定义头文件和中断定义头文件 */ 
#include "STC15F2K60S2.h"
#include "intrins.h"

/* 重命名，简写 */
#define uint unsigned int
#define uchar unsigned char

/* 中断1 */
#define i1 interrupt 1

sbit ledSel = P2 ^3;    			// LED或数码管选择信号(共用选择端信号)
sbit key1 = P3 ^2; 					// 按键控制数码管扫描的频率

/* 显示0-9对应的数字，段选选择 */
uchar baseSevenSegment[] = {
    0x3f, 0x06, 0x5b, 0x4f, 0x66,
    0x6d, 0x7d, 0x07, 0x7f, 0x6f
}; 
unsigned char const line = 0x40; 	// "-"：8中中间横杠的段选信息
char timeAddOneFlag = 0;    		// 时间增加标志，为1，时间增加一秒
char key1ActionFlag = 0;     		// 按键操作标志，为1，按键操作需要响应
unsigned int ledOnFlag = 0; 		// LED亮起标志，为1，LED亮起
char tubeOnFlag = 0;        		// 数码管亮标志，为1，数码管亮起
int ledValue = 1;          	 		// LED显示值为多少
int myDisplay[8] = {0};     		// 数码管显示值为多少，一共8个数码管
unsigned int timeCount = 1; 		// 计数器
unsigned int currHour = 0;			// 当前小时
unsigned int currMinute = 0;		// 当前分钟
unsigned int currSecond = 0;		// 当前秒钟
unsigned int interruptCount = 0;	// 中断计数器
unsigned int keyDownTime = 0;		// 按键按下的时间
unsigned int scanTime = 1;  		// 扫描时间
unsigned int currBit = 0;   		// 当前显示的位

/* 延时函数 可以用ISP生成 */
void Delay5us()       //@11.0592MHz
{
    unsigned char i;
    _nop_();
    i = 11;
    while (--i);
}

/* 设置ledSel,转为数码管显示 */
void switchToTube() {
    ledSel = 0;
}

/* 设置ledSel,转为led设置 */
void switchToLed() {
    P0 = 0;
    ledSel = 1;
}

/**
 * 改变其中一位的内容
 *
 * @param bitNum 位数（第几位）（例如最左那位，则调用1）
 * @param value 改变后的数字，需确保大于0小于10
 */
void change1Bit(int bitNum, int value) {
    myDisplay[bitNum - 1] = baseSevenSegment[value];
}

/**
 * 改变其中一位的内容（设置七段码）
 *
 * @param bitNum 位数（第几位）（例如最左那位，则调用1）
 * @param sevenSegCode 目标七段码
 */
void change1Bit_seven(int bitNum, int sevenSegCode) {
    myDisplay[bitNum - 1] = sevenSegCode;
}

/**
 * 数码管设置为显示指定的数值
 *
 * @param num 数字
 */
void changeAll(long num) {
    int i;
    for (i = 7; i >= 0; --i) {
        int foo = num % 10;
        myDisplay[i] = baseSevenSegment[foo];
        num /= 10;
    }
}

/**
 * led亮
 */
void displayLed() {
    if (ledOnFlag) {
        switchToLed();
        P0 = ledValue;
    }
}

/**
 * 显示数码管
 */
void showTube() {
    if (tubeOnFlag) {
        switchToTube();
        P0 = 0;
        P2 = currBit;
        P0 = myDisplay[currBit];
        Delay5us();
    }
}

/**
 * 初始化定时器
 */
void timer0Initialize()        //0.1毫秒@12MHz
{
    AUXR |= 0x80;        // 定时器时钟1T模式
    TMOD &= 0xF0;        // 设置定时器模式
    TL0 = 0xAE;        	 // 设置定时器初值
    TH0 = 0xFB;          // 设置定时器初值
    TF0 = 0;             // 清除TF0标志
    TR0 = 1;             // 定时器0开始计时
    EA = 1; 			 // 打开总的中断
    ET0 = 1; 			 // 打开定时器0中断
}

/**
 * 整体程序初始化函数
 */
void initialize() {
    P0M0 = 0xFF;
    P0M1 = 0x00;
    P2M0 = 0x0f; //设置P2.0-3为推挽工作状态
    P2M1 = 0x00;
    P3M0 = 0x00;
    P3M1 = 0x00;
    P3M0 = 0x00;
    P3M1 = 0x00;
    ledSel = 0;

    timer0Initialize();
    changeAll(0);
    /*
     * 第三位和第六位设置为 '-'
     */
    change1Bit_seven(3, line);
    change1Bit_seven(6, line);
}

/**
 * 时间自增1秒
 */
void addTime() {
    ++currSecond;
    if (currSecond == 60) {
        ++currMinute;
        currSecond = 0;
        if (currMinute == 60) {
            ++currHour;
            currMinute = 0;
            if (currHour == 24)
                currHour = 0;
            change1Bit(2, currHour % 10);
            change1Bit(1, currHour / 10);
        }
        change1Bit(5, currMinute % 10);
        change1Bit(4, currMinute / 10);
    }
    change1Bit(8, currSecond % 10);
    change1Bit(7, currSecond / 10);
}

/**
 * 按下key1要做的事
 */
void key1Action() {
    if (key1ActionFlag) {
        if (ledValue == 0x80)
            ledValue = 0x01;
        else
            ledValue <<= 1;
        if (ledValue == 1)
            scanTime = 1;
        else if (ledValue == 2)
            scanTime = 50;
        else if (ledValue == 4)
            scanTime = 100;
        else if (ledValue == 8)
            scanTime = 200;
        else if (ledValue == 16)
            scanTime = 500;
        else if (ledValue == 32)
            scanTime = 1000;
        else if (ledValue == 64)
            scanTime = 2000;
        else if (ledValue == 128)
            scanTime = 5000;
        key1ActionFlag = 0;
    }
}

/**
 * 收到中断的信号（是时候自增时间了）
 */
void timeSignalHandler() {
    if (timeAddOneFlag) {
        addTime();
        timeAddOneFlag = 0;
    }
}

/**
 * 单片机运行
 */
void run() {
    while (1) {
        timeSignalHandler();
        displayLed();
        showTube();
        key1Action();
    }
}

/**
 * 每0.1毫秒进入一次定时器中断
 */
void interruptFunction() i1 {
    static const int KEY_TIME_THRESHOLD = 500;
    interruptCount = (interruptCount + 1) % 20000;
    // led显示的频率应该低些才有好的显示效果
    if (interruptCount % 12 > 10) {
        ledOnFlag = 1;
        tubeOnFlag = 0;
    } else {
        tubeOnFlag = 1;
        ledOnFlag = 0;
    }
    // 数码管的扫描
    if (interruptCount % scanTime == 0)
        currBit = (currBit + 1) % 8;
    // 读秒
    if (interruptCount % 10000 == 0)
        timeAddOneFlag = 1;
    // 按键功能设置
    if (key1 == 0) {
        if (keyDownTime < KEY_TIME_THRESHOLD)
            ++keyDownTime;
    } else {
        if (keyDownTime >= KEY_TIME_THRESHOLD)
            key1ActionFlag = 1;
        keyDownTime = 0;
    }
}

int main() {
    initialize();
    run();
    return 0;
}

/* 对硬件各个端口的定义的头文件，直接使用即可 */
#include <STC15F2K60S2.h>
/* 重定义类型名，简写 */
#define uint unsigned int
#define uchar unsigned char

uint i=0;
// 段选：选择亮灯
uchar duanxuan[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f};
// 位选：选择哪一个数码管
uchar weixuan[]={0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07};			 

void Delay(int n)				// 延时函数，单位毫秒
{
	while(n--);
}

void main()
{
    /* 设置推挽输出
     * 和流水灯实验类似，对P0端口和P2端口进行设置
     * 端口设置推挽输出，通道0设置“1”，通道0全0，具体见数据手册，流水灯也讲过了
     * 端口0的0通道，是表示位选，八个位对应八个灯管，所以全部设成1
     * 端口2的0通道，是表示段选，一次只能选一个数码管，由三位输入进行选择
     * 分别是：P2.2 P2.1 P2.0
     * 刚好是P2的第三位，所以赋值时候，只要P2 = weixuan[i]
     * 就可以
     * 这里简单将2的0通道全部设成1
     */
	P2M0=0xff;					
   	P2M1=0x00;
    P0M0=0xff;
    P0M1=0x00;
	/* 循环扫描数码管
     * 不断扫描数码管，使每一小段数码管都点亮一段时间
     * 视觉上一直是亮的状态
     */
	while(1)
	{
		for(i=0;i<8;i++)
		{
			P0=0;
			P2=weixuan[i];		// 选择数码管的位数
			P0=duanxuan[i+1];	// 选择对应的数值
			Delay(600);			// 延时
		}
	}
}

/* 这个是我们的单片机的端口的定义 */
/* 如果仔细阅读头文件，可以看到就是用唯一的整数标识每一个端口 */
#include<STC15F2K60S2.H>

/* 定义类型，简写 */
#define uchar unsigned char
#define uint unsigned int

/* 选择位 */
sbit led_sel=P2^3; // 端口P2.3
uchar led;         // 用一个uchar表示8个LED，每一个是1位

void Init() {
	// P0的通道1全0
	P0M1=0x00;
    // P0的通道0全1
	P0M0=0xff;
	// P2的通道1全0
	P2M1=0x00;
    // P2的通道0只要bit3为1
	P2M0=0x08;
	// 流水灯从L0开始(00000001)
	led_sel=1;	
}

void Delay200ms()		//@11.0592MHz
{
	unsigned char i, j, k;
	//_nop_();
	//_nop_();
	i = 9;
	j = 104;
	k = 139;
	do
	{
		do
		{
			while (--k);
		} while (--j);
	} while (--i);
}

void main()
{
    // 初始化LED灯
	Init();
    // 从L0开始亮
	led=0x01;
    // 无休止闪烁
	while(1)
	{
        // P0端口连接LED灯，所以把寄存器LED给P0
		P0=led;
		// 延时200ms	
		Delay200ms();
        // LED寄存器状态赋值
		if(led==0x80) // 如果到了L7灯，下一个状态又从L0开始
			led=0x01;
		else		  // 否则左移一位
			led=led<<1;
	}
	
}

#define NUM_CHAIR 5					// 最大等待椅子数目
#define NUM_CUST  10				// 顾客数量
sem_t customers;         			// 表示有顾客的条件变量
sem_t barber;    	     			// 表示理发师醒了的条件变量
sem_t mutex;              			// 空闲椅子数是共享资源，需要互斥量
int freechairs;      				// 空椅子的数量

void * Barber() {
    while (ture) {	     			// 理发师持续不断工作或者睡眠
        sem_wait(&customers);		// 试图为一个顾客理发，如果没有顾客就睡着
        sem_wait(&mutex);			// 需要修改空椅子的数量(全局变量)，需要上锁
        freechair++;			    // 为一个顾客理发，顾客起身，空一张椅子出来
        sem_post(&barber);			// 此时理发师可以工作，通知顾客过来理发
        sem_post(&mutex);			// 修改完空椅子数目，释放锁
        /* 理发师在理发... */
    }
}

void * Customers() { 	 			// 一个线程仅仅表示一名顾客
    sem_wait(&mutex);    		 	// 想要坐到一张椅子上等待
    if (freechairs > 0) {			// 如果还有空椅子的话
        freechairs--;				// 顾客坐到一张椅子上等待
        sem_post(&customers);		// 唤醒理发师，有顾客来了
        sem_post(&mutex);			// 顾客已经坐到椅子上等待，释放互斥量
        sem_wait(&barber);			// 如果理发师还在忙，就等他
        /* 抢到理发师，此时顾客开始理发 */
    } 
    else {							// 没有空着的椅子 
        sem_post(&mutex);			// 不要忘记试图坐下上的锁(第20行)
        /* 没有椅子坐，直接走了 */
    }
}

int main() {
	/* 初始化 */
    sem_init(&customers, 0, 0);
    sem_init(&barbers, 0, 0);
    sem_init(&mutex, 0, 1);
    freechairs = NUM_CHAIR;
    
    /* 启动理发师和顾客 */
    pthread_t bar, cust[NUM_CUST];
    Pthread_create(&bar, NULL, Barber, NULL);	  	
    for (int i = 0; i < NUM_CUST; i++) {
        Pthread_create(&cust[i], NULL, Customers, NULL);
        sleep(randint(NULL));	  // 每隔一个随机时间来一个顾客
    }
    return 0;
}

int main(int argc, char *argv[])

tsh> /bin/ls -l -d &

/*
 * main - The shell's main routine 
 */
int main(int argc, char **argv) 
{
    char c;
    char cmdline[MAXLINE];
    int emit_prompt = 1; /* emit prompt (default) */

    /* Redirect stderr to stdout (so that driver will get all output
     * on the pipe connected to stdout) */
    dup2(1, 2);	// 把错误信息重定向到标准输出上，也就是输出到屏幕上

    /* Parse the command line */
    // 处理参数
    /*
    * -h 帮助文件
    * -v 发送额外的诊断信息
    * -p 不打印prompt
    */
    while ((c = getopt(argc, argv, "hvp")) != EOF) {
        switch (c) {
        case 'h':             /* print help message */
            usage();
	    break;
        case 'v':             /* emit additional diagnostic info */
            verbose = 1;
	    break;
        case 'p':             /* don't print a prompt */
            emit_prompt = 0;  /* handy for automatic testing */
	    break;
	default:
            usage();
	}
    }

    /* Install the signal handlers */
	// 对各种信号进行处理
    /* These are the ones you will need to implement */
    Signal(SIGINT,  sigint_handler);   /* ctrl-c */
    Signal(SIGTSTP, sigtstp_handler);  /* ctrl-z */
    Signal(SIGCHLD, sigchld_handler);  /* Terminated or stopped child */

    /* This one provides a clean way to kill the shell */
    Signal(SIGQUIT, sigquit_handler); 

    /* Initialize the job list */
    // 初始化作业列表
    initjobs(jobs);

    /* Execute the shell's read/eval loop */
    while (1) {

	/* Read command line */
    // 打印一个prompt符
	if (emit_prompt) {
	    printf("%s", prompt);
	    fflush(stdout);
	}
    // 从标准获得命令行
	if ((fgets(cmdline, MAXLINE, stdin) == NULL) && ferror(stdin))
	    app_error("fgets error");
    
    // EOF: 当输入ctrl-d的时候表示标准输入(文件)结束，此时直接退出
	if (feof(stdin)) { /* End of file (ctrl-d) */
	    fflush(stdout);
	    exit(0);
	}

	/* Evaluate the command line */
	eval(cmdline);		// 解析命令行
	fflush(stdout);
	fflush(stdout);
    } 

    exit(0); /* control never reaches here */
}

/* 
 * eval - evaluate a command line
 */
void eval(char *cmdline) 
{
...
	// 通过把argv传递给buildin_command让它判断是不是内置命令并执行
    // 如果不是返回零
    if (!builtin_command(argv)) { 
...
}
    
/* 
* buildin_cmd
*/  
int builtin_cmd(char **argv) 
{
	...

// EOF: 当输入ctrl-d的时候表示标准输入(文件)结束，此时直接退出
	if (feof(stdin)) { /* End of file (ctrl-d) */
	    fflush(stdout);
	    exit(0);
	}

int builtin_cmd(char **argv);

/* 
 * parseline - Parse the command line and build the argv array.
 * 
 * Characters enclosed in single quotes are treated as a single
 * argument.  Return true if the user has requested a BG job, false if
 * the user has requested a FG job.  
 */

void eval(char *cmdline) 
{	
    // 参数字符串数组
	char *argv[MAXARGS]; /* argv for execve() */
	int bg;              /* should the job run in bg or fg? */
	
	/* parse command line */
    // 解析cmdline获得argv
    bg = parseline(cmdline, argv); 
	if (!builtin_cmd(argv)) { 
    ...
}

/* 
 * builtin_cmd - If the user has typed a built-in command then execute
 *    it immediately.  
 */
int builtin_cmd(char **argv) 
{
	if (!strcmp(argv[0], "quit"))
		exit(0);  /* terminate shell */
    ...

// in `parseline`

/* should the job run in the background? */
    if ((bg = (*argv[argc-1] == '&')) != 0) {
	argv[--argc] = NULL;
    }

/* global variables */
int nextjid = 1;            /* next job ID to allocate */
...
/* addjob - Add a job to the job list */
int addjob(struct job_t *jobs, pid_t pid, int state, char *cmdline) 
{
    int i;
    if (pid < 1)	// 无效pid
        return 0;
    
    for (i = 0; i < MAXJOBS; i++) {	
        /* 如果jobs数组里面有pid等于0等于0的表项，表示这个位置可以用，把这个作业放进去 */
        if (jobs[i].pid == 0) {
            jobs[i].pid = pid;
            jobs[i].state = state;
            jobs[i].jid = nextjid++;
            if (nextjid > MAXJOBS)
                nextjid = 1;
            strcpy(jobs[i].cmdline, cmdline);
            if(verbose){
                printf("Added job [%d] %d %s\n", jobs[i].jid, jobs[i].pid, jobs[i].cmdline);
            }
            return 1;
        }
    }
    printf("Tried to create too many jobs\n");
    return 0;
}

/* fgpid - Return PID of current foreground job, 0 if no such job */
pid_t fgpid(struct job_t *jobs) {
    int i;

    for (i = 0; i < MAXJOBS; i++)
	if (jobs[i].state == FG)
	    return jobs[i].pid;
    return 0;
}

void waitfg(pid_t pid)
{
    while (pid == fgpid(jobs))
        sleep(0); // 这里是指主动让出CPU的意思
}

// in `eval`
...  
    
if (!builtin_cmd(argv)) { 
    if ((pid = fork()) == 0) {  /* child */

        /* Background jobs should ignore SIGINT (ctrl-c)  */
        /* and SIGTSTP (ctrl-z) */
        /*
        if (bg) {
            // 课本对SIG_IGN有详细解释
            // 如果信号的handler是SIG_IGN，会忽略这个信号
            Signal(SIGINT, SIG_IGN);
            Signal(SIGTSTP, SIG_IGN);
        }
        */
        
		// 前台执行
        if (execve(argv[0], argv, environ) < 0) {
            printf("%s: Command not found.\n", argv[0]);
            fflush(stdout);
            exit(0); // 如果没有这个可执行程序，那么直接终止这个子进程
        }
    }
    /* parent waits for foreground job to terminate or stop */
    addjob(jobs, pid, (bg == 1 ? BG : FG), cmdline);
    if (!bg) // 前台运行则等待子进程
        waitfg(pid);
    else
        printf("[%d] (%d) %s", pid2jid(pid), pid, cmdline);
}

/* 
 * sigchld_handler - The kernel sends a SIGCHLD to the shell whenever
 *     a child job terminates (becomes a zombie), or stops because it
 *     received a SIGSTOP or SIGTSTP signal. The handler reaps all
 *     available zombie children, but doesn't wait for any other
 *     currently running children to terminate.  
 */
void sigchld_handler(int sig) 
{
    pid_t pid;
    int status;

    if (verbose)
        printf("sigchld_handler: entering \n");

    /* 
    * 回收僵尸进程
    * 这里的WNOHANG是非常重要的。
    * 它的本意是如果所有孩子都没有僵尸(终止)状态的，直接退出
    * 这个能够避免在这里等待所有前台的running和stopped程序终止
    * 这样tsh就不能正常接受用户的输入了
    * WUNTRACED是等待直到有一个子进程变成僵尸退出，返回它的pid
    * 这个选项开启能够检查已终止和被停止的子进程
    */
    while ((pid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) { 
        // 这里不管是不是正常exit或者ctrl-c或者ctrl-z退出的
        // 子进程都结束了，都要回收资源
        deletejob(jobs, pid);
        if (verbose)
            printf("sigchld_handler: job %d deleted\n", pid);
    }
    if (verbose)
        printf("sigchld_handler: exiting\n");
}

// in `eval`
...   
sigset_t mask;
    
if (!builtin_cmd(argv)) {
        Sigprocmask(SIG_BLOCK, &mask, &prev);  /* 阻塞SIGCHLD */

        if ((pid = fork()) == 0) {   /* Child runs user job */
            /* 给fork出来的子进程设置一个独立的组，
	 		 * 子进程是这个组的组长,组id为子进程的pid */
            setpgid(0, 0);	
            
            /* 对于子进程并不需要阻塞SIGCHLD的信号 */
            Sigprocmask(SIG_UNBLOCK, &prev, NULL);  // unblock SIGCHLD
            
            /* 
            * 前台执行 
            * 如果没有这个可执行程序，那么直接终止这个子进程
            */
            if (execve(argv[0], argv, environ) < 0) {
                printf("%s: Command not found.\n", argv[0]);
                _exit(1);
            }
        }

        addjob(jobs, pid, bg ? BG : FG, cmdline);
        /* 已经加到jobs了，解除阻塞 */
        Sigprocmask(SIG_SETMASK, &prev, NULL);  


        /* Parent waits for foreground job to terminate */
        if (!bg)  // 前台运行则等待子进程
            waitfg(pid);
        else      // background
            printf("[%d] (%d) %s", pid2jid(pid), pid, cmdline);
    }

/* listjobs - Print the job list */
void listjobs(struct job_t *jobs) 
{
    int i;

    for (i = 0; i < MAXJOBS; i++) {
        if (jobs[i].pid != 0) {
            printf("[%d] (%d) ", jobs[i].jid, jobs[i].pid);
            switch (jobs[i].state) {
                case BG: 
                    printf("Running ");
                    break;
                case FG: 
                    printf("Foreground ");
                    break;
                case ST: 
                    printf("Stopped ");
                    break;
                default:
                    printf("listjobs: Internal error: job[%d].state=%d ", 
                           i, jobs[i].state);
            }
            printf("%s", jobs[i].cmdline);
        }
    }
}

int builtin_cmd(char **argv) 
{
    ...
    // jobs command    
    if (!strcmp(argv[0], "jobs")) {        
        listjobs(jobs);        
        return 1;    
    }
    ...

void sigint_handler(int sig)
{
    // 这一步的保存和下一步的恢复，是由于在下面的kill系统调用中可能会覆盖errno的值
    // 导致现在的errno丢失
    // 而errno在sigchild_handler中还有使用到，为了避免产生这种错误需要在这里保存，在后面恢复
    int olderrno = errno;
    // get the foreground job pid
    pid_t fg_pid = fgpid(jobs);
    /*
    * int kill(pid_t pid,int signo)
 	* 功能: 向进程或进程组发送一个信号 （成功返回 0； 否则，返回 -1 ）
    */
    kill(-fg_pid, sig); 
    // -fg_pid表示向进程组号为pid的组中的每个进程发sig信号
    // 在这里就是向前台进程以及它的每一个子进程(子进程都在自己的父进程的pid为组id的组下)
    errno = olderrno;
}

void sigtstp_handler(int sig)
{
    // 为了异步信号安全防止errno被覆盖
    int olderrno = errno;
    // get the foreground job pid
    pid_t fg_pid = fgpid(jobs);
    // kill the group in the foreground
    kill(-fg_pid, sig);
    errno = olderrno;
}

/*
 * sigchld_handler - The kernel sends a SIGCHLD to the shell whenever
 *     a child job terminates (becomes a zombie), or stops because it
 *     received a SIGSTOP or SIGTSTP signal. The handler reaps all
 *     available zombie children, but doesn't wait for any other
 *     currently running children to terminate.
 */
void sigchld_handler(int sig)
{
    int old_errno = errno;

    pid_t pid;
    int status;
    
    if (verbose)
        printf("sigchld_handler: entering \n");

   /* 
    * 回收僵尸进程
    * 这里的WNOHANG是非常重要的。
    * 它的本意是如果所有孩子都没有僵尸(终止)状态的，直接退出
    * 这个能够避免在这里等待所有前台的running和stopped程序终止
    * 这样tsh就不能正常接受用户的输入了
    * WUNTRACED是等待直到有一个子进程变成僵尸退出，返回它的pid
    */
    while ((pid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
        /* 这里实验指导书说不能用while，但是不用会出现错误。他说的while和我的判断条件不一样 */
        // 子进程正常退出
        if (WIFEXITED(status)) {
            deletejob(jobs, pid);
        }
        // 子进程因为ctrl-c退出
        if (WIFSIGNALED(status)) { // terminated by ctrl-c
            printf("Job [%d] (%d) terminated by signal %2d\n", 
                   pid2jid(pid), pid, WTERMSIG(status));
            deletejob(jobs, pid); 
        }
        if (WIFSTOPPED(status)) { // stopped by ctrl-z
            printf("Job [%d] (%d) stopped by signal %2d\n",
                   pid2jid(pid), pid, WSTOPSIG(status));
            // 修改子进程状态为ST
            getjobpid(jobs, pid)->state = ST;
        }
    }
    errno = old_errno;
    if (verbose) 
        printf("sigchld_handler: exiting\n");  
}

int sio_puts(char s[]) /* Put string */
{
    return write(STDOUT_FILENO, s, strlen(s));
}