Code-style consistency improvement:

Apply clang-format-all.sh using the _clang-format file through all the cpp/.h files.
make sure not to apply it to certain serialization structures, since some parser expects the * as part of the name, instead of type.
This commit contains no other changes aside from adding and applying clang-format-all.sh

Extras/Serialize/BlenderSerialize/bBlenderFile.cpp

@@ -27,32 +27,27 @@ extern int DNAlen;
 extern unsigned char DNAstr64[];
 extern int DNAlen64;
 
-
 using namespace bParse;
 
-bBlenderFile::bBlenderFile(const char* fileName)
-:bFile(fileName, "BLENDER")
+bBlenderFile::bBlenderFile(const char *fileName)
+	: bFile(fileName, "BLENDER")
 {
-	mMain= new bMain(this, fileName, mVersion);
+	mMain = new bMain(this, fileName, mVersion);
 }
 
-
-
 bBlenderFile::bBlenderFile(char *memoryBuffer, int len)
-:bFile(memoryBuffer,len, "BLENDER"),
-mMain(0)
+	: bFile(memoryBuffer, len, "BLENDER"),
+	  mMain(0)
 {
-	mMain= new bMain(this, "memoryBuf", mVersion);
+	mMain = new bMain(this, "memoryBuf", mVersion);
 }
 
-
 bBlenderFile::~bBlenderFile()
 {
 	delete mMain;
 }
 
-
-bMain* bBlenderFile::getMain()
+bMain *bBlenderFile::getMain()
 {
 	return mMain;
 }
@@ -60,20 +55,17 @@ bMain* bBlenderFile::getMain()
 // ----------------------------------------------------- //
 void bBlenderFile::parseData()
 {
-//	printf ("Building datablocks\n");
-//	printf ("Chunk size = %d\n",CHUNK_HEADER_LEN);
-//	printf ("File chunk size = %d\n", ChunkUtils::getOffset(mFlags));
+	//	printf ("Building datablocks\n");
+	//	printf ("Chunk size = %d\n",CHUNK_HEADER_LEN);
+	//	printf ("File chunk size = %d\n", ChunkUtils::getOffset(mFlags));
 
-	const bool swap = (mFlags&FD_ENDIAN_SWAP)!=0;
-	
+	const bool swap = (mFlags & FD_ENDIAN_SWAP) != 0;
 
-
-	char *dataPtr = mFileBuffer+mDataStart;
+	char *dataPtr = mFileBuffer + mDataStart;
 
 	bChunkInd dataChunk;
 	dataChunk.code = 0;
 
-
 	//dataPtr += ChunkUtils::getNextBlock(&dataChunk, dataPtr, mFlags);
 	int seek = getNextBlock(&dataChunk, dataPtr, mFlags);
 	//dataPtr += ChunkUtils::getOffset(mFlags);
@@ -81,55 +73,46 @@ void bBlenderFile::parseData()
 
 	while (dataChunk.code != DNA1)
 	{
-		
-
-
-
 		// one behind
 		if (dataChunk.code == SDNA) break;
 		//if (dataChunk.code == DNA1) break;
 
 		// same as (BHEAD+DATA dependency)
-		dataPtrHead = dataPtr+ChunkUtils::getOffset(mFlags);
+		dataPtrHead = dataPtr + ChunkUtils::getOffset(mFlags);
 		char *id = readStruct(dataPtrHead, dataChunk);
 
 		// lookup maps
 		if (id)
 		{
-            m_chunkPtrPtrMap.insert(dataChunk.oldPtr, dataChunk);
-			mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)id);
+			m_chunkPtrPtrMap.insert(dataChunk.oldPtr, dataChunk);
+			mLibPointers.insert(dataChunk.oldPtr, (bStructHandle *)id);
 
 			m_chunks.push_back(dataChunk);
 			// block it
 			bListBasePtr *listID = mMain->getListBasePtr(dataChunk.code);
 			if (listID)
-				listID->push_back((bStructHandle*)id);
+				listID->push_back((bStructHandle *)id);
 		}
 
 		if (dataChunk.code == GLOB)
 		{
-			m_glob = (bStructHandle*) id;
+			m_glob = (bStructHandle *)id;
 		}
 
 		// next please!
 		dataPtr += seek;
 
-		seek =  getNextBlock(&dataChunk, dataPtr, mFlags);
+		seek = getNextBlock(&dataChunk, dataPtr, mFlags);
 		if (seek < 0)
 			break;
 	}
-
 }
 
-void	bBlenderFile::addDataBlock(char* dataBlock)
+void bBlenderFile::addDataBlock(char *dataBlock)
 {
 	mMain->addDatablock(dataBlock);
 }
 
-
-
-
-
 // 32 && 64 bit versions
 extern unsigned char DNAstr[];
 extern int DNAlen;
@@ -137,88 +120,87 @@ extern int DNAlen;
 //unsigned char DNAstr[]={0};
 //int DNAlen=0;
 
-
 extern unsigned char DNAstr64[];
 extern int DNAlen64;
 
-
-void	bBlenderFile::writeDNA(FILE* fp)
+void bBlenderFile::writeDNA(FILE *fp)
 {
-
 	bChunkInd dataChunk;
 	dataChunk.code = DNA1;
 	dataChunk.dna_nr = 0;
 	dataChunk.nr = 1;
-	
+
 	if (VOID_IS_8)
 	{
 		dataChunk.len = DNAlen64;
 		dataChunk.oldPtr = DNAstr64;
-		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
-		fwrite(DNAstr64, DNAlen64,1,fp);
+		fwrite(&dataChunk, sizeof(bChunkInd), 1, fp);
+		fwrite(DNAstr64, DNAlen64, 1, fp);
 	}
 	else
 	{
 		dataChunk.len = DNAlen;
 		dataChunk.oldPtr = DNAstr;
-		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
-		fwrite(DNAstr, DNAlen,1,fp);
+		fwrite(&dataChunk, sizeof(bChunkInd), 1, fp);
+		fwrite(DNAstr, DNAlen, 1, fp);
 	}
 }
 
-void	bBlenderFile::parse(int verboseMode)
+void bBlenderFile::parse(int verboseMode)
 {
 	if (VOID_IS_8)
 	{
-		parseInternal(verboseMode,(char*)DNAstr64,DNAlen64);
+		parseInternal(verboseMode, (char *)DNAstr64, DNAlen64);
 	}
 	else
 	{
-		parseInternal(verboseMode,(char*)DNAstr,DNAlen);
+		parseInternal(verboseMode, (char *)DNAstr, DNAlen);
 	}
 }
 
 // experimental
-int		bBlenderFile::write(const char* fileName, bool fixupPointers)
+int bBlenderFile::write(const char *fileName, bool fixupPointers)
 {
 	FILE *fp = fopen(fileName, "wb");
 	if (fp)
 	{
-		char header[SIZEOFBLENDERHEADER] ;
+		char header[SIZEOFBLENDERHEADER];
 		memcpy(header, m_headerString, 7);
-		int endian= 1;
-		endian= ((char*)&endian)[0];
+		int endian = 1;
+		endian = ((char *)&endian)[0];
 
 		if (endian)
 		{
 			header[7] = '_';
-		} else
+		}
+		else
 		{
 			header[7] = '-';
 		}
 		if (VOID_IS_8)
 		{
-			header[8]='V';
-		} else
+			header[8] = 'V';
+		}
+		else
 		{
-			header[8]='v';
+			header[8] = 'v';
 		}
 
 		header[9] = '2';
 		header[10] = '4';
 		header[11] = '9';
-		
-		fwrite(header,SIZEOFBLENDERHEADER,1,fp);
+
+		fwrite(header, SIZEOFBLENDERHEADER, 1, fp);
 
 		writeChunks(fp, fixupPointers);
 
 		writeDNA(fp);
 
 		fclose(fp);
-		
-	} else
+	}
+	else
 	{
-		printf("Error: cannot open file %s for writing\n",fileName);
+		printf("Error: cannot open file %s for writing\n", fileName);
 		return 0;
 	}
 	return 1;

Extras/Serialize/BlenderSerialize/bBlenderFile.h

@@ -16,48 +16,43 @@ subject to the following restrictions:
 #ifndef B_BLENDER_FILE_H
 #define B_BLENDER_FILE_H
 
-
 #include "bFile.h"
 
-namespace bParse {
+namespace bParse
+{
+// ----------------------------------------------------- //
+class bBlenderFile : public bFile
+{
+protected:
+	bMain* mMain;
 
-	// ----------------------------------------------------- //
-	class bBlenderFile : public bFile
+	bStructHandle* m_glob;
+
+public:
+	bBlenderFile(const char* fileName);
+
+	bBlenderFile(char* memoryBuffer, int len);
+
+	virtual ~bBlenderFile();
+
+	bMain* getMain();
+
+	virtual void addDataBlock(char* dataBlock);
+
+	bStructHandle* getFileGlobal()
 	{
+		return m_glob;
+	}
 
-	protected:
-		bMain*				mMain;
+	// experimental
+	virtual int write(const char* fileName, bool fixupPointers = false);
 
-		bStructHandle*		m_glob;
+	virtual void parse(int verboseMode);
 
-		
-	public:
+	virtual void parseData();
 
-		bBlenderFile(const char* fileName);
-
-		bBlenderFile(char *memoryBuffer, int len);
-
-		virtual ~bBlenderFile();
-
-		bMain* getMain();
-
-		virtual	void	addDataBlock(char* dataBlock);
-
-		bStructHandle*		getFileGlobal()
-		{
-			return m_glob;
-		}
-
-		// experimental
-		virtual int		write(const char* fileName, bool fixupPointers = false);
-
-		virtual	void	parse(int verboseMode);
-
-		virtual	void parseData();
-
-		virtual	void	writeDNA(FILE* fp);
-
-	};
+	virtual void writeDNA(FILE* fp);
 };
+};  // namespace bParse
 
-#endif //B_BLENDER_FILE_H
+#endif  //B_BLENDER_FILE_H

Extras/Serialize/BlenderSerialize/bMain.cpp

@@ -21,51 +21,49 @@ subject to the following restrictions:
 
 using namespace bParse;
 
-
 // ----------------------------------------------------- //
 bMain::bMain(bBlenderFile *filePtr, const char *baseName, int fileVersion)
-	:	mFP(filePtr),
-		mVersion(fileVersion),
-		mName(baseName)	
+	: mFP(filePtr),
+	  mVersion(fileVersion),
+	  mName(baseName)
 {
-	mData.insert(ID_SCE,bListBasePtr());
-	mData.insert(ID_LI,bListBasePtr());
-	mData.insert(ID_OB,bListBasePtr());
-	mData.insert(ID_ME,bListBasePtr());
-	mData.insert(ID_CU,bListBasePtr());
-	mData.insert(ID_MB,bListBasePtr());
-	mData.insert(ID_MA,bListBasePtr());
-	mData.insert(ID_TE,bListBasePtr());
-	mData.insert(ID_IM,bListBasePtr());
-	mData.insert(ID_WV,bListBasePtr());
-	mData.insert(ID_LT,bListBasePtr());
-	mData.insert(ID_LA,bListBasePtr());
-	mData.insert(ID_CA,bListBasePtr());
-	mData.insert(ID_IP,bListBasePtr());
-	mData.insert(ID_KE,bListBasePtr());
-	mData.insert(ID_WO,bListBasePtr());
-	mData.insert(ID_SCR,bListBasePtr());
-	mData.insert(ID_VF,bListBasePtr());
-	mData.insert(ID_TXT,bListBasePtr());
-	mData.insert(ID_SO,bListBasePtr());
-	mData.insert(ID_GR,bListBasePtr());
-	mData.insert(ID_AR,bListBasePtr());
-	mData.insert(ID_AC,bListBasePtr());
-	mData.insert(ID_NT,bListBasePtr());
-	mData.insert(ID_BR,bListBasePtr());
+	mData.insert(ID_SCE, bListBasePtr());
+	mData.insert(ID_LI, bListBasePtr());
+	mData.insert(ID_OB, bListBasePtr());
+	mData.insert(ID_ME, bListBasePtr());
+	mData.insert(ID_CU, bListBasePtr());
+	mData.insert(ID_MB, bListBasePtr());
+	mData.insert(ID_MA, bListBasePtr());
+	mData.insert(ID_TE, bListBasePtr());
+	mData.insert(ID_IM, bListBasePtr());
+	mData.insert(ID_WV, bListBasePtr());
+	mData.insert(ID_LT, bListBasePtr());
+	mData.insert(ID_LA, bListBasePtr());
+	mData.insert(ID_CA, bListBasePtr());
+	mData.insert(ID_IP, bListBasePtr());
+	mData.insert(ID_KE, bListBasePtr());
+	mData.insert(ID_WO, bListBasePtr());
+	mData.insert(ID_SCR, bListBasePtr());
+	mData.insert(ID_VF, bListBasePtr());
+	mData.insert(ID_TXT, bListBasePtr());
+	mData.insert(ID_SO, bListBasePtr());
+	mData.insert(ID_GR, bListBasePtr());
+	mData.insert(ID_AR, bListBasePtr());
+	mData.insert(ID_AC, bListBasePtr());
+	mData.insert(ID_NT, bListBasePtr());
+	mData.insert(ID_BR, bListBasePtr());
 	mData.insert(ID_SCRIPT, bListBasePtr());
 }
 
-
 // ----------------------------------------------------- //
 bMain::~bMain()
 {
 	// allocated data blocks!
 
 	int sz = mPool.size();
-	for (int i=0;i<sz;i++)
+	for (int i = 0; i < sz; i++)
 	{
-		delete [] mPool[i];
+		delete[] mPool[i];
 	}
 }
 
@@ -85,30 +83,25 @@ const char *bMain::getName()
 void bMain::addDatablock(void *allocated)
 {
 	assert(allocated);
-	mPool.push_back((bStructHandle*)allocated);
+	mPool.push_back((bStructHandle *)allocated);
 }
 
-
-
-
 // ------------------------------------------------------------//
 void bMain::linkList(void *listBasePtr)
 {
-
-	struct ListBase // local Blender::ListBase
+	struct ListBase  // local Blender::ListBase
 	{
 		void *first;
 		void *last;
 	};
 
-	struct Link // local Blender::Link
+	struct Link  // local Blender::Link
 	{
 		void *next;
 		void *prev;
 	};
 
-
-	ListBase *base = (ListBase*)listBasePtr;
+	ListBase *base = (ListBase *)listBasePtr;
 
 	if (!base || !base->first)
 		return;
@@ -121,18 +114,18 @@ void bMain::linkList(void *listBasePtr)
 	}
 
 	void *prev = 0;
-	Link *l = (Link*)base->first;
+	Link *l = (Link *)base->first;
 	while (l)
 	{
 		l->next = mFP->findLibPointer(l->next);
 		l->prev = l->next;
 		prev = l->next;
-		l = (Link*)l->next;
+		l = (Link *)l->next;
 	}
 }
 
 // ------------------------------------------------------------//
-bListBasePtr* bMain::getListBasePtr(int listBaseCode)
+bListBasePtr *bMain::getListBasePtr(int listBaseCode)
 {
 	bListBasePtr *ptr = _findCode(listBaseCode);
 	if (!ptr)
@@ -143,12 +136,10 @@ bListBasePtr* bMain::getListBasePtr(int listBaseCode)
 // ------------------------------------------------------------//
 bListBasePtr *bMain::_findCode(int code)
 {
-	
-	bListBasePtr* lbPtr = mData.find(code);
+	bListBasePtr *lbPtr = mData.find(code);
 	return lbPtr;
 }
 
-
 // ------------------------------------------------------------//
 bListBasePtr *bMain::getScene()
 {
@@ -193,8 +184,6 @@ bListBasePtr *bMain::getCurve()
 	return ptr;
 }
 
-
-
 // ------------------------------------------------------------//
 bListBasePtr *bMain::getMball()
 {
@@ -222,7 +211,6 @@ bListBasePtr *bMain::getTex()
 	return ptr;
 }
 
-
 // ------------------------------------------------------------//
 bListBasePtr *bMain::getImage()
 {
@@ -295,7 +283,6 @@ bListBasePtr *bMain::getWorld()
 	return ptr;
 }
 
-
 // ------------------------------------------------------------//
 bListBasePtr *bMain::getScreen()
 {
@@ -368,7 +355,6 @@ bListBasePtr *bMain::getAction()
 	return ptr;
 }
 
-
 // ------------------------------------------------------------//
 bListBasePtr *bMain::getNodetree()
 {
@@ -387,6 +373,4 @@ bListBasePtr *bMain::getBrush()
 	return ptr;
 }
 
-
-
 //eof

Extras/Serialize/BlenderSerialize/bMain.h

@@ -20,91 +20,77 @@ subject to the following restrictions:
 #include "bChunk.h"
 #include "LinearMath/btHashMap.h"
 
+namespace bParse
+{
+class bDNA;
+
+class bBlenderFile;
+};  // namespace bParse
 
 namespace bParse
 {
-	class bDNA;
+// ----------------------------------------------------- //
 
-	class bBlenderFile;
-};
+typedef btHashMap<btHashInt, bListBasePtr> bMainDataMap;
 
-
-
-namespace bParse {
-
-
-	// ----------------------------------------------------- //
-	
-	typedef	btHashMap<btHashInt,bListBasePtr> bMainDataMap;
-
-
-
-	// ----------------------------------------------------- //
-	class bMain
-	{
+// ----------------------------------------------------- //
+class bMain
+{
 	//private:
-	public:
-		bBlenderFile*			mFP;
-		bListBasePtr	mPool;
+public:
+	bBlenderFile *mFP;
+	bListBasePtr mPool;
 
-		int				mVersion;
-		const char*		mName;
+	int mVersion;
+	const char *mName;
 
-		bMainDataMap	mData;
+	bMainDataMap mData;
 
-	
+	bListBasePtr *_findCode(int code);
 
+public:
+	bMain(bBlenderFile *filePtr, const char *baseName, int fileVersion);
+	~bMain();
 
-		bListBasePtr *_findCode(int code);
+	int getVersion();
+	const char *getName();
 
-	public:
-		bMain(bBlenderFile  *filePtr, const char *baseName, int fileVersion);
-		~bMain();
+	bListBasePtr *getListBasePtr(int listBaseCode);
 
-		int getVersion();
-		const char *getName();
+	bListBasePtr *getScene();
+	bListBasePtr *getLibrary();
+	bListBasePtr *getObject();
+	bListBasePtr *getMesh();
+	bListBasePtr *getCurve();
+	bListBasePtr *getMball();
+	bListBasePtr *getMat();
+	bListBasePtr *getTex();
+	bListBasePtr *getImage();
+	bListBasePtr *getWave();
+	bListBasePtr *getLatt();
+	bListBasePtr *getLamp();
+	bListBasePtr *getCamera();
+	bListBasePtr *getIpo();
+	bListBasePtr *getKey();
+	bListBasePtr *getWorld();
+	bListBasePtr *getScreen();
+	bListBasePtr *getScript();
+	bListBasePtr *getVfont();
+	bListBasePtr *getText();
+	bListBasePtr *getSound();
+	bListBasePtr *getGroup();
+	bListBasePtr *getArmature();
+	bListBasePtr *getAction();
+	bListBasePtr *getNodetree();
+	bListBasePtr *getBrush();
 
-		bListBasePtr *getListBasePtr(int listBaseCode);
+	// tracking allocated memory
+	void addDatablock(void *allocated);
 
+	// --
 
-		bListBasePtr *getScene();
-		bListBasePtr *getLibrary();
-		bListBasePtr *getObject();
-		bListBasePtr *getMesh();
-		bListBasePtr *getCurve();
-		bListBasePtr *getMball();
-		bListBasePtr *getMat();
-		bListBasePtr *getTex();
-		bListBasePtr *getImage();
-		bListBasePtr *getWave();
-		bListBasePtr *getLatt();
-		bListBasePtr *getLamp();
-		bListBasePtr *getCamera();
-		bListBasePtr *getIpo();
-		bListBasePtr *getKey();
-		bListBasePtr *getWorld();
-		bListBasePtr *getScreen();
-		bListBasePtr *getScript();
-		bListBasePtr *getVfont();
-		bListBasePtr *getText();
-		bListBasePtr *getSound();
-		bListBasePtr *getGroup();
-		bListBasePtr *getArmature();
-		bListBasePtr *getAction();
-		bListBasePtr *getNodetree();
-		bListBasePtr *getBrush();
+	void linkList(void *listBasePtr);
+};
+}  // namespace bParse
 
-
-		
-		// tracking allocated memory
-		void addDatablock(void *allocated);
-
-
-		// --
-		
-		void linkList(void *listBasePtr);
-	};
-}
-
-
-#endif//__BMAIN_H__
+#endif  //__BMAIN_H__