class EFException
{
public:
	///////////////////////////////////////////////////////////////////////////
	// Enumerations

	/// An enumeration with individual exception categorizations.
	enum ExceptionCode
	{
		EC_FATAL_ERROR,
		EC_GENERAL_ERROR,
		EC_INVALID_PARAMETERS,
		EC_ILLEGAL_ADDRESS,
		EC_ILLEGAL_OPCODE,
		EC_ILLEGAL_PACKET
	};
	
	///////////////////////////////////////////////////////////////////////////
	// Constructors
	
	/** The basic constructor.
	  */
	EFException(const ExceptionCode& code, const std::string& message, const std::string& file, 
				const std::string& function, long line);
	/** The assignment operator.
	  */
	EFException operator = (EFException& right);

	///////////////////////////////////////////////////////////////////////////
	// Exception Information Functions

	/** Returns the exception code for this message.
	  */
	ExceptionCode GetExceptionCode() const throw();
	/** Returns detailed information about the error.
	  */
	std::string GetDetailedInformation() throw();
protected:
	///////////////////////////////////////////////////////////////////////////
	// Exception Code Function

	/** Returns the name of the exception code for this exception.
	  */
	std::string GetExceptionCodeStr() throw();

	///////////////////////////////////////////////////////////////////////////
	// Variables

	long          mLine;
	ExceptionCode mCode;
	std::string   mFile;
	std::string   mMessage;
	std::string   mFunction;
};

    As you can see this class will be our exception class. This is the class which will be thrown every time an exception occurs. This exception describes every aspect of the area where the exception occurred, most notably the name of the file, the function in that file, the line in that file, and also a message describing the error that occurred. This is very useful for getting important, specific information about the error that occurred, as this information is invaluable when you are writing an emulator and tracking down bugs. In addition to all that information you may notice that I have also included an error code. The error codes create a simple way in which a fatal error can be distinguished from a non-fatal error at any point in your program. In addition to this ability to distinguish differences, they also help to categorize an error into a group, making it easier to asses the error when it is thrown.
    Now lets explain some of the more advanced C++ concepts presented here for those who don't know about them. Firstly the word "const" following a function is used to show the fact that within the body of this function no values are modified, this means that the function is only returning a value - nothing more and nothing less. Secondly the word "throw()" following a function is used to create a contract between the function caller and the function itself meaning that this function will not throw any object of any kind any time that it is called. This is very important, especially in an exception class. Also you may have noticed that we specified an "operator =", this is because the compiler (Microsoft Visual C++ .NET) was unable to generate this function at compilation time. Anyways now lets move on to what the functions themselves are supposed to do.
    The purpose of the constructor should be obvious given its parameter names and the names of our protected variables, as should the purpose of the assignment operator, so I will not delve into these as these are necessary knowledge at this point. However let's discuss the function "GetExceptionCode". This function's purpose is to retrieve the error code that categorizes this exception. Inside the body of this function nothing will be modified or thrown, and in fact all the internals of this function do is return the value "mCode" which is a protected member variable. Moving onto the next function, we see "GetDetailedInformation". This function's purpose is to return an std::string containing detailed information about the exception. This function in fact returns a message formatted as follows: