[GOOD] BUILD 0.1.0.450 DATE 8/29/2011 AT 10:30 AM

====================================================
+ Changed 'align 0x4' line above multiboot header in loader.asm to
'align 4'
+ Removed -e option for echo in build.sh
+ Modified build.sh for linux
+ Fixed triple fault when enabling paging
+ Fixed page faults at memory manager initialization
+ Fixed 'mem' console function
+ Added more info about page fault at crash screen
+ Added Panic() macro
+ Added verbose mode for memory manager

[ BAD] BUILD 0.1.0.390 DATE 8/27/2011 AT 10:54 PM
====================================================
+ Added stdlib routines, separated in different files
+ Rewritten physical memory manager
+ Added virtual mem manager
+ Added memory allocation/freeing
+ Added memory library
+ Added temporary allocation (at end of kernel), until paging is started
- Removed functionality from debug console function 'mem'
- Removed system.h, the one remaining function now in stdio.h

Kernel/library/stdlib/convert_ops.c

@@ -0,0 +1,100 @@
+/*
+ * convert_ops.c
+ *
+ *  Created on: Aug 27, 2011
+ *      Author: Tiberiu
+ */
+#include <stdlib.h>
+
+const string _Numbers = "0123456789abcdefghijklmnopqrstuvwxyz";
+
+int32 ConvertIntToString (string buffer, int32 number, int32 base)
+{
+	if (base > 36 || base < 2) return 0;
+
+	int32 len = numlen (number, base), beg = 0, i;
+	uint32 n = (uint32) number;
+
+	// If number is negative and in base 10, we put a '-' in front
+	if (number < 0 && base == 10) buffer[beg++] = '-';
+
+	// Put every digit in string
+	for (i = len-1; i>=beg; i--)
+	{
+		buffer[i] = _Numbers[n % base];
+		n /= base;
+	}
+
+	buffer[len] = 0;
+	return number;
+}
+
+uint32 ConvertUIntToString (string buffer, uint32 number, int32 base)
+{
+	if (base > 36 || base < 2) return 0;
+
+	int32 len = unumlen (number, base), i;
+
+	// Put every digit in string
+	for (i = len-1; i >= 0; i--)
+	{
+		buffer[i] = _Numbers[number % base];
+		number /= base;
+	}
+
+	buffer[len] = 0;
+	return number;
+}
+
+int32 ConvertStringToInt (string buffer)
+{
+	int8 negative = (buffer[0] == '-');
+	int32 pos = (buffer[0] == '-' );
+
+	int32 number = 0;
+
+	while (IsDigit(buffer[pos]))
+	{
+		number = number*10 + (buffer[pos] - '0');
+		pos++;
+	}
+
+	if (negative) return -number;
+	return number;
+}
+
+uint32 ConvertStringToUInt (string buffer)
+{
+	int32 pos = 0;
+	int32 number = 0;
+
+	while (IsDigit(buffer[pos]))
+	{
+		number = number*10 + (buffer[pos] - '0');
+		pos++;
+	}
+
+	return number;
+}
+
+uint32 ConvertStringToIntHex (string buffer)
+{
+	int32 pos = 0;
+	uint32 number = 0;
+
+	// Skip first 2 digits if it is in format 0xXXXX...
+	if (buffer[1] == 'x' || buffer[1] == 'X') pos = 2;
+
+	while (IsHexDigit(buffer[pos]))
+	{
+		number = number*0x10;
+
+		if (IsDigit(buffer[pos])) number += buffer[pos] - '0';
+		else if (buffer[pos] >= 'a' && buffer[pos] <= 'f') number += 10 + buffer[pos] - 'a';
+		else if (buffer[pos] >= 'A' && buffer[pos] <= 'F') number += 10 + buffer[pos] - 'A';
+
+		pos++;
+	}
+
+	return number;
+}

Kernel/library/stdlib/mem_ops.c

@@ -0,0 +1,42 @@
+/*
+ * mem_ops.c
+ *
+ *  Created on: Aug 27, 2011
+ *      Author: Tiberiu
+ */
+#include <types.h>
+
+void *memcpy(void *dest, const void *src, uint32 count)
+{
+	uint8* d = (uint8*) dest;
+	const uint8* s = (const uint8*) src;
+
+	while (count-- != 0)
+		*d++ = *s++;
+
+	return dest;
+}
+
+int32 memcmp(const void *s1, const void *s2, uint32 count)
+{
+	const uint8 *us1 = (const uint8*) s1;
+	const uint8 *us2 = (const uint8*) s2;
+
+	while (count-- != 0)
+	{
+		if (*us1 != *us2) return (*us1 < *us2) ? -1 : 1;
+		us1++; us2++;
+	}
+
+	return 0;
+}
+
+
+void *memset(void *dest, uint8 val, uint32 count)
+{
+	uint8 *temp = (uint8 *)dest;
+	while (count-- != 0)
+		*temp++ = val;
+
+	return dest;
+}

Kernel/library/stdlib/num_ops.c

@@ -0,0 +1,39 @@
+/*
+ * num_ops.c
+ *
+ *  Created on: Aug 27, 2011
+ *      Author: Tiberiu
+ */
+#include <types.h>
+
+uint32 numlen (int32 number, int32 base)
+{
+	// Sanity check
+	if (base < 2) return 0;
+
+	uint32 len = (number < 0 && base == 10);	// add minus sign
+	if (number == 0) return 1;
+
+	while (number) 	{
+		number /= base;
+		++len;
+	}
+
+	return len;
+}
+
+uint32 unumlen (uint32 number, int32 base)
+{
+	// Sanity check
+	if (base < 2) return 0;
+
+	uint32 len = 0;
+	if (number == 0) return 1;
+
+	while (number) 	{
+		number /= base;
+		++len;
+	}
+
+	return len;
+}

Kernel/library/stdlib/ord_arr.c

@@ -0,0 +1,112 @@
+/*
+ * ord-arr.c
+ *
+ *  Created on: Aug 25, 2011
+ *      Author: Tiberiu
+ */
+
+
+/*
+ * memory.c
+ *
+ *  Created on: Aug 24, 2011
+ *      Author: Tiberiu
+ */
+
+#include <stdlib.h>
+#include <memory.h>
+
+int StandardComparePredicate (uint32 a, uint32 b)
+{
+	if (a > b) return 1;
+	else if (a == b) return 0;
+	return -1;
+}
+
+OrderedArray OrderedArrayCreate (uint32 maxSize, ComparePredicate p)
+{
+	OrderedArray ret;
+	ret.Data = (unsigned*) kmalloc(maxSize);
+	memset(ret.Data, 0, maxSize);
+	ret.Size = 0;
+	ret.SizeLimit = maxSize;
+	ret.Compare = (p == 0) ? StandardComparePredicate : p;
+
+	return ret;
+}
+
+OrderedArray OrderedArrayPlace (uint32 addr, uint32 maxSize, ComparePredicate p)
+{
+	OrderedArray ret;
+	ret.Data = (unsigned*)addr;
+	memset(ret.Data, 0, maxSize);
+	ret.Size = 0;
+	ret.SizeLimit = maxSize;
+	ret.Compare = (p == 0) ? StandardComparePredicate : p;
+
+	return ret;
+}
+
+void OrderedArrayDispose (OrderedArray* arr)
+{
+	kfree(arr->Data);
+}
+
+uint32 OrderedArrayBinarySearch (uint32 key, uint32* array, uint32 length, ComparePredicate predicate)
+{
+	if (!predicate) return 0;
+
+	uint32 left = 0, right = length, mid;
+
+	while (left < right)
+	{
+		mid = left + (right-left) / 2;
+
+		int r = (*predicate)(key, array[mid]);
+
+		if (r > 0) left = mid + 1;
+		else if (r < 0) right = mid;
+		else return mid;
+	}
+	mid = left + (right-left) / 2;
+
+	return mid;
+}
+
+uint32 OrderedArraySearch (uint32 key, OrderedArray* arr, ComparePredicate predicate)
+{
+	uint32 r = OrderedArrayBinarySearch(key,arr->Data,arr->Size,predicate);
+
+	if (arr->Data[r] != key) return 0xffffffff;
+	return r;
+}
+
+void OrderedArrayInsert (uint32 item, OrderedArray* arr)
+{
+	if (arr->Size >= arr->SizeLimit) return;
+
+	uint32 location = OrderedArrayBinarySearch(item, arr->Data, arr->Size, arr->Compare);
+
+	uint32 i;
+	for (i = arr->Size; i > location && arr->Size > 0; i--)
+		arr->Data[i] = arr->Data[i-1];
+
+	arr->Data[location] = item;
+	arr->Size++;
+}
+
+uint32 OrderedArrayLookup (uint32 index, OrderedArray* arr)
+{
+	if (index >= arr->Size) return 0;
+	return arr->Data[index];
+}
+
+void OrderedArrayDeleteIndex (uint32 index, OrderedArray* arr)
+{
+	if (index >= arr->Size) return;
+
+	uint32 i;
+	for (i = index + 1; i < arr->Size; i++)
+		arr->Data[i - 1] = arr->Data[i];
+	arr->Size--;
+}

Kernel/library/stdlib/str_ops.c

@@ -0,0 +1,39 @@
+/*
+ * str_ops.c
+ *
+ *  Created on: Aug 27, 2011
+ *      Author: Tiberiu
+ */
+#include <types.h>
+
+uint32 strlen (string s)
+{
+	string end = s;
+	while (*end != '\0')
+		end++;
+
+	return (uint32)(end - s);
+}
+
+int32 strcmp (string a, string b)
+{
+	unsigned char c1, c2;
+
+	while (*a != '\0' && *b != '\0' && *a == *b) {
+		a++; b++;
+	}
+
+	c1 = (*(unsigned char*) a);
+	c2 = (*(unsigned char*) b);
+	return ((c1 < c2) ? -1 : (c1 > c2));
+}
+
+string strcpy (string s1, const string s2)
+{
+	char *dst = s1;
+	const char *src = s2;
+
+	while ((*dst++ = *src++) != '\0') ;
+
+	return s1;
+}