Esempio n. 1
0
Ret buddy_free(Buddy* thiz, size_t offset)
{
	return_val_if_fail(thiz!=NULL && (offset%2)==0, RET_FAIL);
	
	int i;
	for(i=0; i<thiz->size; i++)
	{
		Node* iter = foreach_list(thiz->alloc_list[i], (void* )offset, match_block_callback);
		if(iter == NULL) continue;

		delete_from_list(&(thiz->alloc_list[i]), iter);
		free(iter); iter = NULL;

		Node* buddy_iter = foreach_list(thiz->free_list[i], (void* )offset, match_block_callback);
		if(buddy_iter == NULL)
		{
			return RET_OK;
		}

		delete_from_list(&(thiz->free_list[i]), buddy_iter);
		buddy_iter->size = buddy_iter->size + 1;
		insert_head(&(thiz->free_list[buddy_iter->size - 1]), buddy_iter);
		//TODO merge should be recurive.
	}
	
	return RET_FAIL;
}
Esempio n. 2
0
/**********************************************************
 * main: Prompts the user to enter an operation code,     *
 *       then calls a function to perform the requested   *
 *       action. Repeats until the user enters the        *
 *       command 'q'. Prints an error message if the user *
 *       enters an illegal code.                          *
 **********************************************************/
int main(void)
{
  char code;

  struct player *team_roster = NULL;  
  printf("Operation Code: a for appending to the roster, d for deleteing a player, f for finding a player"
	  ", p for printing the roster; q for quit.\n");
  for (;;) {
    printf("Enter operation code: ");
    scanf(" %c", &code);
    while (getchar() != '\n')   /* skips to end of line */
      ;
    switch (code) {
      case 'a': team_roster = append_to_list(team_roster);
		break;
      case 'f': find_player(team_roster);
                break;
      case 'p': printList(team_roster);
                break;
      case 'd': delete_from_list(team_roster);
		break; 
      case 'q': clearList(team_roster);
		printf("\n");
		return 0;
      default:  printf("Illegal code");
    }
    printf("\n");
  }
}
Esempio n. 3
0
File: mm.c Progetto: horf31/ece454
/**********************************************************
 * place
 * Mark the block as allocated
 **********************************************************/
void place(void* bp, size_t asize, int from_free_list) {
	// Get the current block size
	size_t bsize = GET_SIZE(HDRP(bp));

	// bp is not from the operation of the extend_heap, so need to remove from free list
	if (from_free_list == 1)
		delete_from_list(bp);

	void * split_bp;

	// Split the block if the difference of the sizes is not less than the minimum block size (2*DSIZE)
	if (asize + 2 * DSIZE <= bsize) {
		// Mark the footer and header with the requested size
		PUT(HDRP(bp), PACK(asize, 1));
		PUT(FTRP(bp), PACK(asize, 1));

		// Find the next block ptr as split ptr
		split_bp = NEXT_BLKP(bp);

		// Mark the footer and header of the splitted block
		PUT(HDRP(split_bp), PACK((bsize-asize), 0));
		PUT(FTRP(split_bp), PACK((bsize-asize), 0));

		// Insert this free block to the list
		insert_freelist(split_bp);

	} else { // Not enough size to split, mark the footer and header
		PUT(HDRP(bp), PACK(bsize, 1));
		PUT(FTRP(bp), PACK(bsize, 1));
	}

}
Esempio n. 4
0
void PrivPtr::shrink_ptr(priv_ptr ptr, int current_index, int parent_index, int threadID)
{
	//first, find the first node in the list that appears in the matching if body
	listnode first = ptr->list->head->next; 
	while(first != ptr->list->tail)
	{
		if(first->if_index >= current_index)
			break; 	
		first = first->next; 
	}
	 // second, remove all the nodes located in parallel -- use parent_index
	listnode tmp = ptr->list->head->next; 
        while(tmp != first)
	{
		if(tmp->if_index >= parent_index)
			break; 			
		tmp = tmp->next; 
	}
 	//remove all the nodes from tmp to the node right before first
	listnode tmp1 = NULL; 
	int index = 0;
	while(tmp != first)
	{	
		tmp1 = tmp->next; 
		delete_from_list(&tmp);
		index++;  
		tmp = tmp1; 
	}
	if(index > 0)
	{
		ptr->size -= index; 
	} 
	return; 
}
Esempio n. 5
0
int main()
{
	// Initialize a list
	struct node *head = malloc(sizeof(struct node));
	head->value = 7;
	for (int i = 7; i > 0; --i) {
		head = add_to_list(head, i);
		if (head == NULL) { return EXIT_FAILURE; }
	}

	// Delete 1 and 4
	delete_from_list(&head, 1);
	delete_from_list(&head, 4);

	// Write out the list
	for (struct node *iter = head; iter != NULL; iter = iter->next) { printf("%d ", iter->value); }
	printf("\b\n");

	// Search 5
	struct node *found = search_list(head, 5);
	if (found != NULL) { printf("%d found\n", found->value); }

	// Search 10
	found = search_list(head, 10);
	if (found == NULL) { printf("10 not found\n"); }

	// Count 7 and 2
	printf("The list contains %d seven\n", count_occurrencies(head, 7));
	printf("The list contains %d two\n", count_occurrencies(head, 2));

	// Find last 7
	struct node *last = find_last(head, 7);
	if (last->next != NULL) { fprintf(stderr, "That seven is not the last one\n"); }
	else { printf("Found %d\n", last->value); }

	// Find 1
	last = find_last(head, 1);
	if (last != NULL) { fprintf(stderr, "Found an inexistent element?!\n"); }
	else { printf("1 not found\n"); }

	// Free memory
	clear_list(head);
	return EXIT_SUCCESS;
}
Esempio n. 6
0
void PrivPtr::clear_list(dlist* list)
{
	listnode tmp = (*list)->head->next;
	listnode tmp1;  
	while(tmp != (*list)->tail)
	{
		tmp1 = tmp->next; 
		delete_from_list(&tmp);	
		tmp = tmp1;  
	}
	
}
Esempio n. 7
0
/**************************************************************************
 * Public Functions 
 **************************************************************************/
void catchChild(int signum)//child return or terminate callback
{
    //printf("Child died!%d\n",signum);
    pid_t pid;
    int status;
    delete_from_list(waitpid(-1,&status,WNOHANG));
    
    while((pid = waitpid(-1,&status,WNOHANG|WUNTRACED)) != -1)
    {
        delete_from_list(pid);
        return;

        // if (WIFEXITED(status))
        //     printf("Child ended normally.n");
        // else if (WIFSIGNALED(status))
        //     printf("Child ended because of an uncaught signal.n");
        // else if (WIFSTOPPED(status))
        //     printf("Child process has stopped.n");
    }
    //siglongjmp( env, 1 );   
}
Esempio n. 8
0
File: mm.c Progetto: horf31/ece454
/**********************************************************
 * coalesce
 * Covers the 4 cases discussed in the text:
 * - both neighbours are allocated
 * - the next block is available for coalescing
 * - the previous block is available for coalescing
 * - both neighbours are available for coalescing
 **********************************************************/
void *coalesce(void *bp) {
	size_t prev_alloc = GET_ALLOC(FTRP(PREV_BLKP(bp)));
	size_t next_alloc = GET_ALLOC(HDRP(NEXT_BLKP(bp)));
	size_t size = GET_SIZE(HDRP(bp));

	/* Case 1: |ALLOC|<bp>|ALLOC| cannot coalesce */
	if (prev_alloc && next_alloc) {
		return bp;
	}

	/* Case 2: |ALLOC|<bp>|FREE| can coalesce with the next block */
	else if (prev_alloc && !next_alloc) {
		delete_from_list(NEXT_BLKP(bp));  // Remove the free block from the list
		size += GET_SIZE(HDRP(NEXT_BLKP(bp)));  // Calculate the combined total size
		PUT(HDRP(bp), PACK(size, 0));  // Set the header
		PUT(FTRP(bp), PACK(size, 0));  // Set the footer
		return (bp);
	}

	/* Case 3: |FREE|<bp>|ALLOC| can coalesce with the prev block */
	else if (!prev_alloc && next_alloc) {
		delete_from_list(PREV_BLKP(bp));  // Remove the free block from the list
		size += GET_SIZE(HDRP(PREV_BLKP(bp)));  // Calculate the combined total size
		PUT(FTRP(bp), PACK(size, 0));  // Set the header
		PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0));  // Set the footer
		return (PREV_BLKP(bp));
	}

	/* Case 4: |FREE|<bp>|FREE| both sides are free, can coalesce both */
	else {
		delete_from_list(PREV_BLKP(bp));  // Remove the free blocks from the list
		delete_from_list(NEXT_BLKP(bp));
		size += GET_SIZE(HDRP(PREV_BLKP(bp))) + GET_SIZE(FTRP(NEXT_BLKP(bp)));  // Calculate the combined total size
		PUT(HDRP(PREV_BLKP(bp)), PACK(size,0));  // Set the header
		PUT(FTRP(NEXT_BLKP(bp)), PACK(size,0));  // Set the footer
		return (PREV_BLKP(bp));
	}
}
Esempio n. 9
0
int main()
{
	mylist *head = NULL;
	mylist *found;
	mylist *previous;
	int element;
	int c;
	printf("hi,This program does basic linklist manupulation.\n");
	printf("what would you like to do?\n");
	printf("Press:\nc for creating a list.");
	printf("\na for appending an element to the list.");
	printf("\ns for searching for an element.");
	printf("\nd for deleting an element.");
	printf("\np for printing the list.");
	printf("\ne for exiting program.\n");
	while ((c = getchar())) {
		switch (c) {
			case 'c':
				head = create_list();
				printf("list created\n");
				break;
			case 'a':
				printf ("type in element to add\n");
				scanf ("%d",&element);
				added = add_element(&head , element);
				break;
			case 's':
				printf ("type in element to search for\n");
				scanf ("%d",&element);
				found = search_for_element(&head , element , &previous);
				if (found)
				printf("found: %d\n",found->var);
				else
				printf("not found\n");
				break;
			case 'd':
				printf ("type in element to delete\n");
				scanf ("%d",&element);
				delete_from_list(&head , element);
				break;
			case 'p':
				print_list(&head);
				break;
			case 'e':
				return 0;
		}
	}
	return 0;
}
Esempio n. 10
0
int main(void)
{
    int i = 0, ret = 0;
    struct test_struct *ptr = NULL;

    print_list();

    for(i = 5; i<10; i++)
        add_to_list(i,true);

    print_list();

    for(i = 4; i>0; i--)
        add_to_list(i,false);

    print_list();

    for(i = 1; i<10; i += 4)
    {
        ptr = search_in_list(i, NULL);
        if(NULL == ptr)
        {
            printf("\n Search [val = %d] failed, no such element found\n",i);
        }
        else
        {
            printf("\n Search passed [val = %d]\n",ptr->val);
        }

        print_list();

        ret = delete_from_list(i);
        if(ret != 0)
        {
            printf("\n delete [val = %d] failed, no such element found\n",i);
        }
        else
        {
            printf("\n delete [val = %d]  passed \n",i);
        }

        print_list();
    }

    return 0;
}
Esempio n. 11
0
int main (void)
{
	int num = 5;
	struct node *my_node = malloc(sizeof(struct node));
	my_node->value = num;
	my_node->next = NULL;

	read_numbers();
	printf("my_node add: %p\n", (void *)my_node);
	print_list(top);
	top = insert_into_ordered_list(top, my_node);
	print_list(top);
	print_list(find_last(top, 2));
	delete_from_list(&top, num);
	print_list(top);

	return 0;
}
/*******************************************************************
DELETE_FROM_LIST(b,NEWLIST) = NEWLIST;
DELETE_FROM_LIST(b,ADDLIST(t,l))        = if b=t then l
                                    else ADDLIST(DELETE_FROM_LIST(b,l));
*******************************************************************/
BOXLIST *delete_from_list(BOX *box,BOXLIST *boxlistpointer)
{
    if(boxlistpointer==NULL)
        return NULL;

    if(box==boxlistpointer->box)
    {
        scrub_box(box);
        scrub_boxlist(boxlistpointer);
        return boxlistpointer->link;
    }
    else
    {
        boxlistpointer->link=delete_from_list(box,
                                              boxlistpointer->link);
        return boxlistpointer;
    }
}
Esempio n. 13
0
/*
 * place - transform a free block to an allocated block,
 * then delete old free block from its free list
 * and insert the rest part to the corresponding free list
 */
static void place(void *bp, size_t alloc_block_size) {
    size_t size;
    delete_from_list(bp);
    size = block_size(bp);
    dbg_printf("want to place a %d size allocated block from a %d size free block\n", (int)alloc_block_size, (int)size);
    if (size - alloc_block_size >= 4 * WSIZE) {
        /* have rest part for a new free block */
        if (last_block == bp) {
            last_block = bp + alloc_block_size;
        }
        mark(bp, alloc_block_size, block_prev_alloc(bp), 1);
        bp += alloc_block_size;
        mark(bp, size - alloc_block_size, 1, 0);
        insert_to_list(bp);
    } else {
        /* have no rest part for a new free block */
        mark(bp, size, block_prev_alloc(bp), 1);
        mark(next_block(bp), block_size(next_block(bp)), 1, block_alloc(next_block(bp)));
    }
}
Esempio n. 14
0
/*
 * coalesce - boundary tag coalescing
 * will delete coalesced old blocks from the free list, and
 * will insert the new block to the free list
 * return pointer to coalesced block
 */
static void *coalesce(void *bp) {
    size_t prev_alloc, next_alloc;
    size_t size;
    prev_alloc = block_prev_alloc(bp);
    next_alloc = block_alloc(next_block(bp));
    size = block_size(bp);
    dbg_printf("want to coalesce %d size block, prev alloc: %d, next alloc: %d\n", (int)size, (int)prev_alloc, (int)next_alloc);
    if (prev_alloc && next_alloc) { // alloc - free - alloc
        return bp;
    } else if (prev_alloc && !next_alloc) { // alloc - free - free
        delete_from_list(bp);
        delete_from_list(next_block(bp));
        if (next_block(bp) == last_block) {
            last_block = bp;
        } 
        size += block_size(next_block(bp));
        mark(bp, size, prev_alloc, 0);
        insert_to_list(bp);
    } else if (!prev_alloc && next_alloc) { // free - free (- alloc)
        delete_from_list(prev_block(bp));
        delete_from_list(bp);
        if (bp == last_block) {
            last_block = prev_block(bp);
        }
        size += block_size(prev_block(bp));
        bp = prev_block(bp);
        mark(bp, size, block_prev_alloc(bp), 0);
        insert_to_list(bp);
    } else if (!prev_alloc && !next_alloc) { // free - free - free
        delete_from_list(prev_block(bp));
        delete_from_list(bp);
        delete_from_list(next_block(bp));
        if (next_block(bp) == last_block) {
            last_block = prev_block(bp);
        }
        size += block_size(prev_block(bp)) + block_size(next_block(bp));
        bp = prev_block(bp);
        mark(bp, size, block_prev_alloc(bp), 0);
        insert_to_list(bp);
    }
    return bp;
}
Esempio n. 15
0
int main ()
{
    list l = create_list();
    prepend (&l, (void*)2);
    append (&l, (void*)17);
    insert_in_list (&l, 3, (void*)1);
    insert_in_list (&l, 2, (void*)14);
    display_list(l);
    printf ("\n");
    display_list_reverse(l);
    printf ("\n");
    delete_from_list (&l,2);
    display_list(l);
    printf ("\n");
    display_list_reverse(l);
    printf ("\n");
    set (l, 3, (void*)5);
    display_list(l);
    printf ("\n");
    display_list_reverse(l);
    return 0;
}
Esempio n. 16
0
// Desc : 연결 리스트를 전체 삭제
// Param : head -  리스트의 헤드 포인터
void delete_list(ListNode *head)
{
	while (head != NULL)
		head = delete_from_list(head, head, 1);
}
Esempio n. 17
0
File: mm.c Progetto: horf31/ece454
/**********************************************************
 * mm_realloc
 * Implemented simply in terms of mm_malloc and mm_free
 *********************************************************/
void *mm_realloc(void *ptr, size_t size) {

	/* Case 1: If size == 0 then this is just free, and we return NULL. */
	if (size == 0) {
		mm_free(ptr);
		return NULL;
	}

	/* Case 2: If oldptr is NULL, then this is just malloc. */
	if (ptr == NULL) {
		return (mm_malloc(size));
	}

	/* Case 3: Size is equal or smaller than the original size, return or split */
	size_t old_size = GET_SIZE(HDRP(ptr));          /* current block size */
	size_t asize;                                   /* adjusted requested block size */

	// Adjust block size to include overhead and alignment reqs.
	if (size <= DSIZE)
		asize = 2 * DSIZE;
	else
		asize = DSIZE * ((size + (DSIZE) + (DSIZE - 1)) / DSIZE);

	// If old_size is greater than the minimum block size and new size, then split
	if (old_size >= asize + 2 * DSIZE) {
		split(ptr, asize, old_size);
		return ptr;
	} else if (old_size >= asize) { // If not enough space to split, just return
		return ptr;
	}

	/* Case 4: Check next neighboring block, if free, and the combined size is equal to or greater than size, combine */
	size_t next_alloc = GET_ALLOC(HDRP(NEXT_BLKP(ptr)));      /* allocative state of the next block */
	size_t next_size = GET_SIZE(HDRP(NEXT_BLKP(ptr)));        /* size of the next block */
	size_t remainder_size;

	if ((int) next_alloc == 0 && old_size + next_size >= asize) {
		delete_from_list(NEXT_BLKP(ptr)); // Remove from the free list

		// If the combined space is too large, split
		if (old_size + next_size > asize + 2 * DSIZE) {
			PUT(HDRP(ptr), PACK(asize, 1));  // Mark the footer and header of the realloc'd block
			PUT(FTRP(ptr), PACK(asize, 1));
			remainder_size = old_size + next_size - asize; // Calculate the remainder size of the splitted block
			PUT(HDRP(NEXT_BLKP(ptr)), PACK(remainder_size, 0));  // Mark the footer and header for the splitted block
			PUT(FTRP(NEXT_BLKP(ptr)), PACK(remainder_size, 0));
			insert_freelist((intptr_t *) NEXT_BLKP(ptr));
		} else { // No enough space to split
			PUT(HDRP(ptr), PACK(old_size+next_size, 1));  // Mark the footer and header of the realloc'd block
			PUT(FTRP(ptr), PACK(old_size+next_size, 1));
		}
		return ptr;
	}

	/* Case 5: Current block is at the end of the heap, just extend heap */
	// Check if the next block ptr is at the end of the heap
	if (NEXT_BLKP(ptr) > (char*)mem_heap_hi() ) {
		size_t extendsize = asize - old_size; // Calculate the size needed to extend
		intptr_t * bp;
		if ((bp = extend_heap(extendsize / WSIZE)) == NULL) // Extend the heap
			return NULL;
		PUT(HDRP(ptr), PACK(asize, 1));  // Mark the footer and header
		PUT(FTRP(ptr), PACK(asize, 1));
		return ptr;
	}

	/* Case 6: Check previous neighboring block, if free, and the combined size is equal to or greater than size, combine and move the content */
	intptr_t * prev_p = (intptr_t *)PREV_BLKP(ptr); /* previous block's ptr */
	size_t prev_alloc = GET_ALLOC(HDRP(prev_p));    /* allocative state of the prev block */
	size_t prev_size = GET_SIZE(HDRP(prev_p));      /* size of the next block */

	if ((int) prev_alloc == 0 && old_size + prev_size >= asize) {
		delete_from_list(PREV_BLKP(ptr));  // Remove from the free list
		memmove(prev_p, ptr, asize);  // Move the content to the new starting ptr

		// If the combined space is too large, split
		if (old_size + prev_size > asize + 2 * DSIZE) {
			PUT(HDRP(prev_p), PACK(asize, 1));  // Mark the footer and header of the realloc'd block
			PUT(FTRP(prev_p), PACK(asize, 1));
			remainder_size = old_size + prev_size - asize;  // Calculate the remainder size of the splitted block
			PUT(HDRP(NEXT_BLKP(prev_p)), PACK(remainder_size, 0));  // Mark the footer and header for the splitted block
			PUT(FTRP(NEXT_BLKP(prev_p)), PACK(remainder_size, 0));
			insert_freelist((intptr_t *) NEXT_BLKP(prev_p));
		} else { // No enough space to split
			PUT(HDRP(prev_p), PACK(old_size+prev_size, 1));  // Mark the footer and header of the realloc'd block
			PUT(FTRP(prev_p), PACK(old_size+prev_size, 1));
		}
		return prev_p;
	}

	/* Case 7: Malloc a new block, copy the content, free the old block */

	void *oldptr = ptr;
	void *newptr;

	newptr = mm_malloc(size); // Malloc a new block
	if (newptr == NULL)
		return NULL;

	// Copy the old data.
	if (size < old_size)
		old_size = size;
	memcpy(newptr, oldptr, old_size);
	mm_free(oldptr);  // Free the old block
	return newptr;
}
Esempio n. 18
0
void delete_from_alloc_list(const void *ptr) {
  assert(ptr);
  HeapStruct *node = delete_from_list(alloc_list, ptr);
  assert(node);
  free(node);
}
Esempio n. 19
0
void
NMEnumerationCallback(
	void *inContext,
	NMEnumerationCommand inCommand, 
	NMEnumerationItem *item)
{
	struct list_item_data *list_data= (struct list_item_data *) inContext;
	short index;

	switch(inCommand)
	{
		case kNMEnumAdd:
			for(index= 0; index<list_data->count; ++index)
			{
				if (list_data->host[index]==item->id) DEBUG_PRINT("Got multiple adds for id %d", item->id);
			}
			
			if (index==list_data->count)
			{
				list_data->host[list_data->count++]= item->id;
				index= add_text_to_list(list_data->dialog, iGameList, item->name);
				op_assert(index==list_data->count-1);
			}
			break;
			
		case kNMEnumDelete:
		{
			NMBoolean found = false;
			for(index= 0; index<list_data->count; ++index)
			{
				if (list_data->host[index]==item->id) 
				{
					found = true;
					// remove from list.
					delete_from_list(list_data->dialog, iGameList, index);
					
					// from cache
					memmove(&list_data->host[index], &list_data->host[index+1], 
						list_data->count-index-1);
					list_data->count--;
					break;
				}
			}
			
			if (!found)
			{
				DEBUG_PRINT("Got a remove for something I don't have in my list?? (%d %s)",item->id, item->name);
			}
			break;
		}
		case kNMEnumClear:
			empty_list(list_data->dialog, iGameList);
			list_data->count= 0;
			break;
			
		default:
			DEBUG_PRINT("Command %d unrecognized in NMEnumerationCallback", inCommand);
			break;

	}
	
	return;
}
Esempio n. 20
0
int main(int argc, char*argv[], char*envp[]){

	char next_char;
	int i, fd;
	copy_envp(envp);
	char changepath[1024]; 
	head = (struct node *) malloc( sizeof(struct node) ); 
	head->next = NULL;   
    head->val = 0;
	struct node *ptr = (struct node *)malloc(sizeof(struct node *));
	ptr->val=0;
	ptr->next = NULL;
	head = current = ptr;

	/** clears screen for RSI **/
	if(fork() == 0) {
		execvp("clear", argv);
		exit(1);
	} else {
		wait(NULL);
	}


	/** Prints prompt for first time **/
	strcpy(cwd,"");
	if (getcwd(cwd, sizeof(cwd)) == NULL){
		perror("getcwd() error");
	}
	printf("RSI: %s >  ", cwd);
	fflush(stdout);	
	




	char word[24] = "\0";
	char* args[256];
	int m  = 0;
	int child_pid;
	int h;
	char command[24];
	static char arg_buffer[256] = "\0";




    /* while user has not pushed ctrl-d */
	while(next_char != EOF){



		/* gets next char typed in cmd line, adds to words. */
		/* puts the words (arguments) into argv *************/
		next_char=getchar();
		if(isspace(next_char) == 0){
			strncat(word, &next_char, 1);

		} else{
			strcpy(command, word);
			args[m] = (char *)malloc(sizeof(char) * 100);
			strcpy(args[m], command);
			strcpy(word, "");
			m++;
		}
		
		/* if the line is done, ...*/
		if(next_char == '\n'){

			args[m] = (char *)malloc(sizeof(char) * 2);
			args[m] = NULL;
			int r = 0;
			int j = 0;
			int wpid;

			/* if statements check if cmd is bg, bglist, or cd.  */
			/* if not, it executes the command, waits for the child to complete, then prompts again */

			if (strcmp(args[0], "cd" ) == 0){
				change_directory(args, changepath, envp);
			}

			else if(strcmp(args[0], "\0")==0){
				printf("\nNo Command Entered.\n");
			}

			else if(strcmp(args[0], "bglist") == 0){
				bglist();
			}

			/** if it's a bg process, execute process, add info to list, then continue. **/
			else if(strcmp(args[0], "bg") == 0){

				for(r = 0; r<m-1; r++){
					bzero(args[r], sizeof(args[r]));
					strcpy(args[r],args[r+1]);
					
				}
				bzero(args[m-1], sizeof(args[m-1]));
				args[m-1] = NULL;

				if ((child_pid=fork()) == 0) {
					h = execvp(args[0], args);
					printf("errno is %d\n", errno);	
				}

				else {
					int c = 1;
					/* combine separate args to single string for node and future printout at bglist */
					for(c=1; c<m-1; c++){
						strcat(arg_buffer, args[c]);
						strcat(arg_buffer, " ");
					}
					
					add_to_list(child_pid, args[0], arg_buffer);
					bzero(arg_buffer, 256);
				}	
			}	

			/* execute process, then wait until process has finished to continue */
			else {
				pid_t num;
				if ((num = fork()) == 0){
					h = execvp(args[0], args);
					printf("errno is %d\n", errno);
				}
				else {
					waitpid(num, NULL, 0); 
				}

			}

			m = 0;


			/* gets cwd and checks for finished processes.  If there are, remove them from the list of bg processes. */
			strcpy(cwd,"");
			if (getcwd(cwd, sizeof(cwd)) == NULL){
				perror("getcwd() error");
			}
			int status;
		   	int pid;
		    	/* waitpid() returns a PID on success*/
		    	for(;;){
		    		pid = waitpid(-1, &status, WNOHANG);
		    		if(pid <= 0){
		    			break;
		    		}
		    		printf("[proc %d exited with code %d]\n", pid, WEXITSTATUS(status));
				delete_from_list(pid);
		    	}
		    /* prints prompt */
			printf("\nRSI: %s >  ", cwd);
			fflush(stdout);

		}		
	}

}