// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#ifndef __PFSDUMP_H__

#define __PFSDUMP_H__

#ifndef __MSVCDOTNET__

#pragma warning(disable: 4710)

#endif //__MSVCDOTNET__

int const MajorVersion=1;

int const MinorVersion=6;

int const Build=66;

#include <stdlib.h>

#include <memory.h>

#include <ctype.h>

#ifdef __MSVCDOTNET__

#include <strstream>

#include <fstream>

#include <iomanip>

#include <iostream>

using namespace std;

#else //!__MSVCDOTNET__

#include <strstrea.h>

#include <fstream.h>

#include <iomanip.h>

#endif //__MSVCDOTNET__

char const* const Margin="  ";

template <class T> inline T min(T a,T b) {return a<b ? a : b;}

template <class T> inline T max(T a,T b) {return a>b ? a : b;}

class Handle

	{

	enum

		{

		IndexMask=0xffffff,

		GenMask=0xf000000,

		GenShift=24,

		TocBase=0x40000000,

		AvailBit=0x80000000,

		TocDelta=AvailBit

		};

public:

	inline Handle() {}

	inline Handle(unsigned aValue) :iValue(aValue) {}

	inline bool IsNull() const {return iValue==0;}

	inline int Avail() const {return iValue&AvailBit;}

	inline int IsDelta() const {return iValue&TocDelta;}

	inline bool IsTocBase() const {return iValue==TocBase;}

	inline int Generation() const {return (iValue&GenMask)>>GenShift;}

	inline int Index() const {return iValue&IndexMask;}

	inline int operator==(Handle aHandle) const {return iValue==aHandle.iValue;}

	inline int operator!=(Handle aHandle) const {return iValue!=aHandle.iValue;}

private:

	unsigned long iValue;

//

	friend class StreamId;

	friend ostream& operator<<(ostream&,Handle);

	};

class StreamId : public Handle

	{

	enum {Mask=0xfffffff};

public:

	inline StreamId(Handle aHandle) :Handle(aHandle.iValue&Mask) {}

	};

class FramePos

	{

public:

	inline FramePos() {}

	inline FramePos(int aPos) :iValue(aPos) {}

	inline int Pos() const {return iValue;}

private:

	int iValue;

//

	friend ostream& operator<<(ostream&,FramePos);

	};

class FileOffset

	{

public:

	inline FileOffset(int anOffset) :iValue(anOffset) {}

	inline int Offset() const {return iValue;}

// offset/pos conversion

	FileOffset(FramePos aPos);

	operator FramePos() const;

private:

	int iValue;

//

	friend ostream& operator<<(ostream&,FileOffset);

	};

class FrameDes

	{

	enum {TypeMask=0xc000,TypeShift=14,LengthMask=0x3fff};

public:

	enum {First=0x20,Size=2,Interval=0x4002,FullShift=14};

	enum {Free=0,Data,Toc,Continuation};

//

	inline FrameDes() {}

	inline FrameDes(unsigned aDes) :iDes((unsigned short)aDes) {}

	inline int Type() const {return iDes>>TypeShift;}

	inline int Length() const {return iDes&LengthMask;}

private:

	unsigned short iDes;

//

	friend ostream& operator<<(ostream&,FrameDes);

	friend istream& operator>>(istream&,FrameDes&);

	};

class Header

	{

	enum {dirty=0x1,backupshift=1};

public:

	enum {tocoffset=-12};

public:

	struct Reloc

		{

		Handle iHandle;

		FramePos iPos;

		};

	enum {Offset=0x10,Size=14};

public:

	inline int Empty() const {return Toc().Pos()<0;}

	inline int Dirty() const {return iBackupToc&dirty;}

	FramePos Toc() const;

	Reloc const* GetReloc() const;

private:

	long iBackupToc;

	union

		{

		struct

			{

			long iZero;

			long iPos;

			} iToc;

		struct

			{

			unsigned long iHandle;

			long iPos;

			} iReloc;

		};

	unsigned short iCrc;

	};

ostream& operator<<(ostream&,Header const&);

class Frames

	{

public:

	struct Element

		{

		FramePos iPos;

		FrameDes iDes;

		};

	typedef Element const* Iterator;

public:

	Frames();

	~Frames();

//

	void Add(FramePos aPos,FrameDes aDes);

	void Complete();

	Iterator Find(FramePos aPos) const;

	inline Iterator Begin() const {return iRep;}

	inline Iterator End() const {return iRep+iElements;}

private:

	static int Compare(void const* aLeft,void const* aRight);

private:

	int iSize;

	int iElements;

	Element* iRep;

	};

class Stream

	{

public:

	inline Stream(Frames const& aFrames,FramePos aPos)	:iFrame(aFrames.Find(aPos)) {}

	inline Stream(Frames::Iterator aFrame) :iFrame(aFrame) {}

	inline int IsGood() const {return iFrame!=NULL;}

	inline int Type() const {return iFrame->iDes.Type();}

	inline Frames::Iterator Frame() const {return iFrame;}

	int Length() const;

	void* Load(istream& aStream) const;

private:

	Frames::Iterator iFrame;

	};

class Toc

	{

public:

	struct Head

		{

		enum {Size=12};

		inline StreamId Root() const {return StreamId(iRoot);}

		inline int IsDelta() const {return iRoot.IsDelta();}

		Handle iRoot;

		Handle iAvail;

		long iCount;

		};

	struct DeltaHead

		{

		enum {Size = 7};

		long iBase;

		unsigned short iMagic;

		unsigned char iCount;

		};

	struct Entry

		{

		enum {BaseSize=5,BaseRedundant=3,DeltaSize=8};

		inline Handle Link() const {return iLink;}

		inline FramePos Pos() const {return iPos;}

	//

		Handle iHandle;

		union

			{

			unsigned long iLink;

			long iPos;

			};

		};

	typedef Entry const* Iterator;

public:

	Toc();

	~Toc();

//

	void Load(istream& aStream,Frames const& aFrames,Frames::Iterator aFrame,Header::Reloc const* aReloc);

	inline Head const& Header() const {return iHeader;}

	inline Iterator Begin() const {return iRep;}

	inline Iterator End() const {return iRep+iHeader.iCount;}

	inline Entry const& operator[](int anIndex) {return iRep[anIndex-1];}

private:

	void Base(const char* aPtr,int aCount);

private:

	FramePos iPos;

	Head iHeader;

	DeltaHead iDelta;

	Entry* iRep;

	int iAvail;

//

	friend ostream& operator<<(ostream&,Toc const&);

	};

class HexDump

	{

	enum {HexInterval=0x10};

public:

	HexDump();

	~HexDump();

//

	void Reset();

	void Dump(istream& aStream,int aBytes);

	void Flush();

private:

	int iPos;

	int iByte;

	char* iPtr;

	char iChar[HexInterval+4];

	};

class StoreFile

	{

	enum {PermanentFileStoreUid=268435536};

public:

	StoreFile(char const* aFile);

	~StoreFile();

//

	inline int Empty() const {return iHeader.Empty();}

	void EmitHeader();

	void EmitFrames();

	void EmitToc();

	void EmitStreams();

private:

	void LoadFrames();

	void LoadToc();

public:

	static int OutWidth;

private:

	ifstream iFile;

	int iSize;

	Header iHeader;

	Frames iFrames;

	Toc iToc;

	};

class binbuf : public streambuf

	{

public:

	binbuf();

private:

	int overflow(int);

	int underflow();

	};

class Program

	{

public:

	enum {frame=0x1,quiet=0x2,verbose=0x4,compare=0x8};

public:

	Program();

//

	int ProcessCommandLine(int argc,char ** argv);

	void Information();

	void ExplainUsage();

	void Run();

	inline int Option(int type) const {return iOptions&type;}

	inline int TocRevision() const {return iTocRevision;}

//

	static void Abort(char const* message);

	static void Corrupt(char const* message);

	static ostream& Error();

	static ostream& Warning();

private:

	char const* iFile;

	int iOptions;

	int iTocRevision;

	binbuf iBinBuf;

	ostream iBin;

	int iErrors;

	};

extern Program TheProgram;

#endif