Aex.Uni Presents the Core Library

Author

Message

Aaron Miller

18

Years of Service

User Offline

Joined: 25th Feb 2006

Playing: osu!

Posted: 4th Feb 2008 00:53

Link

Aex.Uni's Core Library
This library consists of an (open-source) SDK featuring ANSI and Unicode string support, and a garbage collector. Coming soon, a linked list manager, and an array sorter.

Here are the contents of it currently, place these files wherever, preferably: C:\Aex.Uni\Core\Include.

core_base.h

+ Code Snippet

#ifndef _CORE_BASE_H_
#define _CORE_BASE_H_

// Windows
#if (!defined(CORE_NO_WINDOWS))
#include <windows.h>
#endif

// Standard Library
#if (!defined(CORE_NO_STANDARDLIB))
#include <stdio.h>
#include <stdlib.h>
#endif

// Undefines
#ifdef CORE_VERSION
#undef CORE_VERSION
#endif
#ifdef MAX_STRING
#undef MAX_STRING
#endif
#ifdef SAFE_FREE_PTR
#undef SAFE_FREE_PTR
#endif
#ifdef SAFE_RELEASE_PTR
#undef SAFE_RELEASE_PTR
#endif

// Defines
#define CORE_VERSION		0x02030801	// February 3rd 2008 - Build 1
#define MAX_STRING		256
#define SAFE_FREE_PTR(p)	if (p != NULL) { free((void*)p); p = NULL; }
#define SAFE_RELEASE_PTR(p)	if (p != NULL) { p->Release(); p = NULL; }

#endif

core_string.h

#ifndef _CORE_STRING_H_
#define _CORE_STRING_H_

// Main include
#include "core_base.h"

// Type-Defines
#if (defined(_UNICODE) || defined(UNICODE))
typedef wchar_t			_char;
#else
typedef char			_char;
#endif

// String Structure
struct string
{
	long				id;
	long				m_Length;
	_char*				m_str;
	inline string();
	inline string(_char* str);
	inline string(const string& str);
	inline ~string();
	inline long length(void);
	inline _char* c_str();
	inline const string& operator=(_char* str);
	inline const string& operator=(const string& str);
	inline _char* operator+(const _char* str);
	inline _char* operator+(const string& str);
};

inline string::string()
{
	m_Length = 0;
	m_str = NULL;
}

inline string::string(_char* str)
{
	long strlength = 0;
	while(str[strlength] != 0) { strlength++; }
	m_Length = strlength;
	if (m_Length > 0)
	{
		m_str = (_char*)malloc(sizeof(_char) * (strlength+1));
		for(long i = 0; i < strlength; i++)
		{
			m_str[i] = str[i];
		}
		m_str[i] = 0;
	}
	else
	{
		m_str = "\0";
	}
}

inline string::string(const string& str)
{
	long strlength = 0;
	while(str.m_str[strlength] != 0) { strlength++; }
	m_Length = strlength;
	if (m_Length > 0)
	{
		m_str = (_char*)malloc(sizeof(_char) * (strlength+1));
		for(long i = 0; i < strlength; i++)
		{
			m_str[i] = str.m_str[i];
		}
		m_str[i] = 0;
	}
	else
	{
		m_str = "\0";
	}
}

inline string::~string()
{
	if (m_str != NULL)
	{
		free((void*)m_str);
		m_str = NULL;
	}
	m_Length = 0;
}

inline long string::length(void)
{
	return m_Length;
}

inline _char* string::c_str(void)
{
	return m_str;
}

inline const string& string::operator=(_char* str)
{
	if (m_str != NULL)
	{
		free((void*)m_str);
	}
	if (str != NULL)
	{
		// Data
		long strlength = 0;
		long size = 0;
		long i = 0;
		// Retrieve the string's length
		while(str[strlength] != 0) { strlength++; }
		m_Length = strlength;
		if (m_Length > 0)
		{
			// Get how big the string is (in bytes + 1 null character byte's size)
			size = sizeof(_char) * (strlength + 1);
			// Allocate the memory for the string
			m_str = (_char*)malloc(size);
			// Copy over the data of the other string into this string, up until the NULL byte, then set the null byte.
			while(str[i] != 0) { m_str[i] = str[i]; i++; } m_str[i] = 0;
		}
		else
		{
			m_str = "\0";
		}
	}
	else
	{
		m_str = "\0";
	}
	return *this;
}

inline const string& string::operator=(const string& str)
{
	if (m_str != NULL)
	{
		free((void*)m_str);
	}
	_char* _str = str.m_str;
	if (_str != NULL)
	{
		// Data
		long strlength = 0;
		long size = 0;
		long i = 0;
		// Retrieve the _string's length
		while(_str[strlength] != 0) { strlength++; }
		m_Length = strlength;
		if (m_Length > 0)
		{
			// Get how big the _string is (in bytes + 1 null character byte's size)
			size = sizeof(_char) * (strlength + 1);
			// Allocate the memory for the _string
			m_str = (_char*)malloc(size);
			// Copy over the data of the other _string into this _string, up until the NULL byte, then set the null byte.
			while(_str[i] != 0) { m_str[i] = _str[i]; i++; } m_str[i] = 0;
		}
		else
		{
			m_str = "\0";
		}
	}
	else
	{
		m_str = "\0";
	}
	return *this;
}

inline _char* string::operator+(const _char* str)
{
	if (str != NULL)
	{
		// Data
		long strlength = 0, cstrlength = 0;
		long size = 0, size0 = 0, size1 = 0;
		long i = 0;
		// Retrieve str's length
		while(str[strlength] != 0) { strlength++; }
		// Get the combined length
		cstrlength = strlength + m_Length;
		// Get how big this string is (Not counting the null byte)
		size0 = sizeof(_char) * m_Length;
		// Get how big the other string is (Not counting the null byte)
		size1 = sizeof(_char) * strlength;
		// Get how big the combined size is (Plus null character)
		size = size0 + size1 + sizeof(_char);
		// Create a buffer big enough for the entire string
		_char* tmp = (_char*)malloc(size);
		// Copy the contents of m_str to tmp
		for(i = 0; i < m_Length; i++) { tmp[i] = m_str[i]; }
		// Copy the contents of str to tmp
		for(i = m_Length; i < cstrlength; i++) { tmp[i] = str[i]; }
		// Set the last piece to null
		tmp[cstrlength] = 0;
		// Free the string
		if (m_str != NULL)
		{
			free((void*)m_str);
		}
		// Set m_Length to clength, and m_str to tmp
		m_Length = cstrlength;
		m_str = tmp;
	}
	return m_str;
}

inline _char* string::operator+(const string& str)
{
	_char* _str = str.m_str;
	if (_str != NULL)
	{
		// Data
		long strlength = 0, cstrlength = 0;
		long size = 0, size0 = 0, size1 = 0;
		long i = 0;
		// Retrieve _str's length
		while(_str[strlength] != 0) { strlength++; }
		// Get the combined length
		cstrlength = strlength + m_Length;
		// Get how big this _string is (Not counting the null byte)
		size0 = sizeof(_char) * m_Length;
		// Get how big the other _string is (Not counting the null byte)
		size1 = sizeof(_char) * strlength;
		// Get how big the combined size is (Plus null character)
		size = size0 + size1 + sizeof(_char);
		// Create a buffer big enough for the entire _string
		_char* tmp = (_char*)malloc(size);
		// Copy the contents of m_str to tmp
		for(i = 0; i < m_Length; i++) { tmp[i] = m_str[i]; }
		// Copy the contents of _str to tmp
		long n = 0;
		for(i = m_Length; i < cstrlength; i++) { tmp[i] = _str[n]; n++; }
		// Set the last piece to null
		tmp[cstrlength] = 0;
		// Free the _string
		if (m_str != NULL)
		{
			free((void*)m_str);
		}
		// Set m_Length to cstrlength, and m_str to tmp
		m_Length = cstrlength;
		m_str = tmp;
	}
	return m_str;
}

#endif

+ Code Snippet

#ifndef _CORE_STRING_H_
#define _CORE_STRING_H_

// Main include
#include "core_base.h"

// Type-Defines
#if (defined(_UNICODE) || defined(UNICODE))
typedef wchar_t			_char;
#else
typedef char			_char;
#endif

// String Structure
struct string
{
	long				id;
	long				m_Length;
	_char*				m_str;
	inline string();
	inline string(_char* str);
	inline string(const string& str);
	inline ~string();
	inline long length(void);
	inline _char* c_str();
	inline const string& operator=(_char* str);
	inline const string& operator=(const string& str);
	inline _char* operator+(const _char* str);
	inline _char* operator+(const string& str);
};

inline string::string()
{
	m_Length = 0;
	m_str = NULL;
}

inline string::string(_char* str)
{
	long strlength = 0;
	while(str[strlength] != 0) { strlength++; }
	m_Length = strlength;
	if (m_Length > 0)
	{
		m_str = (_char*)malloc(sizeof(_char) * (strlength+1));
		for(long i = 0; i < strlength; i++)
		{
			m_str[i] = str[i];
		}
		m_str[i] = 0;
	}
	else
	{
		m_str = "\0";
	}
}

inline string::string(const string& str)
{
	long strlength = 0;
	while(str.m_str[strlength] != 0) { strlength++; }
	m_Length = strlength;
	if (m_Length > 0)
	{
		m_str = (_char*)malloc(sizeof(_char) * (strlength+1));
		for(long i = 0; i < strlength; i++)
		{
			m_str[i] = str.m_str[i];
		}
		m_str[i] = 0;
	}
	else
	{
		m_str = "\0";
	}
}

inline string::~string()
{
	if (m_str != NULL)
	{
		free((void*)m_str);
		m_str = NULL;
	}
	m_Length = 0;
}

inline long string::length(void)
{
	return m_Length;
}

inline _char* string::c_str(void)
{
	return m_str;
}

inline const string& string::operator=(_char* str)
{
	if (m_str != NULL)
	{
		free((void*)m_str);
	}
	if (str != NULL)
	{
		// Data
		long strlength = 0;
		long size = 0;
		long i = 0;
		// Retrieve the string's length
		while(str[strlength] != 0) { strlength++; }
		m_Length = strlength;
		if (m_Length > 0)
		{
			// Get how big the string is (in bytes + 1 null character byte's size)
			size = sizeof(_char) * (strlength + 1);
			// Allocate the memory for the string
			m_str = (_char*)malloc(size);
			// Copy over the data of the other string into this string, up until the NULL byte, then set the null byte.
			while(str[i] != 0) { m_str[i] = str[i]; i++; } m_str[i] = 0;
		}
		else
		{
			m_str = "\0";
		}
	}
	else
	{
		m_str = "\0";
	}
	return *this;
}

inline const string& string::operator=(const string& str)
{
	if (m_str != NULL)
	{
		free((void*)m_str);
	}
	_char* _str = str.m_str;
	if (_str != NULL)
	{
		// Data
		long strlength = 0;
		long size = 0;
		long i = 0;
		// Retrieve the _string's length
		while(_str[strlength] != 0) { strlength++; }
		m_Length = strlength;
		if (m_Length > 0)
		{
			// Get how big the _string is (in bytes + 1 null character byte's size)
			size = sizeof(_char) * (strlength + 1);
			// Allocate the memory for the _string
			m_str = (_char*)malloc(size);
			// Copy over the data of the other _string into this _string, up until the NULL byte, then set the null byte.
			while(_str[i] != 0) { m_str[i] = _str[i]; i++; } m_str[i] = 0;
		}
		else
		{
			m_str = "\0";
		}
	}
	else
	{
		m_str = "\0";
	}
	return *this;
}

inline _char* string::operator+(const _char* str)
{
	if (str != NULL)
	{
		// Data
		long strlength = 0, cstrlength = 0;
		long size = 0, size0 = 0, size1 = 0;
		long i = 0;
		// Retrieve str's length
		while(str[strlength] != 0) { strlength++; }
		// Get the combined length
		cstrlength = strlength + m_Length;
		// Get how big this string is (Not counting the null byte)
		size0 = sizeof(_char) * m_Length;
		// Get how big the other string is (Not counting the null byte)
		size1 = sizeof(_char) * strlength;
		// Get how big the combined size is (Plus null character)
		size = size0 + size1 + sizeof(_char);
		// Create a buffer big enough for the entire string
		_char* tmp = (_char*)malloc(size);
		// Copy the contents of m_str to tmp
		for(i = 0; i < m_Length; i++) { tmp[i] = m_str[i]; }
		// Copy the contents of str to tmp
		for(i = m_Length; i < cstrlength; i++) { tmp[i] = str[i]; }
		// Set the last piece to null
		tmp[cstrlength] = 0;
		// Free the string
		if (m_str != NULL)
		{
			free((void*)m_str);
		}
		// Set m_Length to clength, and m_str to tmp
		m_Length = cstrlength;
		m_str = tmp;
	}
	return m_str;
}

inline _char* string::operator+(const string& str)
{
	_char* _str = str.m_str;
	if (_str != NULL)
	{
		// Data
		long strlength = 0, cstrlength = 0;
		long size = 0, size0 = 0, size1 = 0;
		long i = 0;
		// Retrieve _str's length
		while(_str[strlength] != 0) { strlength++; }
		// Get the combined length
		cstrlength = strlength + m_Length;
		// Get how big this _string is (Not counting the null byte)
		size0 = sizeof(_char) * m_Length;
		// Get how big the other _string is (Not counting the null byte)
		size1 = sizeof(_char) * strlength;
		// Get how big the combined size is (Plus null character)
		size = size0 + size1 + sizeof(_char);
		// Create a buffer big enough for the entire _string
		_char* tmp = (_char*)malloc(size);
		// Copy the contents of m_str to tmp
		for(i = 0; i < m_Length; i++) { tmp[i] = m_str[i]; }
		// Copy the contents of _str to tmp
		long n = 0;
		for(i = m_Length; i < cstrlength; i++) { tmp[i] = _str[n]; n++; }
		// Set the last piece to null
		tmp[cstrlength] = 0;
		// Free the _string
		if (m_str != NULL)
		{
			free((void*)m_str);
		}
		// Set m_Length to cstrlength, and m_str to tmp
		m_Length = cstrlength;
		m_str = tmp;
	}
	return m_str;
}

#endif

core_gc.h

#ifndef _CORE_GARBAGECOLLECTOR_H_
#define _CORE_GARBAGECOLLECTOR_H_

// Main include
#include "core_base.h"

// -- Garbage Collector ~ Start ~ --
struct garbageCollector
{
	void**				Garbage;
	unsigned long		Size;
	unsigned long		Current;
	inline garbageCollector();
	inline ~garbageCollector();
	inline void Release(void);
	inline void Add(void* pp);
	inline void Remove(void* pp);
};

// Release all the memory in the garbage collector
inline void garbageCollector::Release(void)
{
	unsigned long i;
	for(i=0; i<Size; i++)
	{
		if (Garbage[i] != NULL)
		{
			HeapFree(GetProcessHeap(), 0, Garbage[i]);
			Garbage[i] = NULL;
		}
	}
}

// Garbage collector constructor
inline garbageCollector::garbageCollector()
{
	Garbage = (void**)HeapAlloc(GetProcessHeap(), 0, 4);
	Current = 0;
	Size = 0;
}

// Garbage collector destructor
inline garbageCollector::~garbageCollector()
{
	unsigned long i;
	for(i=0; i<Size; i++)
	{
		if (Garbage[i] != NULL)
		{
			HeapFree(GetProcessHeap(), 0, Garbage[i]);
			Garbage[i] = NULL;
		}
	}
}

// Add a pointer to the garbage collector
inline void garbageCollector::Add(void* pp)
{
	Garbage = (void**)HeapReAlloc(GetProcessHeap(), 0, (void*)Garbage, (Size + 1) * 4);
	Garbage[Current] = pp;
	Current++;
	Size++;
}

// Remove a pointer from the garbage collector
inline void garbageCollector::Remove(void* pp)
{
	int i = 0;
	int fReady = 0;
	int fResult = 0;
	while (fReady == 0)
	{
		if (Garbage[i] == pp)
		{
			HeapFree(GetProcessHeap(), 0, pp);
			Garbage[i] = NULL;
			fReady = 1;
			fResult = 1;
		}
		if (i < (int)Size)
		{
			i++;
		}
		else
		{
			fReady = 1;
		}
	}
}

inline void* AllocMemGC(garbageCollector* gc, unsigned long int numBytes)
{
	void* tmp = HeapAlloc(GetProcessHeap(),0,numBytes);
	if (tmp != NULL)
	{
		memset(tmp, 0, numBytes);
		gc->Add(tmp);
		return tmp;
	}
	return NULL;
}
inline void FreeMemGC(garbageCollector* gc, void* pPtr)
{
	if (pPtr != NULL)
	{
		gc->Remove(pPtr);
	}
}

// -- Garbage Collector ~ End ~ --

// -- Garbage Collector (COM) ~ Start ~ --
struct garbageCollectorCOM
{
	void**				Garbage;
	unsigned long		Size;
	unsigned long		Current;
	inline garbageCollectorCOM();
	inline ~garbageCollectorCOM();
	inline void Release(void);
	inline void Add(void* pp);
	inline void Remove(void* pp);
};

// COM garbage collector constructor
inline garbageCollectorCOM::garbageCollectorCOM()
{
	Garbage = (void**)HeapAlloc(GetProcessHeap(), 0, 4);
	Current = 0;
	Size = 0;
}

// COM garbage collector destructor
inline garbageCollectorCOM::~garbageCollectorCOM()
{
	unsigned long i;
	for(i=0; i<Size; i++)
	{
		if (Garbage[i] != NULL)
		{
			((IUnknown*)Garbage[i])->Release();
			Garbage[i] = NULL;
		}
	}
}

// Remove all memory inside the garbage collector
inline void garbageCollectorCOM::Release(void)
{
	unsigned long i;
	for(i=0; i<Size; i++)
	{
		if (Garbage[i] != NULL)
		{
			((IUnknown*)Garbage[i])->Release();
			Garbage[i] = NULL;
		}
	}
}

// Add a COM pointer to the garbage collector
inline void garbageCollectorCOM::Add(void* pp)
{
	Garbage = (void**)HeapReAlloc(GetProcessHeap(), 0, (void*)Garbage, (Size + 1) * 4);
	Garbage[Current] = pp;
	Current++;
	Size++;
}

// Remove and release a COM pointer in the garbage collector
inline void garbageCollectorCOM::Remove(void* pp)
{
	int i = 0;
	int fReady = 0;
	int fResult = 0;
	while (fReady == 0)
	{
		if (Garbage[i] == pp)
		{
			((IUnknown*)Garbage[i])->Release();
			Garbage[i] = NULL;
			fReady = 1;
			fResult = 1;
		}
		if (i < (int)Size)
		{
			i++;
		}
		else
		{
			fReady = 1;
		}
	}
}

#endif

+ Code Snippet

#ifndef _CORE_GARBAGECOLLECTOR_H_
#define _CORE_GARBAGECOLLECTOR_H_

// Main include
#include "core_base.h"

// -- Garbage Collector ~ Start ~ --
struct garbageCollector
{
	void**				Garbage;
	unsigned long		Size;
	unsigned long		Current;
	inline garbageCollector();
	inline ~garbageCollector();
	inline void Release(void);
	inline void Add(void* pp);
	inline void Remove(void* pp);
};

// Release all the memory in the garbage collector
inline void garbageCollector::Release(void)
{
	unsigned long i;
	for(i=0; i<Size; i++)
	{
		if (Garbage[i] != NULL)
		{
			HeapFree(GetProcessHeap(), 0, Garbage[i]);
			Garbage[i] = NULL;
		}
	}
}

// Garbage collector constructor
inline garbageCollector::garbageCollector()
{
	Garbage = (void**)HeapAlloc(GetProcessHeap(), 0, 4);
	Current = 0;
	Size = 0;
}

// Garbage collector destructor
inline garbageCollector::~garbageCollector()
{
	unsigned long i;
	for(i=0; i<Size; i++)
	{
		if (Garbage[i] != NULL)
		{
			HeapFree(GetProcessHeap(), 0, Garbage[i]);
			Garbage[i] = NULL;
		}
	}
}

// Add a pointer to the garbage collector
inline void garbageCollector::Add(void* pp)
{
	Garbage = (void**)HeapReAlloc(GetProcessHeap(), 0, (void*)Garbage, (Size + 1) * 4);
	Garbage[Current] = pp;
	Current++;
	Size++;
}

// Remove a pointer from the garbage collector
inline void garbageCollector::Remove(void* pp)
{
	int i = 0;
	int fReady = 0;
	int fResult = 0;
	while (fReady == 0)
	{
		if (Garbage[i] == pp)
		{
			HeapFree(GetProcessHeap(), 0, pp);
			Garbage[i] = NULL;
			fReady = 1;
			fResult = 1;
		}
		if (i < (int)Size)
		{
			i++;
		}
		else
		{
			fReady = 1;
		}
	}
}

inline void* AllocMemGC(garbageCollector* gc, unsigned long int numBytes)
{
	void* tmp = HeapAlloc(GetProcessHeap(),0,numBytes);
	if (tmp != NULL)
	{
		memset(tmp, 0, numBytes);
		gc->Add(tmp);
		return tmp;
	}
	return NULL;
}
inline void FreeMemGC(garbageCollector* gc, void* pPtr)
{
	if (pPtr != NULL)
	{
		gc->Remove(pPtr);
	}
}

// -- Garbage Collector ~ End ~ --

// -- Garbage Collector (COM) ~ Start ~ --
struct garbageCollectorCOM
{
	void**				Garbage;
	unsigned long		Size;
	unsigned long		Current;
	inline garbageCollectorCOM();
	inline ~garbageCollectorCOM();
	inline void Release(void);
	inline void Add(void* pp);
	inline void Remove(void* pp);
};

// COM garbage collector constructor
inline garbageCollectorCOM::garbageCollectorCOM()
{
	Garbage = (void**)HeapAlloc(GetProcessHeap(), 0, 4);
	Current = 0;
	Size = 0;
}

// COM garbage collector destructor
inline garbageCollectorCOM::~garbageCollectorCOM()
{
	unsigned long i;
	for(i=0; i<Size; i++)
	{
		if (Garbage[i] != NULL)
		{
			((IUnknown*)Garbage[i])->Release();
			Garbage[i] = NULL;
		}
	}
}

// Remove all memory inside the garbage collector
inline void garbageCollectorCOM::Release(void)
{
	unsigned long i;
	for(i=0; i<Size; i++)
	{
		if (Garbage[i] != NULL)
		{
			((IUnknown*)Garbage[i])->Release();
			Garbage[i] = NULL;
		}
	}
}

// Add a COM pointer to the garbage collector
inline void garbageCollectorCOM::Add(void* pp)
{
	Garbage = (void**)HeapReAlloc(GetProcessHeap(), 0, (void*)Garbage, (Size + 1) * 4);
	Garbage[Current] = pp;
	Current++;
	Size++;
}

// Remove and release a COM pointer in the garbage collector
inline void garbageCollectorCOM::Remove(void* pp)
{
	int i = 0;
	int fReady = 0;
	int fResult = 0;
	while (fReady == 0)
	{
		if (Garbage[i] == pp)
		{
			((IUnknown*)Garbage[i])->Release();
			Garbage[i] = NULL;
			fReady = 1;
			fResult = 1;
		}
		if (i < (int)Size)
		{
			i++;
		}
		else
		{
			fReady = 1;
		}
	}
}

#endif

Hopefully the code should explain it self, any questions feel free to ask.

Cheers,

-naota

With any luck you'll be able to turn a fully functioning program to a crashing program with just a little bit of coding.
Aex.Uni forums

Back to top

Profile PM Email Website

Aaron Miller

18

Years of Service

User Offline

Joined: 25th Feb 2006

Playing: osu!

Posted: 6th Feb 2008 02:12

Link

I would also like to note that core_string.h was completely recreated from the original IString I showed over here a while ago. I did not forget about it, I took the advice I was given and redeveloped it.

Also, if anyone has any feedback or suggestions I'd gladly take them. Suggestions and criticism are important for this goes into my own software.

Cheers,

-naota

With any luck you'll be able to turn a fully functioning program to a crashing program with just a little bit of coding.
Aex.Uni forums

Back to top

Profile PM Email Website

jason p sage

17

Years of Service

User Offline

Joined: 10th Jun 2007

Location: Ellington, CT USA

Posted: 9th Feb 2008 15:39

Link

Looks like you put some work into this code. Good Job.

I did notice some loops where your copying string data and I think you might be better served by strcpy(this->s,st); or one of its varieties.

I BELIEVE these libs use the CPU native instructions to "bulk" copy "ranges" of ram - something the CPU is actually WIRED to do - and therefore happens BLAZINGLY fast - especially compared to looping through multiple instructions, managing your counter, dereferencing pointers each iteration.

The "Hardwired" method - in Assembly language - is a matter of setting the source location, the destination, and the length... then you almost literally press "FIRE" and the CPU does it all in one instruction... (yes a few clock cycles depending how much your moving) but much faster than man handling it. (It is a little complex setting up the source, destination, etc... but only for people - no work at all for CPU but memory addressing topics are getting a little to out there for this recommendation - because in short - if you just use strcpy you'll see a major speed increase with little effort on your part to convert the loop.

Here is a sample string lib I did that has it - just as a sample for ya:

jfc_string.h

/*============================================================================
|    _________ _______  _______  ______  _______    Jegas, LLC               |
|   /___  ___// _____/ / _____/ / __  / / _____/    JasonPSage@jegas.com     |
|      / /   / /__    / / ___  / /_/ / / /____                               |
|     / /   / ____/  / / /  / / __  / /____  /                               |
|____/ /   / /___   / /__/ / / / / / _____/ /                                |
/_____/   /______/ /______/ /_/ /_/ /______/                                 |
|                 Under the Hood                                             |
==============================================================================
           Copyright(c)2007 Jegas, LLC                      
============================================================================*/
#pragma once
//=============================================================================
class JFC_STRING{
//=============================================================================
public:  
  char *s;char chNull;
  unsigned int uiLength;
  JFC_STRING();
  ~JFC_STRING();
  void Clear(void);
  void Clear(int p_NewLength);// allows making a buffer instantly.
  void ConCat(const char *p_char);
  void Set(const char *p_char);
  char *Get(void);
  unsigned int Length(void);
  bool EqualCS(char *p_szCompareThis); // Case Sensitive
  bool Equal(char *p_szCompareThis);
  //function Replace(source$,search$,key$)
  //Function Misc_strip_path(f$)
  //Function Remove_End(f$)
  //function strInstr(source$,search$)

};
//=============================================================================

+ Code Snippet

/*============================================================================
|    _________ _______  _______  ______  _______    Jegas, LLC               |
|   /___  ___// _____/ / _____/ / __  / / _____/    JasonPSage@jegas.com     |
|      / /   / /__    / / ___  / /_/ / / /____                               |
|     / /   / ____/  / / /  / / __  / /____  /                               |
|____/ /   / /___   / /__/ / / / / / _____/ /                                |
/_____/   /______/ /______/ /_/ /_/ /______/                                 |
|                 Under the Hood                                             |
==============================================================================
           Copyright(c)2007 Jegas, LLC                      
============================================================================*/
#pragma once
//=============================================================================
class JFC_STRING{
//=============================================================================
public:  
  char *s;char chNull;
  unsigned int uiLength;
  JFC_STRING();
  ~JFC_STRING();
  void Clear(void);
  void Clear(int p_NewLength);// allows making a buffer instantly.
  void ConCat(const char *p_char);
  void Set(const char *p_char);
  char *Get(void);
  unsigned int Length(void);
  bool EqualCS(char *p_szCompareThis); // Case Sensitive
  bool Equal(char *p_szCompareThis);
  //function Replace(source$,search$,key$)
  //Function Misc_strip_path(f$)
  //Function Remove_End(f$)
  //function strInstr(source$,search$)

};
//=============================================================================

jfc_string.cpp

/*============================================================================
|    _________ _______  _______  ______  _______    Jegas, LLC               |
|   /___  ___// _____/ / _____/ / __  / / _____/    JasonPSage@jegas.com     |
|      / /   / /__    / / ___  / /_/ / / /____                               |
|     / /   / ____/  / / /  / / __  / /____  /                               |
|____/ /   / /___   / /__/ / / / / / _____/ /                                |
/_____/   /______/ /______/ /_/ /_/ /______/                                 |
|                 Under the Hood                                             |
==============================================================================
           Copyright(c)2007 Jegas, LLC                      
============================================================================*/
#include "jfc_string.h"
#include "string.h"

//=============================================================================
JFC_STRING::JFC_STRING(){
//=============================================================================
  this->s=0;
  chNull='\0';
  this->Clear();
};
//=============================================================================

//=============================================================================
JFC_STRING::~JFC_STRING(){
//=============================================================================
  if(this->s!=0){    
    delete this->s;
  };
};
//=============================================================================

//=============================================================================
void JFC_STRING::Clear(void){
//=============================================================================
  if(this->s!=0){
    delete this->s;
  };
  this->uiLength=0;
  this->s=new char[this->uiLength+1];
  this->s[this->uiLength]='\0';
};
//=============================================================================

//=============================================================================
void JFC_STRING::Clear(int p_NewLength){
//=============================================================================
  if(this->s!=0){
    delete this->s;
  };
  this->uiLength=p_NewLength;
  this->s=new char[this->uiLength+1];
  this->s[this->uiLength]='\0';
  int i;
  for(i=0;i<this->uiLength;i++){
    this->s[i]='\0';
  };
};
//=============================================================================

//=============================================================================
void JFC_STRING::ConCat(const char *p_char){
//=============================================================================
  char *st;
  this->uiLength=(unsigned int)(strlen(p_char)+this->uiLength);
  st=new char[this->uiLength+1];
  st[0]=chNull;
  strcat(st,this->s);
  strcat(st,p_char);
  delete this->s;
  this->s=new char[this->uiLength+1];
  strcpy(this->s,st);
  delete st;
  this->s[this->uiLength]='\0';
};
//=============================================================================

//=============================================================================
void JFC_STRING::Set(const char *p_char){
//=============================================================================
  this->Clear();
  this->ConCat(p_char);
};
//=============================================================================

//=============================================================================
char *JFC_STRING::Get(void){
//=============================================================================
  if(this->s!=0){
    return this->s;
  }else{
    return 0;
  };
};
//=============================================================================

//=============================================================================
unsigned int JFC_STRING::Length(void){
//=============================================================================
  return this->uiLength;
};
//=============================================================================

//=============================================================================
bool JFC_STRING::EqualCS(char *p_szCompareThis){
//=============================================================================
  return (strcmp(this->s,p_szCompareThis)==0); 
};
//=============================================================================

//=============================================================================
bool JFC_STRING::Equal(char *p_szCompareThis){
//=============================================================================
  return (strcmpi(this->s,p_szCompareThis)==0); 
};
//=============================================================================

+ Code Snippet

/*============================================================================
|    _________ _______  _______  ______  _______    Jegas, LLC               |
|   /___  ___// _____/ / _____/ / __  / / _____/    JasonPSage@jegas.com     |
|      / /   / /__    / / ___  / /_/ / / /____                               |
|     / /   / ____/  / / /  / / __  / /____  /                               |
|____/ /   / /___   / /__/ / / / / / _____/ /                                |
/_____/   /______/ /______/ /_/ /_/ /______/                                 |
|                 Under the Hood                                             |
==============================================================================
           Copyright(c)2007 Jegas, LLC                      
============================================================================*/
#include "jfc_string.h"
#include "string.h"




//=============================================================================
JFC_STRING::JFC_STRING(){
//=============================================================================
  this->s=0;
  chNull='\0';
  this->Clear();
};
//=============================================================================


//=============================================================================
JFC_STRING::~JFC_STRING(){
//=============================================================================
  if(this->s!=0){    
    delete this->s;
  };
};
//=============================================================================

//=============================================================================
void JFC_STRING::Clear(void){
//=============================================================================
  if(this->s!=0){
    delete this->s;
  };
  this->uiLength=0;
  this->s=new char[this->uiLength+1];
  this->s[this->uiLength]='\0';
};
//=============================================================================

//=============================================================================
void JFC_STRING::Clear(int p_NewLength){
//=============================================================================
  if(this->s!=0){
    delete this->s;
  };
  this->uiLength=p_NewLength;
  this->s=new char[this->uiLength+1];
  this->s[this->uiLength]='\0';
  int i;
  for(i=0;i<this->uiLength;i++){
    this->s[i]='\0';
  };
};
//=============================================================================



//=============================================================================
void JFC_STRING::ConCat(const char *p_char){
//=============================================================================
  char *st;
  this->uiLength=(unsigned int)(strlen(p_char)+this->uiLength);
  st=new char[this->uiLength+1];
  st[0]=chNull;
  strcat(st,this->s);
  strcat(st,p_char);
  delete this->s;
  this->s=new char[this->uiLength+1];
  strcpy(this->s,st);
  delete st;
  this->s[this->uiLength]='\0';
};
//=============================================================================

//=============================================================================
void JFC_STRING::Set(const char *p_char){
//=============================================================================
  this->Clear();
  this->ConCat(p_char);
};
//=============================================================================

//=============================================================================
char *JFC_STRING::Get(void){
//=============================================================================
  if(this->s!=0){
    return this->s;
  }else{
    return 0;
  };
};
//=============================================================================

//=============================================================================
unsigned int JFC_STRING::Length(void){
//=============================================================================
  return this->uiLength;
};
//=============================================================================



//=============================================================================
bool JFC_STRING::EqualCS(char *p_szCompareThis){
//=============================================================================
  return (strcmp(this->s,p_szCompareThis)==0); 
};
//=============================================================================

//=============================================================================
bool JFC_STRING::Equal(char *p_szCompareThis){
//=============================================================================
  return (strcmpi(this->s,p_szCompareThis)==0); 
};
//=============================================================================

http://www.jasonpetersage.com/?PAGE=ironinfantry&SECTION=ironinfantry

Back to top

Profile PM Email Website

Zotoaster

19

Years of Service

User Offline

Joined: 20th Dec 2004

Location: Scotland

Posted: 9th Feb 2008 16:21

Link

I'm liking the look of that garbage collector! Good work.

Your signature has been erased by a mod

Back to top

Profile PM Email

Aaron Miller

18

Years of Service

User Offline

Joined: 25th Feb 2006

Playing: osu!

Posted: 11th Feb 2008 00:53

Link

@jason p sage
Oh! I know what you're talking about. I actually used that command while developing my OS kernel in ASM, funny I didn't think of it. I'll have a look for it. But here's the thing with using inline ASM, the compiler will actually optimize your code to something completely different (In some cases) and will not do ANY optimizations on it if inline ASM is used. However, by providing an inline function containing the inline ASM, and then calling that inline function in the main code, I suppose that could work.

Any thoughts on doing it a quicker way still?

As a general note, I've been working on the core library more and came up with what I call the "MSI" (Modular Structure Interface). It's similar to COM except it actually does garbage collecting. I found a problem in the original version + a better way to implement it so I'm rewriting it right now.

In addition, I added some defines which better inform you of the target operating system, as well as several other functions. Most notably are the "PROC" and "INLINE" defines. PROC specifies the native calling convention you are using (If none are predefined, it'll define __stdcall). Then depending on that it'll do something like "USING_CDECL", "USING_STDCALL", and "USING_FASTCALL" to better help you link in proper libraries to these commands. INLINE will check what compiler you're using, then if you're using MSVC++ it'll specify __forceinline as the inline function, otherwise it'll use inline. The difference is that no matter what __forceinline will cause the function to become inlined with the code, where as inline may or may not work depending on the size of the code. Optimization is up to the end-user.

@Zotoaster
Thanks

I made it a while ago and then decided making a more standardized version would be good.

Glad you like it btw.

Cheers,

-naota

With any luck you'll be able to turn a fully functioning program to a crashing program with just a little bit of coding.
Aex.Uni forums

Back to top

Profile PM Email Website

jason p sage

17

Years of Service

User Offline

Joined: 10th Jun 2007

Location: Ellington, CT USA

Posted: 11th Feb 2008 01:26 Edited at: 11th Feb 2008 01:36

Link

@Aaron - I don't think you need to inline anything. I think when you use the <memory.h> header and commands like memcpy and memset I think it does that for you.

[edit]Meaning - I think it MAKES the CPU do the native fast stuff.

Note however I was trying to use those myself this weekend - sometimes I don't have a problem - this weekend I got frustrated enough to do the same thing you have in your code now - a for loop! Why? I keep screwing up the pointer syntax - and would get exceptions.... I tried a bunch of stuff ... and rescinded to for next - my code 100% working... and someday if I notice speed as issue - I'll revisit.... I try to practice what I preach.. but sometimes - <sigh> [/edit]

http://www.jasonpetersage.com/?PAGE=ironinfantry&SECTION=ironinfantry

Back to top

Profile PM Email Website

Aaron Miller

18

Years of Service

User Offline

Joined: 25th Feb 2006

Playing: osu!

Posted: 12th Feb 2008 20:58

Link

@jason
Its MUCH quicker to just not call a function, rather to do the code yourself, therefor inlining the ASM code keeps compiler optimizations as well as using the single instruction opcode.

Besides, if I can't do something that simple why do something complex?

Cheers,

-naota

With any luck you'll be able to turn a fully functioning program to a crashing program with just a little bit of coding.
Aex.Uni forums

Back to top

Profile PM Email Website

jason p sage

17

Years of Service

User Offline

Joined: 10th Jun 2007

Location: Ellington, CT USA

Posted: 13th Feb 2008 01:03

Link

I think you're missing what my goal of telling this to you was all about.

I'm pretty sure the memset, memcpy, strcpy, etc. commands are effectively INLINE functions, further more I believe they are coded in such a way to utilize the CPU's native (fast as heck) memory copying commands - e.g. they are usually written in assembly...

effectively - they are inline assembly code doing CPU native instructions giving you the extra speed.

However I'm in agreement though - that design is important yada yada - but working code is better than none - and going back to tighten bottle necks makes more sense than fighting for days on a routine - whose speed gains might not really even have a positive impact

I'm guilty of all things... except that, and that, and that...

In other words - The only reason I know anything is because I do a lot wrong first.

http://www.jasonpetersage.com/?PAGE=ironinfantry&SECTION=ironinfantry

Back to top

Profile PM Email Website

Aaron Miller

18

Years of Service

User Offline

Joined: 25th Feb 2006

Playing: osu!

Posted: 15th Feb 2008 02:38

Link

Thanks, but my point is that they aren't always inlined.

If I write the routine myself, then it will effectively be inline and I know it'll be inlined.

Plus better learning experience.

btw all, I got the MSI portion finished, but forgot to put it on this USB. :/ I'll upload it saturday or sunday (US time).

Cheers,

-naota

With any luck you'll be able to turn a fully functioning program to a crashing program with just a little bit of coding.
Aex.Uni forums

Back to top

Profile PM Email Website

Aaron Miller

18

Years of Service

User Offline

Joined: 25th Feb 2006

Playing: osu!

Posted: 16th Feb 2008 19:30

Link

I have the new version ready, its in this zip file with license and readme. MSI (The most complex part) has been explained greatly in its header file.

Cheers,

-naota

With any luck you'll be able to turn a fully functioning program to a crashing program with just a little bit of coding.
Aex.Uni forums

Attachments

Login to view attachments

Back to top

Profile PM Email Website

jason p sage

17

Years of Service

User Offline

Joined: 10th Jun 2007

Location: Ellington, CT USA

Posted: 17th Feb 2008 14:33

Link

I know what you mean and what you're saying and I think you have a point. If you really WANT inlined stuff - sometimes its better to do it yourself and force it. If this is what you are saying - I can believe this most readily.

http://www.jasonpetersage.com/?PAGE=ironinfantry&SECTION=ironinfantry

Back to top

Profile PM Email Website

Aaron Miller

18

Years of Service

User Offline

Joined: 25th Feb 2006

Playing: osu!

Posted: 22nd Feb 2008 20:55

Link

Yes, that is what I mean.

Cheers,

-naota

With any luck you'll be able to turn a fully functioning program to a crashing program with just a little bit of coding.
Aex.Uni forums

Back to top

Profile PM Email Website

jason p sage

17

Years of Service

User Offline

Joined: 10th Jun 2007

Location: Ellington, CT USA

Posted: 22nd Feb 2008 21:59

Link

You can use the stdlib for linked lists - I have a homebrew one if you want it that's not template based - you have to inherit - and override a couple things - and it can work with any types you want.

Your call.. Works reliably.

http://www.jasonpetersage.com/?PAGE=ironinfantry&SECTION=ironinfantry

Back to top

Profile PM Email Website

Aaron Miller

18

Years of Service

User Offline

Joined: 25th Feb 2006

Playing: osu!

Posted: 23rd Feb 2008 06:27

Link

I already have linked lists set up.

But if you wish to show yours off, be my guest.

Cheers,

-naota

With any luck you'll be able to turn a fully functioning program to a crashing program with just a little bit of coding.
Aex.Uni forums

Back to top

Profile PM Email Website

jason p sage

17

Years of Service

User Offline

Joined: 10th Jun 2007

Location: Ellington, CT USA

Posted: 23rd Feb 2008 15:06

Link

Thanx Bro - Maybe I will - I'm going to make another thread so I don't clutter up yours. BTW - That Garbage Collector is neat.

http://www.jasonpetersage.com/?PAGE=ironinfantry&SECTION=ironinfantry

Back to top

Profile PM Email Website

Aaron Miller

18

Years of Service

User Offline

Joined: 25th Feb 2006

Playing: osu!

Posted: 23rd Feb 2008 23:06

Link

np

My email actually IS "nocannedmeat@gmail.com". Why? I don't know.
Aex.Uni forums

Back to top

Profile PM Email Website

Sorry your browser is not supported!

Dark GDK / Aex.Uni Presents the Core Library

Attachments