diff --git a/student-distrib/Proc.c b/student-distrib/Proc.c
deleted file mode 100644
index 44b824291c9031bfa63fc01be699fcbc7539950d..0000000000000000000000000000000000000000
--- a/student-distrib/Proc.c
+++ /dev/null
@@ -1,13 +0,0 @@
-
-#include "Proc.h"
-
-
-void control_initilization(void){
-
-    int i;
-    for(i = 0; i < MAX_PROCESS; i++) 
-    	control.pid_array[i] = 0;
-
-    control.total_prog_count = 0;
-    control.cur_terminal = 0;
-}
diff --git a/student-distrib/Proc.h b/student-distrib/Proc.h
index 04f4dfbb0ade884e493ff069f09fcf4717812f64..4f170574d6472f25012e96b4fce255d5ab45a8bf 100644
--- a/student-distrib/Proc.h
+++ b/student-distrib/Proc.h
@@ -1,6 +1,29 @@
 #include "lib.h"
 #include "types.h"
+#include "x86_desc.h"
 
+#include "rtc.h"
+#include "keyboard.h"
+#include "terminal.h"
+#include "filesys.h"
 
+/* Mask to get 8KB page */
+#define PCB_M           0xFFFFE000
 
-void control_initilization(void);
+
+extern int32_t fail(); // Error handling helper function
+extern void control_initilization(void);
+extern void exit(void);
+
+/* File Descriptor helper functions */
+extern int32_t fd_check(int32_t fd);
+extern void    fd_clear(int32_t fd);
+
+extern void pcb_init(pcb_t* pcb , uint8_t* cmd, uint8_t (*argv)[MAX_ARGUMENT_SIZE], uint32_t pid, uint32_t arg_num);
+extern pcb_t* current_pcb(void);
+extern pcb_t* get_pcb(uint32_t pid);
+
+extern int32_t parse_cmd(const uint8_t* command, uint8_t* cmd, uint8_t (*argv)[MAX_ARGUMENT_SIZE]); /* Function for parsing commands */
+extern int32_t get_pid(void);
+extern int32_t set_pid(void);
+extern int32_t clear_pid(int32_t pid);
diff --git a/student-distrib/bootimg b/student-distrib/bootimg
index 820ea25a989234d2061a1683cc0885ba3cc83a09..98e51374322d4c0b555858e7cac9d72f4af9f2eb 100755
Binary files a/student-distrib/bootimg and b/student-distrib/bootimg differ
diff --git a/student-distrib/kernel.c b/student-distrib/kernel.c
index 46112954d0dc9bea4fe5c290878a36581efc6ad3..8c9fd86613dd58eb85bfa99f567108553f4a7296 100644
--- a/student-distrib/kernel.c
+++ b/student-distrib/kernel.c
@@ -9,12 +9,12 @@
 #include "debug.h"
 #include "idt.h"
 #include "tests.h"
-#include "Proc.h"
+#include "proc.h"
 //#include "paging.h"
 //#include "rtc.h"
 //#include "keyboard.h"
 //#include "filesys.h"
-//#include "terminal.h"
+#include "terminal.h"
 //#include "syscall.h"
 
 #include "types.h"
@@ -180,7 +180,8 @@ void entry(unsigned long magic, unsigned long addr) {
 
     clear();
 
-    terminal_open(NULL);
+    init_terminal();
+    //terminal_open(NULL);
 
 #ifdef RUN_TESTS
     /* Run tests */
diff --git a/student-distrib/keyboard.c b/student-distrib/keyboard.c
index 54b78a20a2756b89afbf2a577f2fba7c334a503f..7780b8a0d65e57df7aaf67d9b6029d178d1bfc7e 100644
--- a/student-distrib/keyboard.c
+++ b/student-distrib/keyboard.c
@@ -347,6 +347,31 @@ void KB_handler(void) {
         return;
     }
 
+    if( alt_flag    &&
+        !shift_flag &&
+        (pressed_key == 0x02 || pressed_key == 0x03 || pressed_key == 0x04) )
+    {
+        int32_t term_id;
+
+        switch(pressed_key)
+        {
+            case 0x02:
+                term_id = 0;
+                break;
+            case 0x03:
+                term_id = 1;
+                break;
+            case 0x04:
+                term_id = 2;
+                break;
+        }
+
+        switch_terminal(term_id);
+        send_eoi(KB_IRQ);
+        return;
+    }
+
+
     // handle unknown keys by not printing
     switch (pressed_key)
     {
@@ -361,78 +386,3 @@ void KB_handler(void) {
 
     return;
 }
-
-/************************ Terminal driver functions  ************************/
-/*
-
-void clear_buffer(void)
-{
-    int i;
-    // fill buffer with NULL
-    for(i = 0; i < MAX_BUF_SIZE; i++)
-        line_buffer[i] = NULL;
-
-    buffer_index = 0;
-}
-
-int32_t terminal_read(int32_t fd, int8_t* buf, int32_t nbytes)
-{
-
-    // check for invalid buffer adress
-    if(buf == NULL)
-        return -1;
-
-    int i, size;
-
-    // hold inside function until enter is pressed or buffer size is reached
-    while(buffer_index < MAX_BUF_SIZE-1 && !enter_flag);
-    // copy the line buffer to the parameter buffer
-    for(i = 0; i < buffer_index; i++)
-        buf[i] = line_buffer[i];
-
-    size = buffer_index;
-
-    // reset enter flag
-    enter_flag = 0;
-
-    //clear line buffer
-    for(i = 0; i < MAX_BUF_SIZE; i++)
-        line_buffer[i] = NULL;
-
-    buffer_index = 0;
-
-    // return size
-    return size;
-}
-
-
-int32_t terminal_write(int32_t fd, const int8_t* buf, int32_t nbytes)
-{
-    // checks if buf is null or overflow
-    if(buf == NULL || nbytes > MAX_BUF_SIZE-1)
-        return -1;
-
-    int i;
-    // prints content to terminal
-    for(i = 0; i < nbytes; i++)
-        putc(buf[i]);
-
-    return nbytes;
-}
-
-
-int32_t terminal_open(const uint8_t* filename)
-{
-    clear();
-    reset_cursor();
-    clear_buffer();
-    return 0;
-}
-
-
-int32_t terminal_close(int32_t fd)
-{
-    clear_buffer();
-    return 0;
-}
-*/
diff --git a/student-distrib/keyboard.h b/student-distrib/keyboard.h
index 144c15107cfe605e928ed682c07f690ace8326e2..997a644dbd4d8b8ede9341597d6334459d47fe50 100644
--- a/student-distrib/keyboard.h
+++ b/student-distrib/keyboard.h
@@ -27,4 +27,6 @@ extern void KB_handler(void); // interrupt handler
 
 void buffer_backspace(void);
 
+void switch_terminal(int32_t term_id);
+
 #endif
diff --git a/student-distrib/mp3.img b/student-distrib/mp3.img
index 04f0fe6b09f5a86a98b54ab489a64474a2cfa157..338fe28b1dbc4833a522aed2c44009ee5df03e9f 100755
Binary files a/student-distrib/mp3.img and b/student-distrib/mp3.img differ
diff --git a/student-distrib/paging.c b/student-distrib/paging.c
index d156696a808f7c57a1b8850eab6e16b4fec62fb7..17b3e61cbba64283ce89623f0e915ab57f9ab889 100644
--- a/student-distrib/paging.c
+++ b/student-distrib/paging.c
@@ -26,6 +26,9 @@ void paging_initi(void){
 
     /* Set page table for video memory */
     page_table[VIDEO_MEM] |= PRESENT;
+    page_table[VIDEO_MEM + 1] |= PRESENT; //for 1st terminal
+    page_table[VIDEO_MEM + 2] |= PRESENT; //for 2nd terminal
+    page_table[VIDEO_MEM + 3] |= PRESENT; //for 3rd terminal
 
     /* Put the page table in the page directory */
     page_directory[0] = ((uint32_t)page_table) | READ_WRITE | PRESENT;
@@ -42,21 +45,15 @@ void paging_initi(void){
     return;
 }
 
-/* init_new_program
- * Inputs: PID number of process
- * Return Value: void
- * Function: Initialises page for user program
- */
-void init_new_program(uint32_t pid){
 
-    uint32_t addr = _8_MB + pid*_4_MB;
-
-    page_directory[32] =  addr | SIZE | USER | READ_WRITE | PRESENT;
-
-}
 
 /* !!!!!!!!!!!!!!!!!! This needs to be updated */
-uint8_t* vidmem_init(uint32_t pid){
+/* remap_vidmem
+ * Inputs: PID number of process
+ * Return Value: void
+ * Function: Initialises page for video memory
+ */
+uint8_t* remap_vidmem(uint32_t pid){
 
     int32_t addr = VIDEO_MEM + pid*4;
 
@@ -64,29 +61,68 @@ uint8_t* vidmem_init(uint32_t pid){
 
     page_directory[0] = ((uint32_t)page_table) | USER | READ_WRITE | PRESENT;
 
-    // asm volatile(
-    //     "movl %%eax, %%cr3"
-    //     :
-    //     : "a"(page_directory) );	// move page_directory into cr3
-
+    // flush TLB
+	flush_tlb();
     return (uint8_t*)(addr << 12);
 }
 
+/* remap_program
+ * Inputs: PID number of process
+ * Return Value: void
+ * Function: Initialises page for user program
+ */
+void remap_program(uint32_t pid){
 
-void term_vid_mem(int32_t term_id){
+    uint32_t addr = _8_MB + pid*_4_MB;
+
+    page_directory[32] =  addr | SIZE | USER | READ_WRITE | PRESENT;
+
+    // flush TLB
+	flush_tlb();
+    return;
+}
+
+/* remap_term
+ * Inputs: terminal id
+ * Return Value: void
+ * Function: Initialises page for user program
+ */
+void remap_term(int32_t term_id){
 
     uint32_t addr = control.terminal[term_id].vid_mem;;
     if (control.cur_terminal == term_id) addr = TERM_VID;
 
-	page_directory[33] = ((uint32_t)vid_table) | USER | READ_WRITE | PRESENT;
-	vid_table[term_id] = addr | USER | READ_WRITE | PRESENT;
+	//page_directory[33] = ((uint32_t)vid_table) | USER | READ_WRITE | PRESENT;
+	page_table[VIDEO_MEM] = addr | USER | READ_WRITE | PRESENT;
 
     // flush TLB
-	asm volatile(
-		"movl %0, %%eax\n"
-		"movl %%eax, %%cr3\n"
+	flush_tlb();
+    return;
+}
+
+/* remap_proc
+ * Inputs: PID number of process
+ * Return Value: void
+ * Function: Initialises page for user program
+ */
+int32_t remap_proc(int32_t pid){
+
+	if (pid < 0 || pid >= MAX_PROCESS) return -1;
+	page_directory[32] = (_8_MB + _4_MB * pid) | USER | READ_WRITE | PRESENT;
+
+    // flush TLB
+	flush_tlb();
+	return 0;
+}
+
+
+void flush_tlb(void){
+    asm volatile(
+		"movl %0, %%eax       \n"
+		"movl %%eax, %%cr3    \n"
 		:
 		: "r" (page_directory)
-		: "eax"
+		: "eax", "memory", "cc"
 	);
+    return;
 }
diff --git a/student-distrib/paging.h b/student-distrib/paging.h
index 23a5f8afad39942ddb416ae945b68d234e27a6a9..1711f89b82bcd647b9350ba0e4d1bb1ecd967608 100644
--- a/student-distrib/paging.h
+++ b/student-distrib/paging.h
@@ -58,9 +58,11 @@ void loadPageDirectory(unsigned int*);
  */
 void enablePaging(void);
 
-extern void init_new_program(uint32_t pid);
 
-extern uint8_t* vidmem_init(uint32_t pid);
 
+extern uint8_t* remap_vidmem(uint32_t pid);
+extern int32_t remap_proc(int32_t pid);
+extern void remap_program(uint32_t pid);
+extern void remap_term(int32_t term_id);
 
-extern void term_vid_mem(int32_t term_id);
+extern void flush_tlb(void);
diff --git a/student-distrib/pit.c b/student-distrib/pit.c
new file mode 100644
index 0000000000000000000000000000000000000000..ffa0fdbbd38e45addb35749e46b9c10090ef5917
--- /dev/null
+++ b/student-distrib/pit.c
@@ -0,0 +1,38 @@
+#include "pit.h"
+
+// referance from https://wiki.osdev.org/PIT
+void i8253_init(void){
+	int32_t freq = FREQUENCY / 10000;
+	int32_t low  = freq &  0xFF;
+	int32_t high = freq >> 8;
+
+	//sent command to the port
+	outb(0x34,  CMD_REG);
+	outb(low,   CHANNEL_0);
+	outb(high, CHANNEL_0);
+	enable_irq(0);
+    return;
+}
+
+
+
+void pit_handler(){
+
+	send_eoi(0);
+
+	pcb_t* pcb = get_pcb(control.cur_pid);
+	
+	asm volatile(
+		"movl %%esp, %0\n"
+		"movl %%ebp, %1\n"
+		"leal switch_addr, %2\n"
+		: "=r" (pcb->current_esp), "=r" (pcb->current_ebp), "=r" (pcb->current_eip)
+		: 
+		: "memory"
+	);
+	scheduler();
+	asm volatile ("switch_addr:");
+	return;
+
+    return;
+}
diff --git a/student-distrib/pit.h b/student-distrib/pit.h
new file mode 100644
index 0000000000000000000000000000000000000000..7029ff9412d8ba7265fa1b5cd742681b20be79c0
--- /dev/null
+++ b/student-distrib/pit.h
@@ -0,0 +1,7 @@
+#include "lib.h"
+#include "types.h"
+#include "keyboard.h"
+
+#define FREQUENCY 			    1193182
+#define CHANNEL_0 				0x40
+#define CMD_REG					0x43
diff --git a/student-distrib/proc.c b/student-distrib/proc.c
new file mode 100644
index 0000000000000000000000000000000000000000..5296e428ab670b77d3dd1cf8aa3788908349beef
--- /dev/null
+++ b/student-distrib/proc.c
@@ -0,0 +1,243 @@
+
+#include "proc.h"
+
+
+
+f_table_t    dir_jumptable    = { open_dir,      close_dir,      read_dir,      write_dir       };
+f_table_t    file_jumptable   = { open_file,     close_file,     read_file,     write_file      };
+f_table_t    rtc_jumptable    = { rtc_open,      rtc_close,      rtc_read,      rtc_write       };
+f_table_t    stdin_jumptable  = { terminal_open, terminal_close, terminal_read, terminal_write  };
+f_table_t    stdout_jumptable = { terminal_open, terminal_close, terminal_read, terminal_write  };
+f_table_t    no_jumptable     = { fail         , fail          , fail         , fail            };
+
+
+int32_t fail(){
+    return -1;
+}
+
+void control_initilization(void)
+{
+    int i;
+    for(i = 0; i < MAX_PROCESS; i++)   control.pid_array[i] = 0;
+
+    control.total_prog_count = 0;
+    control.cur_terminal = 0;
+}
+
+
+//checking is fd is valid
+int32_t fd_check(int32_t fd)
+{
+    if( control.terminal[control.cur_terminal].pcb->fd[fd].flags != 0 &&
+        fd >= MIN_FILE_NUM &&
+        fd <  MAX_FILE_NUM ){ return 1; }
+    else { return 0; }
+}
+
+//clearing fd
+void fd_clear(int32_t fd)
+{
+    control.terminal[control.cur_terminal].pcb->fd[fd].fileop_ptr.read  = 0;
+    control.terminal[control.cur_terminal].pcb->fd[fd].fileop_ptr.write = 0;
+    control.terminal[control.cur_terminal].pcb->fd[fd].fileop_ptr.open  = 0;
+    control.terminal[control.cur_terminal].pcb->fd[fd].fileop_ptr.close = 0;
+    control.terminal[control.cur_terminal].pcb->fd[fd].inode_index      = 0;
+    control.terminal[control.cur_terminal].pcb->fd[fd].file_pos         = 0;
+    control.terminal[control.cur_terminal].pcb->fd[fd].flags            = 0;
+    return;
+}
+
+//initialize pcb
+void pcb_init(pcb_t* pcb , uint8_t* parsed_cmd, uint8_t (*argv)[MAX_ARGUMENT_SIZE], uint32_t pid, uint32_t arg_num)
+{
+    int i;
+    for( i = 0; i < MAX_FILE_NUM ; i++){
+        pcb->fd[i].fileop_ptr.read  = 0;
+        pcb->fd[i].fileop_ptr.write = 0;
+        pcb->fd[i].fileop_ptr.open  = 0;
+        pcb->fd[i].fileop_ptr.close = 0;
+        pcb->fd[i].inode_index      = 0;
+        pcb->fd[i].file_pos         = 0;
+        pcb->fd[i].flags            = 0;
+    }
+
+    //initialze stdin
+    pcb->fd[STDIN_FD].fileop_ptr  = (f_table_t)stdin_jumptable;
+    pcb->fd[STDIN_FD].inode_index = 0;
+    pcb->fd[STDIN_FD].file_pos    = 0;
+    pcb->fd[STDIN_FD].flags       = 1;
+
+    //initialze stdout
+    pcb->fd[STDOUT_FD].fileop_ptr  = (f_table_t)stdout_jumptable;
+    pcb->fd[STDOUT_FD].inode_index = 0;
+    pcb->fd[STDOUT_FD].file_pos    = 0;
+    pcb->fd[STDOUT_FD].flags       = 1;
+
+    //initialize other things in pcb structures
+    pcb->pid      = pid;
+    //pcb->parent_pid = (control.terminal[control.cur_terminal].terminal_prog_count - 1 == 0) ? pid - 1: control.terminal[control.cur_terminal].pcb->pid;
+    // no program other than the shell initiates another program
+    pcb->parent_pid = 0;
+
+    pcb->arg_num = arg_num;
+    memcpy(pcb->cmd, parsed_cmd, MAX_COMMAND_SIZE);
+    for(i = 0; i < MAX_ARGUMENT_NUM; i++) memcpy(pcb->argv[i],argv[i], MAX_ARGUMENT_SIZE);
+
+    pcb->parent_esp  = 0;
+    pcb->parent_ebp  = 0;
+    pcb->parent_pcb  = control.terminal[control.cur_terminal].pcb;
+    pcb->tss_esp0 =  tss.esp0;
+
+    return;
+}
+
+//function that return a pointer to the current pcb
+pcb_t* current_pcb(void)
+{
+    pcb_t* pcb;
+    asm volatile(
+         "andl %%esp, %0"
+         : "=r" (pcb)
+         : "r" (PCB_M)
+         );
+    return pcb;
+}
+
+//parsing the command, extract command and argument
+//return number of arguments when success, -2 when exit, -1 when fail
+int32_t parse_cmd(const uint8_t* command, uint8_t* parsed_cmd, uint8_t (*argv)[MAX_ARGUMENT_SIZE])
+{
+    int32_t i,j, command_length;
+    int32_t end = 0;
+    int32_t start = 0;
+
+    //clear parsed_cmd buffer
+    for(i = 0; i < MAX_COMMAND_SIZE; i++){ parsed_cmd[i] = '\0'; }
+
+    //clear argument buffer
+    for(i = 0; i < MAX_ARGUMENT_NUM; i++)
+    {
+        for(j = 0; j < MAX_ARGUMENT_SIZE; j++) argv[i][j] = '\0';
+    }
+
+    //skip spaces at start of command
+    while (command[start] == ' '){ start++; end++; }
+
+    //find end of command (end in space or line terminator)
+    while (command[end] != ' '   &&
+           command[end] != '\0'  &&
+           command[end] != AS_NL) end++;
+
+    //check if command is bigger than valid command size
+    if(end - start > MAX_COMMAND_SIZE)
+    {
+        printf("command name exceeded the maximum size of %d\n", MAX_COMMAND_SIZE);
+        return -1;
+    }
+
+    //copy command to parsed_cmd
+    for (i = 0; i < (end - start); i++) parsed_cmd[i] = command[i+start];
+
+    command_length = strlen((int8_t*)command);
+
+    //skip spaces (needs to be here for return value)
+    while(command[end] == ' ') end++;
+
+    //extracting arguments
+    for( j = 0 ; end < command_length ; j++ )
+    {
+        //set new start to end of last argument
+        start = end;
+
+        //check if max number of arguments is reached
+        if(j >= MAX_ARGUMENT_NUM)
+        {
+            printf("input exceeded the maximum number of arguments %d\n", MAX_ARGUMENT_NUM);
+            return -1;
+        }
+
+        //skip spaces until argument is reached
+        while (command[start] == ' ') { start++; end++; }
+
+        //find end of command (end in space or line terminator)
+        while (command[end] != ' '  &&
+               command[end] != '\0' &&
+               command[end] != AS_NL) end++;
+
+        //check if argument is bigger than valid command size
+        if(end - start > MAX_ARGUMENT_SIZE)
+        {
+            printf("argument %d exceeded the maximum size of %d\n", j+1, MAX_ARGUMENT_SIZE);
+            return -1;
+        }
+
+        //copy argument to return array
+        for (i = 0; i < (end - start); i++)    argv[j][i] = command[i+start];
+
+    }
+
+    if (strncmp("exit", (int8_t*)parsed_cmd, 4) == 0)
+        return -2;
+
+    return j;
+}
+
+/*
+void context_switch(uint32_t entry_point)
+{
+     asm volatile(
+         "pushl %0           #push SS       \n"
+         "pushl %1           #push ESP      \n"
+         "pushfl             #push EFLAGS   \n"
+
+         "orl $0x200,(%%esp) #Set IF flag   \n"
+
+         "pushl %2           #push CS       \n"
+         "pushl %3           #push ret_addr \n"
+         "iret                              \n"
+         : //output
+         : "g"(USER_DS), "g"(STACK), "g" (USER_CS), "g" (entry_point) //input
+         );
+}*/
+
+void exit(void)
+{
+    asm volatile( "call halt;");
+    return;
+}
+
+/* Determines the next available process number */
+/* 0--0--0--0--0--0 */
+/* Returns available PID 0-5 */
+int32_t set_pid(void)
+{
+    int32_t i;
+
+    /* Loop till you find a free process index */
+    for (i = 0; i < MAX_PROCESS; i++)
+    {
+        if (control.pid_array[i] == 0){
+            control.pid_array[i] = 1;
+            return i;
+        }
+    }
+    printf("Reached maximum number of processes %d\n", MAX_PROCESS);
+    return -1;
+}
+
+int32_t get_pid(void)
+{
+    int32_t i, count = -1;
+    for (i = 0; i < MAX_PROCESS; i++){ if (control.pid_array[i] == 1) count++; }
+    return count;
+}
+
+int32_t clear_pid(int32_t pid)
+{
+    control.pid_array[pid] = 0;
+    return get_pid();
+}
+
+pcb_t* get_pcb(uint32_t pid){
+    return (pcb_t *)(_8_MB - (pid + 1) * _8_KB);
+}
diff --git a/student-distrib/scheduler.c b/student-distrib/scheduler.c
new file mode 100644
index 0000000000000000000000000000000000000000..13d4fd3ac346e84969589c7d4d235165eabc0cfb
--- /dev/null
+++ b/student-distrib/scheduler.c
@@ -0,0 +1,54 @@
+#include "scheduler.h"
+
+//in a certain mount of time, swap out of the current process and run the next one
+void scheduler(void){
+
+	if (control.cur_pid == -1) return;
+
+	int32_t flag = 0;
+	int32_t i;
+
+	for (i = control.cur_pid + 1; i < MAX_PROCESS; i++)
+	{
+		if (control.pid_array[i] > 0 )
+		{
+			flag = 1;
+			break;
+		}
+	}
+
+	if (flag == 0)
+	{
+		for (i = 0; i < control.cur_pid; i++)
+		{
+			if (control.pid_array[i] > 0 )
+			{
+				flag = 1;
+				break;
+			}
+		}
+	}
+
+	if (flag == 0) return;
+
+	// update current pid, tss and remap paging
+	remap_proc(i);
+	control.cur_pid = i;
+	tss.ss0 = KERNEL_DS;
+	tss.esp0 = _8_MB - _8_KB * control.cur_pid;
+
+	// restore esp, ebp, eip
+    pcb_t* pcb =  get_pcb(i);
+	uint32_t esp = pcb->current_esp;
+	uint32_t ebp = pcb->current_ebp;
+	uint32_t eip = pcb->current_eip;
+
+	asm volatile(
+		"movl %0, %%esp\n"
+		"movl %1, %%ebp\n"
+		"jmp *%2\n"
+		:
+		: "r" (esp), "r" (ebp), "r" (eip)
+		: "memory"
+	);
+}
diff --git a/student-distrib/scheduler.h b/student-distrib/scheduler.h
new file mode 100644
index 0000000000000000000000000000000000000000..a6c5f3f4dca1edd1024ca233d6b052476bc710db
--- /dev/null
+++ b/student-distrib/scheduler.h
@@ -0,0 +1,6 @@
+#include "lib.h"
+#include "types.h"
+#include "x86_desc.h"
+
+pcb_t* get_pcb(uint32_t pid);
+int32_t remap_proc(int32_t pid);
diff --git a/student-distrib/syscall.c b/student-distrib/syscall.c
index 1f55a8184907ec808a7538c747537a0a3ebe7914..a7647916661a2e4bd7ae811daf2403183b16f430 100644
--- a/student-distrib/syscall.c
+++ b/student-distrib/syscall.c
@@ -1,12 +1,5 @@
 #include "syscall.h"
 
-f_table dir_jumptable    = { open_dir,      close_dir,      read_dir,      write_dir       };
-f_table file_jumptable   = { open_file,     close_file,     read_file,     write_file      };
-f_table rtc_jumptable    = { rtc_open,      rtc_close,      rtc_read,      rtc_write       };
-f_table stdin_jumptable  = { terminal_open, terminal_close, terminal_read, terminal_write  };
-f_table stdout_jumptable = { terminal_open, terminal_close, terminal_read, terminal_write  };
-f_table no_jumptable     = { fail         , fail          , fail         , fail            };
-
 /*
  *The halt system call
  *
@@ -50,7 +43,7 @@ int32_t halt (uint8_t status){
 
     //------------------ Restore parent paging ---------------------------------
 
-    init_new_program( pcb_prev->pid );
+    remap_program( pcb_prev->pid );
     flush_tlb();
 
     tss.esp0 = pcb_cur->tss_esp0;
@@ -98,7 +91,7 @@ int32_t execute(const uint8_t* command){
     // if command == NULL, abort
     if(command == NULL) return -1;
 
-    
+
 
     // if cpu reaches its maximum control, abort
     if(control.total_prog_count >= MAX_PROCESS)
@@ -164,7 +157,7 @@ int32_t execute(const uint8_t* command){
 
     //-------------------- 3: Paging -------------------------------------------
 
-        init_new_program(pid);
+        remap_program(pid);
         flush_tlb();
 
     //-------------------- 4: User-level Program Loader ------------------------
@@ -247,50 +240,21 @@ int32_t read (int32_t fd, void* buf, int32_t nbytes){
 
     cli();
 
-    uint32_t type;
-    uint32_t length;
     int32_t ret;
 
-    //printf("[read] fd = %d\n", fd);
-
-    control.terminal[control.cur_terminal].pcb = current_pcb();
-
-    //printf("flags from fd = %d has value %d\n", fd, control.terminal[control.cur_terminal].pcb->fd[fd].flags);
-
-    //fd extra check
-    if(fd < 0 || fd > MAX_FILE_NUM || fd == STDOUT_FD || control.terminal[control.cur_terminal].pcb->fd[fd].flags == 0)
-        return -1;
+    if (fd_check(fd) < 0) return -1; // invalid fd
 
-    //printf("[read] passed return -1");
+    if (buf == NULL) return -1; // invalid buf
 
-    /* Type of file */
-    type   = (rtc_jumptable.read == control.terminal[control.cur_terminal].pcb->fd[fd].fileop_ptr.read) ? 0 : 1;
+    if (nbytes < 0) return -1; // invalid nbytes
 
-    /* Length of file */
-    length = ((inode_t*)(control.filesys_start + FS_BLOCK_SIZE*(1+control.terminal[control.cur_terminal].pcb->fd[fd].inode_index) ))->length;
+    control.terminal[control.cur_terminal].pcb = current_pcb();
 
-    /* Check file descriptor index */
-    if( /*(fd == STDIN_FD) || */ fd_check(fd) ){
-        ////printf("00000000000000000000000000000000000000 \n");
-        sti();
-        ret =  control.terminal[control.cur_terminal].pcb->fd[fd].fileop_ptr.read(fd, buf, nbytes);
-        ////printf("[read] buf: %s\n", buf);
-        ////printf("[read] ret: %d\n", ret);
-        //printf("[read] return %d\n", ret);
-        return ret;
-    }
+    ret =  control.terminal[control.cur_terminal].pcb->fd[fd].fileop_ptr.read(fd, buf, nbytes);
+    return ret;
 
     sti();
 
-    /* Checks on type and file length*/
-    if( type  &&  ( control.terminal[control.cur_terminal].pcb->fd[fd].file_pos >= length ) ){
-        control.terminal[control.cur_terminal].pcb->fd[fd].file_pos = 0;
-        ////printf("********************************************** \n");
-        //printf("[read] return 0\n");
-        return 0;
-    }
-    //printf("[read] return -1\n");
-    return -1;
 }
 
 /*
@@ -312,7 +276,7 @@ int32_t read (int32_t fd, void* buf, int32_t nbytes){
  *        2. the number of bytes written when successed.
  */
 int32_t write (int32_t fd, const void* buf, int32_t nbytes){
-    
+
     int32_t ret;
 
     control.terminal[control.cur_terminal].pcb = current_pcb();
@@ -376,7 +340,7 @@ int32_t open (const uint8_t* filename){
         if(control.terminal[control.cur_terminal].pcb->fd[i].flags == 0)
         {
             fd = i;
-            break; 
+            break;
         }
 
         if(i == MAX_FILE_NUM-1){
@@ -426,7 +390,7 @@ int32_t close (int32_t fd){
     control.terminal[control.cur_terminal].pcb = current_pcb();
 
     //fd extra check
-    // if(fd < 0 || fd > MAX_FILE_NUM || 
+    // if(fd < 0 || fd > MAX_FILE_NUM ||
     //    control.terminal[control.cur_terminal].pcb->fd[fd].flags == 0)
     //      return -1;
 
@@ -508,13 +472,13 @@ int32_t vidmap (uint8_t** screen_start){
     /* Get the memory location */
     int addr = (uint32_t)screen_start;
 
-    /* Check if address falls in address range of user-level page */  
+    /* Check if address falls in address range of user-level page */
     if ( addr < VID_STA || addr > VID_END)
         return -1;
 
     control.terminal[control.cur_terminal].pcb = current_pcb();
 
-    *screen_start = vidmem_init(control.terminal[control.cur_terminal].pcb->pid);
+    *screen_start = remap_vidmem(control.terminal[control.cur_terminal].pcb->pid);
 
     flush_tlb();
 
@@ -535,274 +499,3 @@ int32_t vidmap (uint8_t** screen_start){
 int32_t set_handler (int32_t signum, void* handler_address);
 
 int32_t sigreturn (void);
-
-
-//------------------------------------------------------------------------------------------
-
-//checking is fd is valid
-int32_t fd_check(int32_t fd){
-
-    if( fd >= MIN_FILE_NUM &&
-        fd <  MAX_FILE_NUM &&
-        control.terminal[control.cur_terminal].pcb->fd[fd].flags != 0 )
-    {
-        return 1;
-    }
-    else
-    {
-        return 0;
-    }
-
-}
-
-//clearing fd
-void fd_clear(int32_t fd){
-    control.terminal[control.cur_terminal].pcb->fd[fd].fileop_ptr.read  = 0;
-    control.terminal[control.cur_terminal].pcb->fd[fd].fileop_ptr.write = 0;
-    control.terminal[control.cur_terminal].pcb->fd[fd].fileop_ptr.open  = 0;
-    control.terminal[control.cur_terminal].pcb->fd[fd].fileop_ptr.close = 0;
-    control.terminal[control.cur_terminal].pcb->fd[fd].inode_index      = 0;
-    control.terminal[control.cur_terminal].pcb->fd[fd].file_pos         = 0;
-    control.terminal[control.cur_terminal].pcb->fd[fd].flags            = 0;
-
-    return;
-}
-
-//initialize pcb
-void pcb_init(pcb_t* pcb , uint8_t* parsed_cmd, uint8_t (*argv)[MAX_ARGUMENT_SIZE], uint32_t pid, uint32_t arg_num){
-
-    int i;
-    for( i = 0; i < MAX_FILE_NUM ; i++){
-        pcb->fd[i].fileop_ptr.read  = 0;
-        pcb->fd[i].fileop_ptr.write = 0;
-        pcb->fd[i].fileop_ptr.open  = 0;
-        pcb->fd[i].fileop_ptr.close = 0;
-        pcb->fd[i].inode_index      = 0;
-        pcb->fd[i].file_pos         = 0;
-        pcb->fd[i].flags            = 0;
-    }
-
-    //initialze stdin
-    pcb->fd[STDIN_FD].fileop_ptr  = (f_table)stdin_jumptable;
-    pcb->fd[STDIN_FD].inode_index = 0;
-    pcb->fd[STDIN_FD].file_pos    = 0;
-    pcb->fd[STDIN_FD].flags       = 1;
-
-    //initialze stdout
-    pcb->fd[STDOUT_FD].fileop_ptr  = (f_table)stdout_jumptable;
-    pcb->fd[STDOUT_FD].inode_index = 0;
-    pcb->fd[STDOUT_FD].file_pos    = 0;
-    pcb->fd[STDOUT_FD].flags       = 1;
-
-    //initialize other things in pcb structures
-    pcb->pid      = pid;
-    //pcb->parent_pid = (control.terminal[control.cur_terminal].terminal_prog_count - 1 == 0) ? pid - 1: control.terminal[control.cur_terminal].pcb->pid;
-    // no program other than the shell initiates another program
-    pcb->parent_pid = 0;
-
-    pcb->arg_num = arg_num;
-    memcpy(pcb->cmd, parsed_cmd, MAX_COMMAND_SIZE);
-    for(i = 0; i < MAX_ARGUMENT_NUM; i++) memcpy(pcb->argv[i],argv[i], MAX_ARGUMENT_SIZE);
-
-
-    //pcb->par_esp  = 0;
-    //pcb->par_ebp  = 0;
-    pcb->parent_esp  = 0;
-    pcb->parent_ebp  = 0;
-    pcb->parent_pcb  = control.terminal[control.cur_terminal].pcb;
-    pcb->tss_esp0 =  tss.esp0;
-
-    return;
-}
-
-//function that return a pointer to the current pcb
-pcb_t* current_pcb(void){
-    pcb_t* pcb;
-    asm volatile(
-         "andl %%esp, %0"
-         : "=r" (pcb)
-         : "r" (PCB_M)
-         );
-    return pcb;
-}
-
-//parsing the command, extract command and argument
-//return number of arguments when success, -2 when exit, -1 when fail
-int32_t parse_cmd(const uint8_t* command, uint8_t* parsed_cmd, uint8_t (*argv)[MAX_ARGUMENT_SIZE]){
-
-    int32_t i,j, command_length;
-    int32_t end = 0;
-    int32_t start = 0;
-
-    //clear parsed_cmd buffer
-    for(i = 0; i < MAX_COMMAND_SIZE; i++)
-    {
-        parsed_cmd[i] = '\0';
-    }
-
-    //clear argument buffer
-    for(i = 0; i < MAX_ARGUMENT_NUM; i++)
-    {
-        for(j = 0; j < MAX_ARGUMENT_SIZE; j++)
-        {
-            argv[i][j] = '\0';
-        }
-    }
-
-    //skip spaces at start of command
-    while (command[start] == ' ')
-    {
-        start++;
-        end++;
-    }
-
-    //find end of command (end in space or line terminator)
-    while (command[end] != ' '   &&
-           command[end] != '\0'  &&
-           command[end] != AS_NL)
-    {
-        end++;
-    }
-
-    //check if command is bigger than valid command size
-    if(end - start > MAX_COMMAND_SIZE)
-    {
-        printf("command name exceeded the maximum size of %d\n", MAX_COMMAND_SIZE);
-        return -1;
-    }
-
-    //copy command to parsed_cmd
-    for (i = 0; i < (end - start); i++)
-    {
-        parsed_cmd[i] = command[i+start];
-    }
-
-    command_length = strlen((int8_t*)command);
-
-    //skip spaces (needs to be here for return value)
-    while(command[end] == ' ')
-    {
-        end++;
-    }
-
-    //extracting arguments
-    for( j = 0 ; end < command_length ; j++ )
-    {
-        //set new start to end of last argument
-        start = end;
-
-        //check if max number of arguments is reached
-        if(j >= MAX_ARGUMENT_NUM)
-        {
-            printf("input exceeded the maximum number of arguments %d\n", MAX_ARGUMENT_NUM);
-            return -1;
-        }
-
-        //skip spaces until argument is reached
-        while (command[start] == ' ')
-        {
-            start++;
-            end++;
-        }
-
-        //find end of command (end in space or line terminator)
-        while (command[end] != ' '  &&
-               command[end] != '\0' &&
-               command[end] != AS_NL)
-        {
-            end++;
-        }
-
-        //check if argument is bigger than valid command size
-        if(end - start > MAX_ARGUMENT_SIZE)
-        {
-            printf("argument %d exceeded the maximum size of %d\n", j+1, MAX_ARGUMENT_SIZE);
-            return -1;
-        }
-
-        //copy argument to return array
-        for (i = 0; i < (end - start); i++)
-        {
-            argv[j][i] = command[i+start];
-        }
-    }
-
-    if (strncmp("exit", (int8_t*)parsed_cmd, 4) == 0)
-        return -2;
-
-    //if (strncmp("terminal#", (int8_t*)parsed_cmd, 4) == 0) return -1;
-
-    return j;
-}
-
-// void context_switch(uint32_t entry_point){
-//     asm volatile(
-//         "pushl %0           #push SS       \n"
-//         "pushl %1           #push ESP      \n"
-//         "pushfl             #push EFLAGS   \n"
-
-//         "orl $0x200,(%%esp) #Set IF flag   \n"
-
-//         "pushl %2           #push CS       \n"
-//         "pushl %3           #push ret_addr \n"
-//         "iret                              \n"
-//         : //output
-//         : "g"(USER_DS), "g"(STACK), "g" (USER_CS), "g" (entry_point) //input
-//         );
-// }
-
-void exit(void){
-    asm volatile(
-
-        "call halt;"
-
-        );
-    return;
-}
-
-/* Determines the next available process number */
-/* 0--0--0--0--0--0 */
-/* Returns available PID 0-5 */
-int32_t set_pid(void){
-
-    int32_t i;
-
-    /* Loop till you find a free process index */
-    for (i = 0; i < MAX_PROCESS; i++){
-
-        if (control.pid_array[i] == 0){
-        	control.pid_array[i] = 1;
-	    	return i;
-        }
-    }
-    printf("Reached maximum number of processes %d\n", MAX_PROCESS);
-    return -1;
-}
-
-int32_t get_pid(void)
-{
-    int32_t i, count = -1;
-
-    for (i = 0; i < MAX_PROCESS; i++)
-    {
-        if (control.pid_array[i] == 1)
-            count++;
-    }
-
-    return count;
-}
-
-int32_t clear_pid(int32_t pid)
-{
-    control.pid_array[pid] = 0;
-
-    return get_pid();
-}
-
-pcb_t* get_pcb(uint32_t pid){
-    return (pcb_t *)(_8_MB - (pid + 1) * _8_KB);
-}
-
-int32_t fail(){
-    return -1;
-}
diff --git a/student-distrib/syscall.h b/student-distrib/syscall.h
index 68a9121a38b4431e5f755f7c8922f16737f6377a..a3278a533ad811d702ef8f43e013304c3e0498bd 100644
--- a/student-distrib/syscall.h
+++ b/student-distrib/syscall.h
@@ -5,37 +5,20 @@
 #include "lib.h"
 #include "types.h"
 #include "x86_desc.h"
+#include "proc.h"
 
-#include "keyboard.h"
 
-#include "rtc.h"
-#include "terminal.h"
-#include "filesys.h"
 
-
-
-#define TABLE_SIZE      4
-
-#define MIN_FILE_NUM    0
-#define STDIN_FD        0
-#define STDOUT_FD       1
-#define USER_FILE_START 2
+#define PROGRAM_START   0x8048000
+#define ENTRY_POINT     24
+#define VID_STA         0x08000000
+#define VID_END         0x08400000
 
 #define OPEN            0
 #define CLOSE           1
 #define READ            2
 #define WRITE           3
 
-
-#define VID_STA         0x08000000
-#define VID_END         0x08400000
-
-//#define VID_STA         0x400000
-//#define VID_END         0x8400000
-
-#define ENTRY_POINT     24
-#define PROGRAM_START   0x8048000
-
 #define AS_DEL          0x7F
 #define AS_E            0x45
 #define AS_L            0x4C
@@ -51,20 +34,16 @@
 #define PCB_M           0xFFFFE000
 
 
-
 #define IF_FLAG         0x200
 
-/* Global variables */
-//extern int32_t prog_count;
-//extern int32_t pid;
 
 /* Assembly linkage for system cals */
 void syscall_linkage();
 
-
 void init_new_program(uint32_t pid);
 uint8_t* vidmem_init(uint32_t pid);
 
+void context_switch(uint32_t entry_point); /* Assembly linkage for context switch */
 
 /* ------------------System calls------------------ */
 extern int32_t halt (uint8_t status);
@@ -77,32 +56,29 @@ extern int32_t getargs (uint8_t* buf, int32_t nbytes);
 extern int32_t vidmap (uint8_t** screen_start);
 extern int32_t set_handler (int32_t signum, void* handler_address);
 extern int32_t sigreturn (void);
-extern void exit(void);
-
-/* File Descriptor helper functions */
-extern int32_t fd_check(int32_t fd);
-extern void fd_clear(int32_t fd);
-
-/* Reloads CR3 */
-extern void flush_tlb(void);
-
-/* Function for parsing commands */
-extern int32_t parse_cmd(const uint8_t* command, uint8_t* cmd, uint8_t (*argv)[MAX_ARGUMENT_SIZE]);
-
-/* Assembly linkage for context switch */
-extern void context_switch(uint32_t entry_point);
-
-/* PCB helper functions */
-extern void pcb_init(pcb_t* pcb , uint8_t* cmd, uint8_t (*argv)[MAX_ARGUMENT_SIZE], uint32_t pid, uint32_t arg_num);
-extern pcb_t* current_pcb(void);
-extern pcb_t* get_pcb(uint32_t pid);
-
-
-int32_t get_pid(void);
-int32_t set_pid(void);
-int32_t clear_pid(int32_t pid);
 
-/* Error handling helper function */
-extern int32_t fail();
+//-------------------function needed from other place-------------------
+//from paging.h
+void     flush_tlb(void);
+void     remap_program(uint32_t pid);
+uint8_t* remap_vidmem(uint32_t pid);
+
+//from proc.h
+int32_t  parse_cmd(const uint8_t* command, uint8_t* cmd, uint8_t (*argv)[MAX_ARGUMENT_SIZE]); /* Function for parsing commands */
+int32_t  get_pid(void);
+int32_t  set_pid(void);
+int32_t  clear_pid(int32_t pid);
+int32_t  fd_check(int32_t fd); /* File Descriptor helper functions */
+void     fd_clear(int32_t fd); /* File Descriptor helper functions */
+void     exit(void);
+void     pcb_init(pcb_t* pcb , uint8_t* cmd, uint8_t (*argv)[MAX_ARGUMENT_SIZE], uint32_t pid, uint32_t arg_num);
+pcb_t*   current_pcb(void); /* PCB helper functions */
+pcb_t*   get_pcb(uint32_t pid); /* PCB helper functions */
+
+//from filesys.h
+int32_t read_dentry_by_name(const uint8_t* fname, dentry_t* dentry);
+int32_t read_dentry_by_index(uint32_t index, dentry_t* dentry);
+int32_t read_data(uint32_t inode, uint32_t offset, uint8_t* buf, uint32_t length);
+int32_t get_file_size(int32_t inode_index);
 
 #endif
diff --git a/student-distrib/syscall_asm.S b/student-distrib/syscall_asm.S
index 1e022a225e04a28ce8f9e6312e4363bf04eeb3b6..80dbd86c9100bce8bfee2c974598666f5875c0a2 100644
--- a/student-distrib/syscall_asm.S
+++ b/student-distrib/syscall_asm.S
@@ -1,3 +1,10 @@
+#define ASM 1
+
+#include "x86_desc.h"
+
+#define STACK 0x8400000
+#define IF_FLAG 0x200
+
 # Assembly linkage functions
 .globl syscall_linkage
 .globl context_switch
@@ -14,7 +21,7 @@ syscall_linkage:
     pushl $0
     PUSHFL
 
-    # Save registers, do not save eax ???
+    # Save registers, do not save and pop eax since it has return value
     pushl %ebx
     pushl %ecx
     pushl %edx
@@ -23,6 +30,7 @@ syscall_linkage:
     pushl %esi
     pushl %edi
 
+
     # Check for valid system call value (1 through 10)
     cmpl $0, %eax
     jbe done_invalid
@@ -50,7 +58,6 @@ done_invalid:
     dec  %eax           # set eax to -1
 
 done:
-
     # Restore registers
     popl %edi
     popl %esi
@@ -70,7 +77,6 @@ IRET
 
 
 sys_execute_leave:
-
     leave
     ret
 
@@ -87,19 +93,13 @@ flush_tlb:
     pushl %edi
     pushl %esi
 
-    # ???
+    # keep value in cr3, but writting to cr3 will flush TLBs
     movl %cr3, %eax
     movl %eax, %cr3
 
-    popl %esi
-    popl %edi
-    popl %ebx
-
-leave
-ret
 
 # context_switch:
-# Description: Sets up stack for IRET to user program ???
+# Description: Sets up stack for IRET to swtich from kernel to user program
 context_switch:
 
     # Load entry point in EBX
diff --git a/student-distrib/terminal.c b/student-distrib/terminal.c
index 5f862323a34b2032c4e2f766fc603a76d0b19dc2..5ecfa52f72a52a302127cb9246a70effc01ed1f8 100644
--- a/student-distrib/terminal.c
+++ b/student-distrib/terminal.c
@@ -141,8 +141,6 @@ int32_t terminal_close(int32_t fd)
 
 
 
-
-
 /*
  *  FUNCTIONALITY: initialize terminal
  *
@@ -154,6 +152,10 @@ int32_t terminal_close(int32_t fd)
  */
 void init_terminal(void){
 
+    clear();
+    reset_cursor();
+    clear_buffer();
+
     int i;
 	for (i = 0; i < 3; i++){
         control.terminal[i].pcb = (pcb_t*)NULL;
@@ -182,28 +184,38 @@ void init_terminal(void){
 
 //maybe we need to write a new cursor update function
 
-void switch_terminal(int term_id){
+void switch_terminal(int32_t term_id){
 
+    printf("[switch] 1\n");
     if( term_id < 0  || term_id > 2) return;
 
+    printf("[switch] 2\n");
     int32_t cur_terminal = control.cur_terminal;
 	if (term_id == cur_terminal) return;
+
 	cli();
 	//store cuurrent terminal data
+    printf("[switch] 3\n");
     copy_term_data(cur_terminal, 0);
+    printf("[switch] 4\n");
     clear_term_vid(cur_terminal);
 
+    printf("[switch] 5\n");
 	// switching terminal
 	int32_t prev_terminal = cur_terminal;
 	cur_terminal = term_id;
 	control.cur_terminal = term_id;
 
-	term_vid_mem(prev_terminal);
-	term_vid_mem(cur_terminal);
+    printf("[switch] 6\n");
+	remap_term(prev_terminal);
+    printf("[switch] 7\n");
+	remap_term(cur_terminal);
+    printf("[switch] 8\n");
 
 	//restore data, set up terminal
     copy_term_data(cur_terminal, 1);
     //update_cursor(cur_terminal);
+    printf("[switch] 9\n");
 
 	sti();
 	return;
@@ -219,12 +231,13 @@ void switch_terminal(int term_id){
  *  OUTPUT: None
  */
 void copy_term_data(int32_t term_id, int32_t cmd){
-    switch(cmd){
+    switch(cmd)
+    {
         case 0:
             memcpy( (void*)control.terminal[term_id].vid_mem, (const void*)TERM_VID, _4_KB );
             break;
         case 1:
-            if (control.terminal[term_id].terminal_prog_count == 0) start_shell();
+            if (control.terminal[term_id].terminal_prog_count == 0) execute((uint8_t*) "shell");;
             memcpy( (void*)TERM_VID, (const void*)control.terminal[term_id].vid_mem, _4_KB );
             break;
     }
@@ -232,19 +245,20 @@ void copy_term_data(int32_t term_id, int32_t cmd){
 }
 
 
-void start_shell(void){
-    //todo
-    return;
-}
-
-
 /*
  *  FUNCTIONALITY: Clears video memory and update cursor
  *  INPUT: terminal id
  *  OUTPUT: None
  */
-void clear_term_vid(int32_t term_id){
-    //todo
+void clear_term_vid(int32_t term_id)
+{
+    int32_t i;
+    int8_t* mem_ptr = (int8_t*)control.terminal[term_id].vid_mem;
+    for (i = 0; i < COL_NUM * ROW_NUM; i++) {
+        *(int8_t *)(mem_ptr + (i << 1)) = ' ';
+        *(int8_t *)(mem_ptr + (i << 1) + 1) = 0x7;
+    }
+	//update_cursor();
     return;
 }
 
diff --git a/student-distrib/terminal.h b/student-distrib/terminal.h
index 05571b90091961f8b8e602692ca7b3146f4690b5..f873d84a65344de5a0b68b7255d8d1e80ce9ba3e 100644
--- a/student-distrib/terminal.h
+++ b/student-distrib/terminal.h
@@ -15,14 +15,14 @@ extern int32_t terminal_write(int32_t fd, const void* buf, int32_t nbytes);
 extern int32_t terminal_open(const uint8_t* filename);
 extern int32_t terminal_close(int32_t fd);
 
+extern void switch_terminal(int32_t term_id);
 
 void init_terminal(void);
-void switch_terminal(int32_t term_id);
 void copy_term_data(int32_t term_id, int32_t cmd);
-void start_shell(void);
 void clear_term_vid(int32_t term_id);
-//void update_cursor(); 
-
-extern void term_vid_mem(int32_t term_id);
+//void update_cursor();
 
+//function from other place
+void remap_term(int32_t term_id);
+int32_t execute (const uint8_t* command);
 #endif
diff --git a/student-distrib/types.h b/student-distrib/types.h
index 982b162e4849c31c5f4a0666d9485a2a2de9cbd6..ae6869573b04b8818cc383fccd3942e2c950385b 100644
--- a/student-distrib/types.h
+++ b/student-distrib/types.h
@@ -7,63 +7,69 @@
 #ifndef _TYPES_H
 #define _TYPES_H
 
-#define     MAX_DATA_BLOCK_INDEX            1023
-#define     FS_BLOCK_SIZE                   4096
-#define     MAX_FILENAME_LENGTH             32
-#define     MAX_NUM_DENTRY                  63
-
-#define     MAX_ARGUMENT_SIZE               40
-
-#define     MAX_ARGUMENT_NUM                2
-#define     MAX_COMMAND_SIZE                10
-
-#define     MAX_FILE_NUM                    8
-
-#define     MAX_BUF_SIZE                    128
-
-#define     NULL                            0
-
-#define     DENTRY_RESERVED                 24
-
-#define     BOOT_RESERVED                   52
-
-
-
-#define MAX_PROCESS     6
-
-#define MAX_TERMINAL    3
-
-/* PCB Size in bytes*/
-#define PCB_SIZE        400
-
-/* Shifting required to write to registers correctl */
-#define VIDEO_ADDR      0x000B8000
-#define VIDEO_MEM       0xB8
-
-/* Logical address of kernel memory - same as physical address */
-#define KERNEL_ADDR     0x00400000
-
-
-#define _1_MB           0x100000
-#define _2_MB           0x200000
-#define _4_MB           0x400000
-#define _8_MB           0x800000
-#define _128_MB         0x8000000
-#define _132_MB         0x8400000
-
-#define _1_KB           1024
-#define _4_KB           4096
-#define _8_KB           0x2000
-
-
-
-// we need to find a place in memory to store termianl data when switch termianl
-#define TERM0_VID       0xB9000
-#define TERM1_VID       0xBA000
-#define TERM2_VID       0xBB000
-
-#define TERM_VID        0xB8000  //this is the address of the display video memory of the termianl
-
+//for file system
+#define     FS_BLOCK_SIZE               4096
+#define     MAX_DATA_BLOCK_INDEX        1023
+#define     MAX_FILENAME_LENGTH         32
+#define     MAX_NUM_DENTRY              63
+#define     DENTRY_RESERVED             24
+#define     BOOT_RESERVED               52
+
+//for PCB
+#define     PCB_SIZE                    400
+#define     MAX_FILE_NUM                8
+#define     MIN_FILE_NUM                0
+#define     MAX_COMMAND_SIZE            10
+#define     MAX_ARGUMENT_NUM            2
+#define     MAX_ARGUMENT_SIZE           40
+
+//for terminal
+#define     MAX_BUF_SIZE                128
+#define     MAX_TERMINAL                3
+#define     COL_NUM                     80
+#define     ROW_NUM                     25
+#define     TERM_VID                    0xB8000  //this is the address of the display video memory of the termianl
+#define     TERM0_VID                   0xB9000
+#define     TERM1_VID                   0xBA000
+#define     TERM2_VID                   0xBB000
+
+//for process
+#define     NON_EXIST                   0x00
+#define     RUNNING                     0x01
+#define     WAITING                     0x02
+#define     MAX_PROCESS                 6
+
+//special place in memory
+#define     KERNEL_ADDR                 0x00400000
+#define     VIDEO_ADDR                  0x000B8000 /* Shifting required to write to registers correctl */
+#define     VIDEO_MEM                   0xB8 /* Shifting required to write to registers correctl */
+#define     STACK                       0x8400000 /* 132 MB */
+
+#define     TABLE_SIZE                  4
+#define     USER_FILE_START             2
+#define     STDIN_FD                    0
+#define     STDOUT_FD                   1
+
+
+//special character
+#define     NULL                        0
+
+#define     _1_MB                       0x100000
+#define     _2_MB                       0x200000
+#define     _4_MB                       0x400000
+#define     _8_MB                       0x800000
+#define     _128_MB                     0x8000000
+#define     _132_MB                     0x8400000
+
+#define     _1_KB                       1024
+#define     _4_KB                       4096
+#define     _8_KB                       0x2000
+
+#define     AS_DEL                      0x7F
+#define     AS_E                        0x45
+#define     AS_L                        0x4C
+#define     AS_F                        0x46
+#define     AS_NL                       0x0A
 
 
 
@@ -110,82 +116,92 @@ typedef struct boot {
     dentry_t    dentries[MAX_NUM_DENTRY];
 } boot_block_t;
 
-/*---------------------------- Process Structure ----------------------------*/
+/*---------------------------- PCB Structure ----------------------------*/
 
 /* File operations table pointer */
-typedef struct f_table {
+typedef struct function_table {
     int32_t (*open)(const uint8_t* filename);
     int32_t (*close)(int32_t fd);
     int32_t (*read)(int32_t fd, void* buf, int32_t nbytes);
     int32_t (*write)(int32_t fd, const void* buf, int32_t nbytes);
-} f_table;
-
+} f_table_t;
 
 /* File Object structure - for PCB */
 typedef struct file_object {
-    f_table     fileop_ptr; /* Only valid for data file */
+    f_table_t   fileop_ptr;     /* Only valid for data file */
     uint32_t    inode_index;
-    uint32_t    file_pos;   /* Current position in file, updated by system calls */
-    uint32_t    flags;      /* If flag is set, file object is in use */
+    uint32_t    file_pos;       /* Current position in file, updated by system calls */
+    uint32_t    flags;          /* If flag is set, file object is in use */
 } file_object_t;
 
-
 /* Process control block structure */
 typedef struct pcb {
 
     file_object_t   fd[MAX_FILE_NUM]; /* File descriptor array */
-    uint32_t        parent_pid; /* Holds parent process ID */
+
+    uint32_t        pid;              /* Holds current process ID */
+    uint32_t        current_esp;        //newly added, need initilization
+    uint32_t        current_ebp;        //newly added, need initilization
+    uint32_t        current_eip;        //newly added, need initilization
+
     struct pcb*     parent_pcb;
-    uint32_t        pid; /* Holds current process ID */
+    uint32_t        parent_pid;       /* Holds parent process ID */
+    uint32_t        parent_esp;       /* Stores Kernel ESP, EBP*/
+    uint32_t        parent_ebp;       /* Stores Kernel ESP, EBP*/
 
-    uint32_t        tss_esp0;/* saves TSS before context switch */
-    uint32_t        parent_esp;    /* Stores Kernel ESP, EBP*/
-    uint32_t        parent_ebp;    /* Stores Kernel ESP, EBP*/
+    uint32_t        tss_esp0;         /* saves TSS before context switch */
 
-    //uint8_t         status;/* ---UNUSED--- */
-    uint8_t         cmd[MAX_COMMAND_SIZE]; /* Command */
+    uint32_t        arg_num;          /* Number of arguments in argv */
+    uint8_t         cmd[MAX_COMMAND_SIZE];  /* Command */
     uint8_t         argv[MAX_ARGUMENT_NUM][MAX_ARGUMENT_SIZE]; /* Argument table */
 
-    uint32_t        arg_num;       /* Number of arguments in argv */
-
 } pcb_t;
 
 /*---------------------------- Terminal Structure ----------------------------*/
 
-/* Terminal structure - Upto 3 terminals supported */
+/* Terminal structure - Up to 3 terminals supported */
 typedef struct terminal {
 
          pcb_t*     pcb;
+
          int32_t    terminal_x;
          int32_t    terminal_y;
 
          int32_t    vid_mem;
+         int32_t    terminal_prog_count;
 
 volatile uint8_t    line_buffer[MAX_BUF_SIZE];
 volatile int32_t    buffer_index;
-         int32_t    terminal_prog_count;
 
 } terminal_t;
 
 
-/*----------------------------- Process Structure ----------------------------*/
+
+/*----------------------------- Control Structure ----------------------------*/
 
 typedef struct control {
 
     terminal_t  terminal[MAX_TERMINAL];
     int32_t     cur_terminal;
-    uint8_t     pid_array[MAX_PROCESS];
-    uint32_t    filesys_start;
     int32_t     total_prog_count;
+    uint32_t    filesys_start;
+    int32_t     pid_array[MAX_PROCESS];
 
-} control_t;
+    int32_t     cur_pid;                   //newly added, need initilization
 
+} control_t;
 
 /*---------------------------- Global variable -------------------------------*/
 
 /* Godlike--- */
 control_t control;
 
+f_table_t dir_jumptable    ;
+f_table_t file_jumptable   ;
+f_table_t rtc_jumptable    ;
+f_table_t stdin_jumptable  ;
+f_table_t stdout_jumptable ;
+f_table_t no_jumptable     ;
 
 #endif /* ASM */
 #endif /* _TYPES_H */