Initial Commit

common/MEMFILE.HPP

@@ -0,0 +1,213 @@
+#ifndef _COMMON_MEMFILE_HPP_
+#define _COMMON_MEMFILE_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _COMMON_TYPES_HPP_
+#include <common/types.hpp>
+#endif
+#ifndef _COMMON_INTEL_HPP_
+#include <common/intel.hpp>
+#endif
+#ifndef _COMMON_GLOBALDATA_HPP_
+#include <common/gdata.hpp>
+#endif
+
+class MemFile
+{
+public:
+  enum SeekFrom{SeekBeginning,SeekCurrent};
+  enum ByteOrder{BigEndian,LittleEndian};
+	enum {BufferLength=16384};
+  MemFile(const String &pathFileName,DWORD lengthBuffer=BufferLength,ByteOrder byteOrder=LittleEndian);
+	MemFile(DWORD lengthBuffer,ByteOrder byteOrder=LittleEndian);
+	virtual ~MemFile();
+	bool rewind(void);
+	bool read(BYTE &value);
+	bool read(WORD &value);
+	bool read(int &value);
+	bool read(DWORD &value);
+	DWORD read(char *lpBuffer,DWORD lengthData);
+	DWORD read(char *lpBuffer,DWORD lengthData,int stopChar);
+  DWORD getLine(String &lineString);
+	bool write(BYTE value);
+	bool write(WORD value);
+	bool write(DWORD value);
+	bool write(int value);
+	bool write(char *lpBuffer,DWORD lengthData);
+  bool write(char *lpBuffer);
+	bool flushBuffer(void);
+  DWORD captureBuffer(GlobalData<BYTE> &memoryBuffer,bool clearDirty);
+  DWORD tell(void)const;
+	bool seek(LONG offset,SeekFrom seekFrom);
+  bool open(DWORD lengthBuffer,ByteOrder byteOrder=LittleEndian);
+  void close(void);
+	DWORD size(void)const;
+	DWORD extent(void)const;
+	bool isOkay(void)const;
+private:
+  enum {CarriageReturn=0x0D,LineFeed=0x0A,NullChar=0x00};
+	bool createBuffer(DWORD lengthBuffer);
+  bool destroyBuffer(void);
+
+	HGLOBAL mhGlobalBuffer;
+	UHUGE *mlpBuffer;
+	UHUGE *mlpBufferPointer;
+	ByteOrder mByteOrder;
+	bool mIsDirty;
+	DWORD mMaxExtent;
+	DWORD mBufferLength;
+	String mPathFileName;
+  Intel mIntelData;
+};
+
+inline
+MemFile::MemFile(const String &pathFileName,DWORD lengthBuffer,ByteOrder byteOrder)
+: mPathFileName(pathFileName), mlpBuffer(0), mlpBufferPointer(0), mByteOrder(byteOrder),
+  mIsDirty(false), mMaxExtent(0), mBufferLength(0), mhGlobalBuffer(0)
+{
+  createBuffer(lengthBuffer);
+}
+
+inline
+MemFile::MemFile(DWORD lengthBuffer,ByteOrder byteOrder)
+: mlpBuffer(0), mlpBufferPointer(0), mByteOrder(byteOrder), mIsDirty(false),
+  mMaxExtent(0), mBufferLength(0), mhGlobalBuffer(0)
+{
+  createBuffer(lengthBuffer);
+}
+
+inline
+MemFile::~MemFile()
+{
+  close();
+}
+
+inline
+bool MemFile::open(DWORD lengthBuffer,ByteOrder byteOrder)
+{
+  close();
+	mByteOrder=byteOrder;
+	return createBuffer(lengthBuffer);
+}
+
+inline
+void MemFile::close()
+{
+	if(mIsDirty)flushBuffer();
+  destroyBuffer();
+	if(!mPathFileName.isNull())mPathFileName=String("");
+}
+
+inline
+bool MemFile::isOkay(void)const
+{
+  return (mhGlobalBuffer?true:false);
+}
+
+inline
+DWORD MemFile::tell(void)const
+{
+	if(!isOkay())return FALSE;
+  return mlpBufferPointer-mlpBuffer;
+}
+
+inline
+bool MemFile::read(BYTE &value)
+{
+	if(!isOkay())return false;
+  if(mlpBufferPointer-mlpBuffer>=mMaxExtent)return false;
+	value=*(mlpBufferPointer++);
+  return true;
+}
+
+inline
+bool MemFile::read(WORD &value)
+{
+  BYTE byteValue;
+
+	if(!isOkay())return false;
+	if(!read(byteValue))return false;
+	value=byteValue;
+	if(!read(byteValue))return false;
+  value|=((WORD)byteValue)<<8;
+	if(BigEndian==mByteOrder)value=mIntelData.intelData(value);
+	return true;
+}
+
+inline
+bool MemFile::read(int &value)
+{
+  return read((DWORD&)value);
+}
+
+inline
+bool MemFile::read(DWORD &value)
+{
+	WORD wordValue;
+
+	if(!isOkay())return false;
+	if(!read(wordValue))return false;
+	value=wordValue;
+	if(!read(wordValue))return false;
+	value|=((DWORD)wordValue)<<16;
+	if(BigEndian==mByteOrder)value=mIntelData.intelData(value);
+  return true;
+}
+
+inline
+bool MemFile::write(BYTE value)
+{
+	if(!isOkay())return false;
+
+  if(mMaxExtent>=mBufferLength)return false;
+	*(mlpBufferPointer++)=value;
+	if(mlpBufferPointer-mlpBuffer>mMaxExtent)mMaxExtent=mlpBufferPointer-mlpBuffer;
+  mIsDirty=true;
+	return true;
+}
+
+inline
+bool MemFile::write(WORD value)
+{
+	BYTE byteValue;
+
+  if(!isOkay())return false;
+	if(BigEndian==mByteOrder)value=mIntelData.intelData(value);
+	byteValue=(BYTE)(value&0x00FF);
+	if(!write(byteValue))return false;
+	byteValue=(BYTE)(value>>8);
+  if(!write(byteValue))return false;
+  return true;
+}
+
+inline
+bool MemFile::write(int value)
+{
+  return write((DWORD)value);
+}
+
+inline
+bool MemFile::write(char *lpBuffer)
+{
+  if(!lpBuffer)return false;
+	return write(lpBuffer,::strlen(lpBuffer));
+}
+
+inline
+DWORD MemFile::size(void)const
+{
+  return (mlpBufferPointer-mlpBuffer);
+}
+
+inline
+DWORD MemFile::extent(void)const
+{
+  return mMaxExtent;
+}
+
+
+#endif