// 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