Import backup from 2004-06-01

kernel/lang/LinkedList.cpp

@@ -1,3 +0,0 @@
-
-#include "LinkedList.h"
-

kernel/lang/LinkedList.h

@@ -106,7 +106,7 @@ LinkedList<T>::LinkedList()
 template <typename Element>
 LinkedList<Element> & LinkedList<Element>::insert(int index, Element e)
 {
-	if (index == count-1)
+	if (index == count)
 		push_back(e);
 	else if (index >= 0 && index < count)
 	{

kernel/lang/cstring.cpp

@@ -0,0 +1,91 @@
+// cstring.c
+// Author: Josh Holtrop
+// Created: 02/26/04
+// Modified: 06/01/04
+// Implements c string functions
+
+#include "string.h"
+#include "asmfuncs.h"
+
+char *strcat(char *dest, const char *src)
+{
+	strcpy(dest+strlen(dest), src);
+	return dest;
+}
+
+
+//Splits a string into multiple strings by turning all characters
+// equal to delim into null values (string termination character)
+//Returns the number of strings after the split, 1 if no delim chars
+int	string_split(char *str, char delim)
+{
+	if (strlen(str) < 1)
+		return 0;	//empty string
+	int count = 1;
+	for (; *str; str++)
+	{
+		if (*str == delim)
+		{
+			count++;
+			*str = 0;
+		}
+	}
+	return count;
+}
+
+
+//Advances a char pointer to the byte after the current string's
+// null-terminating character
+//Useful after calling string_split()
+//Returns a pointer to the following string
+char	*string_advance(char *str)
+{
+	for (; *str; str++);
+	return str+1;
+}
+
+
+void	rtrim(char *str)
+{
+	str += strlen(str);	//now points to the null character at the end of the string
+	str--;
+	for (;;)
+	{
+		if ((*str == ' ') || (*str == '\t') || (*str == '\n'))
+			*str-- = 0;
+		else
+			break;
+	}
+}
+
+
+char	*ucase(char *str)
+{
+	char *ret = str;
+	for (;;)
+	{
+		if (*str == 0)
+			break;
+		if ((*str >= 'a') && (*str <= 'z'))
+			*str = (*str) - 32;
+		str++;
+	}
+	return ret;
+}
+
+
+char	*lcase(char *str)
+{
+	char *ret = str;
+	for (;;)
+	{
+		if (*str == 0)
+			break;
+		if ((*str >= 'A') && (*str <= 'Z'))
+			*str = (*str) + 32;
+		str++;
+	}
+	return ret;
+}
+
+

kernel/lang/cstring.h

@@ -0,0 +1,19 @@
+// cstring.h
+// Author: Josh Holtrop
+// Created: 02/26/04
+// Modified: 06/01/04
+// Implements c string functions
+
+#ifndef __HOS_CSTRING__
+#define __HOS_CSTRING__ __HOS_CSTRING__
+
+char	*strcat(char *dest, const char *src);
+int	string_split(char *str, char delim);
+char	*string_advance(char *str);
+void	rtrim(char *str);
+char	*ucase(char *str);
+char	*lcase(char *str);
+
+#endif
+
+

kernel/lang/string.cpp

@@ -1,90 +1,196 @@
-// string.c
+
+// string.cpp
+// implements c++ string object
 // Author: Josh Holtrop
-// Created: 02/26/04
-// Implements string functions
+// Date: 06/01/04
+// Modified: 06/01/04
 
 #include "string.h"
 #include "asmfuncs.h"
+#include "cstring.h"
 
-char *strcat(char *dest, char *src)
+string::string()
 {
-	strcpy(dest+strlen(dest), src);
-	return dest;
+	myLength = 0;
+	myChars = new char;
+	*myChars = 0;
 }
 
-
-//Splits a string into multiple strings by turning all characters
-// equal to delim into null values (string termination character)
-//Returns the number of strings after the split, 1 if no delim chars
-int	string_split(char *str, char delim)
+string::~string()
 {
-	if (strlen(str) < 1)
-		return 0;	//empty string
-	int count = 1;
-	for (; *str; str++)
+	delete[] myChars;
+}
+
+string::string(const string & orig)
+{
+	myLength = orig.myLength;
+	myChars = new char[myLength + 1];
+	memcpy(myChars, orig.myChars, myLength + 1);
+}
+
+string::string(const char *cstring)
+{
+	myLength = strlen(cstring);
+	myChars = new char[myLength + 1];
+	memcpy(myChars, cstring, myLength + 1);
+}
+
+string & string::operator=(const string & orig)
+{
+	if (this != &orig)
 	{
-		if (*str == delim)
-		{
-			count++;
-			*str = 0;
-		}
+		delete[] myChars;
+		myLength = orig.myLength;
+		myChars = new char[myLength + 1];
+		memcpy(myChars, orig.myChars, myLength + 1);
 	}
-	return count;
+	return *this;
 }
 
-
-//Advances a char pointer to the byte after the current string's
-// null-terminating character
-//Useful after calling string_split()
-//Returns a pointer to the following string
-char	*string_advance(char *str)
+string & string::operator=(const char *cstring)
 {
-	for (; *str; str++);
-	return str+1;
-}
-
-
-void	rtrim(char *str)
-{
-	str += strlen(str);	//now points to the null character at the end of the string
-	str--;
-	for (;;)
+	if (myChars != cstring)
 	{
-		if ((*str == ' ') || (*str == '\t') || (*str == '\n'))
-			*str-- = 0;
-		else
-			break;
+		delete[] myChars;
+		myLength = strlen(cstring);
+		myChars = new char[myLength + 1];
+		memcpy(myChars, cstring, myLength + 1);
 	}
+	return *this;
 }
 
+char * string::data() const { return myChars; }
 
-char	*ucase(char *str)
+int string::size() const { return myLength; }
+
+bool string::operator==(const string & second) const
 {
-	char *ret = str;
-	for (;;)
+	if (myLength != second.myLength)
+		return false;
+	for (unsigned int i = 0; i < myLength; i++)
 	{
-		if (*str == 0)
-			break;
-		if ((*str >= 'a') && (*str <= 'z'))
-			*str = (*str) - 32;
-		str++;
+		if (myChars[i] != second.myChars[i])
+			return false;
 	}
-	return ret;
+	return true;
 }
 
-
-char	*lcase(char *str)
+bool string::operator==(const char *cstring) const
 {
-	char *ret = str;
-	for (;;)
+	if (myLength != strlen(cstring))
+		return false;
+	for (unsigned int i = 0; i < myLength; i++)
 	{
-		if (*str == 0)
-			break;
-		if ((*str >= 'A') && (*str <= 'Z'))
-			*str = (*str) + 32;
-		str++;
+		if (myChars[i] != cstring[i])
+			return false;
 	}
-	return ret;
+	return true;
+}
+
+string & string::operator+=(const string & str)
+{
+	char *newStr = new char[myLength + str.myLength + 1];
+	memcpy(newStr, myChars, myLength);
+	memcpy(newStr + myLength, str.myChars, str.myLength + 1);
+	delete[] myChars;
+	myChars = newStr;
+	return *this;
+}
+
+string & string::operator+=(const char *cstring)
+{
+	char *newStr = new char[myLength + strlen(cstring) + 1];
+	memcpy(newStr, myChars, myLength);
+	memcpy(newStr + myLength, cstring, strlen(cstring) + 1);
+	delete[] myChars;
+	myChars = newStr;
+	return *this;
+}
+
+string & string::operator-=(const string & str)
+{
+	char *newStr = new char[myLength + str.myLength + 1];
+	memcpy(newStr, str.myChars, str.myLength);
+	memcpy(newStr + str.myLength, myChars, myLength + 1);
+	delete[] myChars;
+	myChars = newStr;
+	return *this;
+}
+
+string & string::operator-=(const char *cstring)
+{
+	char *newStr = new char[myLength + strlen(cstring) + 1];
+	memcpy(newStr, cstring, strlen(cstring));
+	memcpy(newStr + strlen(cstring), myChars, myLength + 1);
+	delete[] myChars;
+	myChars = newStr;
+	return *this;
+}
+
+string & string::operator+=(char chr)
+{
+	myLength++;
+	char *newStr = new char[myLength + 1];
+	memcpy(newStr, myChars, myLength);
+	newStr[myLength - 1] = chr;
+	newStr[myLength] = 0;
+	delete[] myChars;
+	myChars = newStr;
+	return *this;
+}
+
+string & string::operator-=(char chr)
+{
+	myLength++;
+	char *newStr = new char[myLength + 1];
+	memcpy(newStr + 1, myChars, myLength);
+	*newStr = chr;
+	delete[] myChars;
+	myChars = newStr;
+	return *this;
+}
+
+
+
+string::string(const string & str1, const string & str2)
+{
+	myLength = str1.myLength + str2.myLength;
+	myChars = new char[myLength + 1];
+	memcpy(myChars, str1.myChars, str1.myLength);
+	memcpy(myChars + myLength, str2.myChars, str2.myLength + 1);
+}
+
+string::string(const string & str1, const char *cstring)
+{
+	myLength = str1.myLength + strlen(cstring);
+	myChars = new char[myLength + 1];
+	memcpy(myChars, str1.myChars, str1.myLength);
+	memcpy(myChars + myLength, cstring, strlen(cstring) + 1);
+}
+
+string::string(const char *cstring, const string & str)
+{
+	myLength = str.myLength + strlen(cstring);
+	myChars = new char[myLength + 1];
+	memcpy(myChars, cstring, strlen(cstring));
+	memcpy(myChars + myLength, str.myChars, str.myLength + 1);
+}
+
+string::string(const string & str1, char chr)
+{
+	myLength = str1.myLength + 1;
+	myChars = new char[myLength + 1];
+	memcpy(myChars, str1.myChars, myLength);
+	myChars[myLength - 1] = chr;
+	myChars[myLength] = 0;
+}
+
+string::string(char chr, const string & str1)
+{
+	myLength = str1.myLength + 1;
+	myChars = new char[myLength + 1];
+	memcpy(myChars  + 1, str1.myChars, myLength + 1);
+	*myChars = chr;
 }
 
 

kernel/lang/string.h

@@ -1,18 +1,83 @@
-// strings.h
+
+// string.h
+// implements c++ string object
 // Author: Josh Holtrop
-// Created: 02/26/04
-// Implements string functions
+// Date: 06/01/04
+// Modified: 06/01/04
+
 
 #ifndef __HOS_STRING__
 #define __HOS_STRING__ __HOS_STRING__
 
-char	*strcat(char *dest, char *src);
-int	string_split(char *str, char delim);
-char	*string_advance(char *str);
-void	rtrim(char *str);
-char	*ucase(char *str);
-char	*lcase(char *str);
+
+class string
+{
+private:
+	char * myChars;
+	unsigned int myLength;
+public:
+	string();
+	~string();
+	string(const string & orig);
+	string(const char *cstring);
+	
+	string & operator=(const string & orig);
+	string & operator=(const char *cstring);
+	bool operator==(const string & second) const;
+	bool operator==(const char *cstring) const;
+	
+	string(const string & str1, const string & str2);
+	string(const string & str1, const char *cstring);
+	string(const char *cstring, const string & str);
+	string(const string & str1, char chr);
+	string(char chr, const string & str1);
+	
+	string & operator+=(const string & str);
+	string & operator+=(const char *cstring);
+	string & operator-=(const string & str);
+	string & operator-=(const char *cstring);
+	string & operator+=(char chr);
+	string & operator-=(char chr);
+	
+	char * data() const;
+	int size() const;
+};
+
+static inline bool operator==(char *cstring, const string & str)
+{ return str == cstring; }
+
+static inline string & operator+=(const char *cstring, string & str)
+{ return str -= cstring; }
+
+static inline string & operator-=(const char *cstring, string & str)
+{ return str += cstring; }
+
+static inline string & operator+=(char chr, string & str)
+{ return str -= chr; }
+
+static inline string & operator-=(char chr, string & str)
+{ return str += chr; }
+
+
+
+static inline string operator+(const string & str1, const string & str2)
+{ return string(str1, str2); }
+
+static inline string operator+(const string & str1, const char *cstring)
+{ return string(str1, cstring); }
+
+static inline string operator-(const string & str1, const string & str2)
+{ return string(str2, str1); }
+
+static inline string operator-(const string & str1, const char *cstring)
+{ return string(cstring, str1); }
+
+static inline string operator+(const string & str1, char chr)
+{ return string(str1, chr); }
+
+static inline string operator-(const string & str1, char chr)
+{ return string(chr, str1); }
+
 
 #endif
 
-