481 lines
14 KiB
C
481 lines
14 KiB
C
|
// linked.c ANSI C kernel environment linked list
|
||
|
|
// requires kmalloc to allocate space for linked list
|
||
|
|
|
||
|
|
#include "linked.h"
|
||
|
|
|
||
|
|
// Create a blank node using kmalloc, then use allocated memory to store
|
||
|
|
// a linked list node with the values passed in the parameters
|
||
|
|
// You must capture the node returned with an lval result variable
|
||
|
|
node *create_node( u32 base_register, u32 limit_register, bool ft_hole_mem, u32 id)
|
||
|
|
{
|
||
|
|
node *new_node = NULL;
|
||
|
|
|
||
|
|
new_node = (node *) kmalloc( NODE_SIZE, 0, (u32 *) new_node);
|
||
|
|
new_node->id = id;
|
||
|
|
new_node->base_register = base_register;
|
||
|
|
new_node->limit_register = limit_register * (new_node->id + 1);
|
||
|
|
new_node->ft_hole_mem = ft_hole_mem;
|
||
|
|
new_node->next = NULL;
|
||
|
|
new_node->previous = NULL;
|
||
|
|
|
||
|
|
return( new_node);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Creates a node from parameters using the above and then passes it to insert the node into the linked list
|
||
|
|
// changes to *head will only affect a local stack variable
|
||
|
|
// You must capture the new head returned with an lval result variable to update head changes
|
||
|
|
// ft_hole_mem is not used currently but is included to maintain a "holes" list
|
||
|
|
// true means update memory list, false means update holes list (if you were to use it)
|
||
|
|
node *add_node( node *head, u32 base_register, u32 limit_register, bool ft_hole_mem, u32 id)
|
||
|
|
{
|
||
|
|
node *new_node = NULL;
|
||
|
|
|
||
|
|
new_node = create_node( base_register, limit_register, ft_hole_mem, id);
|
||
|
|
head = _add_node( head, new_node);
|
||
|
|
return( head);
|
||
|
|
}
|
||
|
|
|
||
|
|
// place an already created node at the end of the list
|
||
|
|
// changes to *head will only affect a local stack variable
|
||
|
|
// You must capture the new head returned with an lval result variable to update head changes
|
||
|
|
node *_add_node( node *head, node *new_node)
|
||
|
|
{
|
||
|
|
node *iterator = NULL;
|
||
|
|
node *previous = NULL;
|
||
|
|
|
||
|
|
if( new_node == NULL) {
|
||
|
|
return(head);
|
||
|
|
}
|
||
|
|
if( head == NULL) {
|
||
|
|
head = new_node;
|
||
|
|
return ( head );
|
||
|
|
} // Stop here is head is empty and just set to new and return new head.
|
||
|
|
|
||
|
|
iterator = head->next; // Head is not NULL so continue with next node as iterator
|
||
|
|
while( iterator != NULL) {
|
||
|
|
previous = iterator;
|
||
|
|
iterator = iterator->next;
|
||
|
|
} // until iterator is null keep pointing new node back to previous node and iterator to next node
|
||
|
|
|
||
|
|
if( previous == NULL) { // just head existed, append new node ...
|
||
|
|
new_node->previous = head;
|
||
|
|
head->next = new_node;
|
||
|
|
} else { // iterated to end of list, append new node ...
|
||
|
|
new_node->previous = previous;
|
||
|
|
previous->next = new_node;
|
||
|
|
} // ... and return
|
||
|
|
return( head);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Iterate to last node and list and then append new node to it
|
||
|
|
node *append_node( node *head, node* new_node)
|
||
|
|
{
|
||
|
|
node *iterator = head;
|
||
|
|
|
||
|
|
if( new_node == NULL) {
|
||
|
|
return( head);
|
||
|
|
}
|
||
|
|
if( head == NULL) {
|
||
|
|
return( new_node);
|
||
|
|
}
|
||
|
|
while( iterator->next != NULL) { // step until at last node
|
||
|
|
iterator = iterator->next;
|
||
|
|
}
|
||
|
|
iterator->next = new_node;
|
||
|
|
new_node->previous = iterator;
|
||
|
|
new_node->next = NULL;
|
||
|
|
return(head);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Given an input id search list until id found
|
||
|
|
// return lval of that *node value otherwise return a NULL value
|
||
|
|
node *find_id( node *head, u32 id)
|
||
|
|
{
|
||
|
|
if( head == NULL) {
|
||
|
|
return( head);
|
||
|
|
}
|
||
|
|
node *iterator = head;
|
||
|
|
|
||
|
|
while(( iterator != NULL) && ( iterator->id != id)) { // search and compare id
|
||
|
|
iterator = iterator->next;
|
||
|
|
}
|
||
|
|
return( iterator);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Given an id, find it with the function above and then use node* value (target)
|
||
|
|
// to create a gap of previous and next nodes which is then closed.
|
||
|
|
// if id is not found nothing happens
|
||
|
|
node *remove_node_by_id( node *head, u32 id)
|
||
|
|
{
|
||
|
|
node *target = NULL;
|
||
|
|
|
||
|
|
target = find_id( head, id);
|
||
|
|
if( target == NULL) {
|
||
|
|
return( head);
|
||
|
|
}
|
||
|
|
head = zip_list( head, target);
|
||
|
|
free_node( target);
|
||
|
|
return( head);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Given a specific lval node* target value, remove it from the list *head
|
||
|
|
// and then close the gap created by removing target.
|
||
|
|
node *zip_list( node *head, node* target)
|
||
|
|
{
|
||
|
|
bool has_previous = true;
|
||
|
|
bool has_next = true;
|
||
|
|
|
||
|
|
if( target == NULL) {
|
||
|
|
return( head);
|
||
|
|
}
|
||
|
|
if( target->previous == NULL) {
|
||
|
|
has_previous = false;
|
||
|
|
#ifdef KDEBUG
|
||
|
|
kprint("has_previous FALSE\n");
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
if ( target->next == NULL) {
|
||
|
|
has_next = false;
|
||
|
|
#ifdef KDEBUG
|
||
|
|
kprint("has_next FALSE\n");
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
if( (has_next == true) && (has_previous == true)) { // Node in middle of chain
|
||
|
|
target->previous->next = target->next;
|
||
|
|
target->next->previous = target->previous;
|
||
|
|
} else if ( (has_next == false && has_previous == true)) { // Node at end of chain
|
||
|
|
target->previous->next = NULL;
|
||
|
|
} else if ( (has_next == true && has_previous == false)) { // Node at start of chain
|
||
|
|
target->next->previous = NULL;
|
||
|
|
head = head->next;
|
||
|
|
} else { // ( has_next == false && has_previous == false) // Node is isolated
|
||
|
|
head = NULL;
|
||
|
|
}
|
||
|
|
return(head);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Use find_id to get the insert_point
|
||
|
|
// decide if insertion is before or after
|
||
|
|
// if ft_before_after = FALSE then insert before target
|
||
|
|
// if ft_before_after = TRUE then append after target
|
||
|
|
node *insert_node( node *head, node* insert_point, node *new_node, bool ft_before_after)
|
||
|
|
{
|
||
|
|
if( new_node == NULL) { // Nothing to add so return unchanged
|
||
|
|
return( head);
|
||
|
|
}
|
||
|
|
if( insert_point == NULL) { // If no point specified either place before head or after tail
|
||
|
|
if( ft_before_after) { // if after is set append as new tail
|
||
|
|
head = append_node( head, new_node);
|
||
|
|
} else { // if before than insert before head as new head
|
||
|
|
new_node->next = head;
|
||
|
|
new_node->previous = NULL;
|
||
|
|
head-> previous = new_node;
|
||
|
|
return( new_node); // return new head
|
||
|
|
}
|
||
|
|
return( head);
|
||
|
|
}
|
||
|
|
|
||
|
|
if( ft_before_after) { // if adding after then...
|
||
|
|
if( insert_point->next != NULL) { // insert node after insertion_point
|
||
|
|
insert_point->next->previous = new_node;
|
||
|
|
new_node->next = insert_point->next;
|
||
|
|
} else { // insertion point is last node instead, skip above operations
|
||
|
|
new_node->next = NULL;
|
||
|
|
}
|
||
|
|
new_node->previous = insert_point;
|
||
|
|
insert_point->next = new_node;
|
||
|
|
} else {
|
||
|
|
if( insert_point->previous != NULL) { // insert node before insertion point
|
||
|
|
insert_point->previous->next = new_node;
|
||
|
|
new_node->previous = insert_point->previous;
|
||
|
|
} else { // insertion point is head
|
||
|
|
new_node->previous = NULL;
|
||
|
|
head = new_node; // set new head as insertion point
|
||
|
|
}
|
||
|
|
insert_point->previous = new_node;
|
||
|
|
new_node->next = insert_point;
|
||
|
|
}
|
||
|
|
return(head); // return changes (if any) to head
|
||
|
|
}
|
||
|
|
|
||
|
|
node *get_tail( node *head)
|
||
|
|
{
|
||
|
|
if( head == NULL) {
|
||
|
|
return(head);
|
||
|
|
}
|
||
|
|
node *tail = head;
|
||
|
|
while( tail->next != NULL) { // iterate until the next node is not NULL
|
||
|
|
tail = tail->next;
|
||
|
|
}
|
||
|
|
return( tail);
|
||
|
|
}
|
||
|
|
|
||
|
|
void get_min_max_id( node *head, u32 *min, u32 *max)
|
||
|
|
{
|
||
|
|
if( head == NULL) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
node *iterator = head;
|
||
|
|
*min = 0xFFFFFFFF;
|
||
|
|
*max = 0;
|
||
|
|
|
||
|
|
while( iterator != NULL) { // iterate until the next node is not NULL
|
||
|
|
if( *min > iterator->id) {
|
||
|
|
*min = iterator->id;
|
||
|
|
}
|
||
|
|
if( *max < iterator->id) {
|
||
|
|
*max = iterator->id;
|
||
|
|
}
|
||
|
|
iterator = iterator->next;
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
void swap_node_data( node* left, node *right)
|
||
|
|
{
|
||
|
|
if(( left == NULL) || (right == NULL)) {
|
||
|
|
kprint("Invalid element.\n");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
node swap;
|
||
|
|
|
||
|
|
kprint_hex("SWAP ", left->id, 4);
|
||
|
|
kprint_hex(" with ", right->id, 4);
|
||
|
|
kprint("\n");
|
||
|
|
|
||
|
|
swap.id = left->id;
|
||
|
|
swap.base_register = left->base_register;
|
||
|
|
swap.limit_register = left->limit_register;
|
||
|
|
swap.ft_hole_mem = left->ft_hole_mem;
|
||
|
|
|
||
|
|
left->id = right->id;
|
||
|
|
left->base_register = right->base_register;
|
||
|
|
left->limit_register = right->limit_register;
|
||
|
|
left->ft_hole_mem = right->ft_hole_mem;
|
||
|
|
|
||
|
|
right->id = swap.id;
|
||
|
|
right->base_register = swap.base_register;
|
||
|
|
right->limit_register = swap.limit_register;
|
||
|
|
right->ft_hole_mem = swap.ft_hole_mem;
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
node *swap_nodes( node *head, node** left, node **right)
|
||
|
|
{
|
||
|
|
|
||
|
|
if( head == NULL) { // don't swap nodes in a list that is empty
|
||
|
|
return( head);
|
||
|
|
}
|
||
|
|
|
||
|
|
if( (*left == NULL) || (*right == NULL) ) { // if either or both nodes are NULL do nothing
|
||
|
|
return( head);
|
||
|
|
}
|
||
|
|
if ( head == *left) { // if left happens to be head than set head to right
|
||
|
|
head = *right;
|
||
|
|
}
|
||
|
|
if ( head == *right) { // if right happens to be head then set head to left
|
||
|
|
head = *left;
|
||
|
|
}
|
||
|
|
|
||
|
|
node *left_previous = (*left)->previous;
|
||
|
|
node *left_next = (*left)->next;
|
||
|
|
node *right_previous = (*right)->previous;
|
||
|
|
node *right_next = (*right)->next;
|
||
|
|
|
||
|
|
if( (*left)->previous != NULL) { // make sure not to access a NULL value node
|
||
|
|
(*left)->previous->next = *right; // previous node to left now points to right instead of left
|
||
|
|
}
|
||
|
|
|
||
|
|
if( (*left)->next != NULL) { // same
|
||
|
|
(*left)->next->previous = *right; // next node to left now points to right instead of left
|
||
|
|
}
|
||
|
|
|
||
|
|
if( (*right)->previous != NULL) { // same
|
||
|
|
(*right)->previous->next = *left; // same as above but right previous to left now
|
||
|
|
}
|
||
|
|
if( (*right)->next != NULL) { // same
|
||
|
|
(*right)->next->previous = *left; // same as above...
|
||
|
|
}
|
||
|
|
|
||
|
|
(*left)->previous = right_previous; // this will obliterate left->previous so it is preserved in left_previous
|
||
|
|
(*left)->next = right_next; // this will obliterate left->next so it is preserved in left_next
|
||
|
|
|
||
|
|
(*right)->previous = left_previous; // now point right node back to previous to left node (obliterated above)
|
||
|
|
(*right)->next = left_next; // now point right node forward to next of left node (obliterated above)
|
||
|
|
|
||
|
|
node* swap;
|
||
|
|
swap = *left;
|
||
|
|
*left = *right;
|
||
|
|
*right = swap;
|
||
|
|
|
||
|
|
#ifdef KDEBUG
|
||
|
|
kprint("LEFT: ");
|
||
|
|
print_node( *left);
|
||
|
|
kprint(" RIGHT: ");
|
||
|
|
print_node( *right);
|
||
|
|
kprint("\n");
|
||
|
|
#endif
|
||
|
|
|
||
|
|
return( head); // return new head if it changed
|
||
|
|
}
|
||
|
|
|
||
|
|
// good ways to sort a list, transfer it to an array and merge or quicksort it
|
||
|
|
// not so good bubble-sort, insertion, select-sort, heap-sort
|
||
|
|
// worst, this ugly hack
|
||
|
|
node *hacksort_list( node* head, bool ft_descending_ascending)
|
||
|
|
{
|
||
|
|
if( head == NULL) {
|
||
|
|
kprint("LIST EMPTY\n");
|
||
|
|
return(head);
|
||
|
|
}
|
||
|
|
if( ft_descending_ascending) {
|
||
|
|
kprint("ASCENDING\n");
|
||
|
|
} else {
|
||
|
|
kprint("DESCENDING\n");
|
||
|
|
}
|
||
|
|
node* outer_iterator = head;
|
||
|
|
node* inner_iterator = head->next;
|
||
|
|
node* max = head;
|
||
|
|
|
||
|
|
while( outer_iterator != NULL) {
|
||
|
|
max = outer_iterator;
|
||
|
|
inner_iterator = outer_iterator->next;
|
||
|
|
while( inner_iterator != NULL) {
|
||
|
|
if( ft_descending_ascending) {
|
||
|
|
if( max->id > inner_iterator->id) { // This decides ASCENDING
|
||
|
|
max = inner_iterator;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if( max->id < inner_iterator->id) { // This decides SORT DESCENDING
|
||
|
|
max = inner_iterator;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
inner_iterator = inner_iterator->next;
|
||
|
|
/******* STOP COUNTER for Infnite Loop Halting
|
||
|
|
u32 count = 0;
|
||
|
|
if( count++ > 10) {
|
||
|
|
return(head);
|
||
|
|
}
|
||
|
|
****/
|
||
|
|
}
|
||
|
|
if( ( outer_iterator != NULL) && ( outer_iterator != max)) {
|
||
|
|
swap_node_data( outer_iterator, max);
|
||
|
|
}
|
||
|
|
outer_iterator = outer_iterator->next;
|
||
|
|
}
|
||
|
|
return( head);
|
||
|
|
}
|
||
|
|
|
||
|
|
node *mergesort_list( node* head, node *pivot, node *left, node *right)
|
||
|
|
{
|
||
|
|
return( head); // disabled, not yet implemented
|
||
|
|
if( ( head == NULL) || ( pivot == NULL) | ( left == NULL) | ( right == NULL)) {
|
||
|
|
return( head);
|
||
|
|
}
|
||
|
|
node *start = left;
|
||
|
|
node *end = right;
|
||
|
|
while( (start->next != NULL) || (start->id != end->id)) {
|
||
|
|
if( start->id < pivot->id) {
|
||
|
|
;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return( head);
|
||
|
|
}
|
||
|
|
|
||
|
|
// stand in for delete, this only zeroes all the values of the node allocated by kmalloc
|
||
|
|
// the memory is not reclaimed, need to add a tracker for these kmalloc allocated blocks
|
||
|
|
// to implement a proper delete function
|
||
|
|
void free_node( node *target)
|
||
|
|
{
|
||
|
|
memory_set( (u8 *) target, 0, NODE_SIZE);
|
||
|
|
target = NULL;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Print a single node's values
|
||
|
|
void print_node( node *current)
|
||
|
|
{
|
||
|
|
char numstr[16];
|
||
|
|
|
||
|
|
if( current->previous != NULL) {
|
||
|
|
kprint_hex( "(", current->previous->id, 4);
|
||
|
|
kprint( ")<-");
|
||
|
|
} else {
|
||
|
|
kprint("NULL<-");
|
||
|
|
}
|
||
|
|
|
||
|
|
memory_set( (u8 *) numstr, 0, 16);
|
||
|
|
hex_to_ascii( current->id, numstr, 16);
|
||
|
|
kprint("ID: "); kprint( numstr); kprint(" --- ");
|
||
|
|
memory_set( (u8 *) numstr, 0, 16);
|
||
|
|
hex_to_ascii( current->base_register, numstr, 16);
|
||
|
|
kprint("BASE: "); kprint( numstr); kprint(" --- ");
|
||
|
|
memory_set( (u8 *) numstr, 0, 16);
|
||
|
|
hex_to_ascii( current->limit_register, numstr, 16);
|
||
|
|
kprint("LIMIT: "); kprint( numstr); kprint(" --- ");
|
||
|
|
if( current->ft_hole_mem) {
|
||
|
|
kprint("MEMORY ");
|
||
|
|
} else {
|
||
|
|
kprint("HOLE ");
|
||
|
|
}
|
||
|
|
if( current->next != NULL) {
|
||
|
|
kprint_hex( "->", current->next->id, 4);
|
||
|
|
} else {
|
||
|
|
kprint("->NULL");
|
||
|
|
}
|
||
|
|
kprint("\n");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// just print the id separated by commas with a line-feed at the end
|
||
|
|
void shortprint_list( node *head, bool ft_descending_ascending)
|
||
|
|
{
|
||
|
|
if( head == NULL) {
|
||
|
|
kprint( "EMPTY.");
|
||
|
|
kprint("\n");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
node *iterator = NULL;
|
||
|
|
if( ft_descending_ascending) {
|
||
|
|
iterator = head;
|
||
|
|
while( iterator != NULL) {
|
||
|
|
kprint_hex( ",",iterator->id, 4);
|
||
|
|
iterator = iterator->next;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
iterator = get_tail( head);
|
||
|
|
while( iterator != NULL) {
|
||
|
|
kprint_hex( ",",iterator->id, 4);
|
||
|
|
iterator = iterator->previous;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
kprint("\n");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// iterate through a list printing out the values of each node
|
||
|
|
void print_list( node *head, bool ft_descending_ascending)
|
||
|
|
{
|
||
|
|
if( head == NULL) {
|
||
|
|
kprint( "EMPTY.");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
node *iterator = NULL;
|
||
|
|
if( ft_descending_ascending) {
|
||
|
|
iterator = head;
|
||
|
|
while( iterator != NULL) {
|
||
|
|
print_node( iterator);
|
||
|
|
iterator = iterator->next;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
iterator = get_tail( head);
|
||
|
|
while( iterator != NULL) {
|
||
|
|
print_node( iterator);
|
||
|
|
iterator = iterator->previous;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|