ssxog/docs/styleguide.md

SSX Decompilation Style Guide

Most of the documentation here is enforced by clang-format.

However, I've written other naming rules which aren't enforced down to make it more obvious, and to aid potentional contributors.

Code Style

Braces/Indentation

Any block scopes should have the brace on the next line, ala Allman bracing.

if(1)
{
	// do something
}

try
{
}
catch(...)
{
	// An error occured
}

Tabs are used for indentation throughout the codebase.

East/West Const/Volatile/...

It seems EA preferred west-const (where semantically possible), so, go west, collect 200$, get out of jail.

Naming Rules

Variables

Variable naming is not too complicated; just try to make it understandable.

There are the following special prefixes, used in certain scenarios:

Name	Meaning/Scenario
m	Class member (or static member) variable.
g	Global variable.

Types

BX/SSX types have a prefix before them, which is:

Prefix	C++ Type
t	typedef struct
c	class/struct
T	template<> class/struct (* Only seen in SSX3)

Legacy types (REAL/SND) won't/don't need this due diligence, so it's ok to omit with those (as a matter of fact, it'd be more correct).

Pointer/Reference Types

The pointer/reference goes on the side of the type, ala T* name and T& name.

Functions

Function naming is PascalCase wherever possible, except for legacy code (specifically SND & REAL).

In this case, REAL/SND functions follow the following standard:

[component/namespace, as uppercase]_[lowercase function name].

No functions should be annotated as (void) unless explicitly decompiled as C or exported in a C header file, as C++ ensures () is not surprising.

Member functions can use the longer this-> access pattern for members if desired, but you don't have to unless you.. well, have to.

Comments

Don't really care. If you think something might not be obvious, feel free to comment describing it.

If there's something surprising (or repulsive, considering 2000 C++), do so too.

Example

Provided is an example of code fitting the style guide, to hopefully visualize things better.

// A basic object.
class cBxObject
{
public:
	int mCounter;
	static int mVar;
    
	uint32_t mUnsignedValue;

	uint16_t mShort;
	int16_t mSignedShort;
    
	static uint16_t mStaticValue;
	static int16_t mStaticSignedValue;
    
	uint64_t mThing;
	int64_t mSignedThing;
	
	static int64_t mThingStatic;
	static uint64_t mThingStatic;
    
	int* mPointerVar;

	// Morph
	void Morph();

	void ReferenceExample(int& output); // only for reference output
};

typedef struct
{
	int Number;
    
	void DoIt();
} tBxStructure;

// example of a legacy function and type name
FILEOP *FILE_dothing();

void cBxObject::Morph()
{
	mCounter++;
	if(mCounter == 32)
	{
		// Do something important.
	}
}