Appendix B

//
// Sample code to read the text out of a PowerPoint '97 presentation.
//
#include <ole2.h>
#include <stdio.h>
#include <time.h>

// Stolen from app\sertypes.h
// system dependent sizes
// system dependent sizes
// 
typedef signed long sint4; // signed 4-byte integral value
typedef signed short sint2; // signed 4-byte integral value
typedef unsigned long uint4; // unsigned 4-byte integral value
typedef unsigned short uint2; // 2-byte
typedef char bool1; // 1-byte boolean
typedef unsigned char ubyte1; // unsigned byte value
typedef uint2 psrType;
typedef uint4 psrSize; // each record is preceeded by
// pssTypeType and pssSizeType.
typedef uint2 psrInstance;
typedef uint2 psrVersion;
typedef uint4 psrReference; // Saved object reference
#define PSFLAG_CONTAINER 0xFF // If the version field of a record
                              // header takes on this value, the
                              // record header marks the start of
                              // a container.
// PowerPoint97 Record Header
typedef unsigned long DWord;

int AssertionFailed( const char* file, int line, const char* expr )
/*=================*/
{
   // AR: Message box the assert
   return( TRUE );
} /* AssertionFailed */

#define Assert( expr ) \
{ \
static char _str[] = #expr; \
\
if( !(int)(expr) ) \
AssertionFailed( __FILE__, __LINE__, _str ); \
} /* Assert */

static BOOL ReadText( WCHAR* buffer, unsigned long bufferSize, unsigned long* pSizeRet );
// Returns TRUE if more text exists. Fills buffer upto bufferSize. Actual size used is
// pSizeRet.

struct RecordHeader
{
   psrVersion recVer : 4; // may be PSFLAG_CONTAINER
   psrInstance recInstance : 12;
   psrType recType;
   psrSize recLen;
};

struct PSR_CurrentUserAtom
{
   uint4 size;
   uint4 magic; // Magic number to ensure this is a PowerPoint file.
   uint4 offsetToCurrentEdit; // Offset in main stream to current edit field.
   uint2 lenUserName;
   uint2 docFileVersion;
   ubyte1 majorVersion;
   ubyte1 minorVersion;
};

struct PSR_UserEditAtom
{
   sint4 lastSlideID; // slideID
   uint4 version; // This is major/minor/build which did the edit
   uint4 offsetLastEdit; // File offset of last edit
   uint4 offsetPersistDirectory; // Offset to PersistPtrs for
                                 // this file version.
   uint4 documentRef;
   uint4 maxPersistWritten; // Addr of last persist ref written to the file (max seen so far).
   sint2 lastViewType; // enum view type
};

struct PSR_SlidePersistAtom
{
   uint4 psrReference;
   uint4 flags;
   sint4 numberTexts;
   sint4 slideId;
   uint4 reserved;
};

#define CURRENT_USER_STREAM L"Current User"
#define DOCUMENT_STREAM L"PowerPoint Document"
#define HEADER_MAGIC_NUM -476987297

const int PST_UserEditAtom = 4085;
const int PST_PersistPtrIncrementalBlock = 6002; // Incremental diffs on persists
const int PST_SlidePersistAtom = 1011;
const int PST_TextCharsAtom = 4000; // Unicode in text
const int PST_TextBytesAtom = 4008; // non-unicode text
class PPSPersistDirectory;

struct ParseContext
{
   ParseContext(ParseContext *pNext) : m_pNext(pNext), m_nCur(0)
   {
   }
   RecordHeader m_rh;
   uint4 m_nCur;
   ParseContext *m_pNext;
};

const int SLIDELISTCHUNKSIZE=32;
struct SlideListChunk
{
   SlideListChunk( SlideListChunk* next, psrReference newOne ) :
   pNext( next ), numInChunk(1)
   {
      refs[0] = newOne;
   }
   SlideListChunk *pNext;
   DWord numInChunk;
   psrReference refs[SLIDELISTCHUNKSIZE];
};

class FileReader
{
public:
   FileReader(IStorage *pStg);
   ~FileReader();
   BOOL ReadText( WCHAR *pBuff, ULONG size, ULONG *pSizeRet );
// Reads next size chars from file. Returns TRUE if there is more
// text to read.
   BOOL IsPowerPoint()
   {
      return m_isPP;
   } // Returns true if this is a PowerPoint '97 file.
   void ReadPersistDirectory();
   void PPSReadUserEditAtom( DWord offset, PSR_UserEditAtom& userEdit );
   void ReadSlideList();
protected:
   BOOL ReadCurrentUser(IStream *pStm);
   void *ReadRecord( RecordHeader& rh );
   BOOL Parse();
   IStream *GetDocStream();
   BOOL DoesClientRead( psrType type )
   {
      return FALSE;
   }
   void ReleaseRecord( RecordHeader& rh, void* diskRecBuf );
   DWord ParseForSlideLists();
   void AddSlideToList( psrReference refToAdd );
   BOOL StartParse( DWord offset );
   BOOL FillBufferWithText();
   BOOL FindNextSlide( DWord& offset );
private:
   PSR_CurrentUserAtom m_currentUser;
   IStream * m_pDocStream;
   IStorage * m_pPowerPointStg;
   BOOL m_isPP;
   ParseContext* m_pParseContexts;
   WCHAR* m_pCurText;
   unsigned long m_curTextPos;
   unsigned long m_curTextLength;
   PSR_UserEditAtom* m_pLastUserEdit;
   PPSPersistDirectory* m_pPersistDirectory;
   SlideListChunk* m_pFirstChunk;
   int m_curSlideNum;
   WCHAR* m_pClientBuf;
   unsigned long m_clientBufSize;
   unsigned long m_clientBufPos;
   ULONG* m_pSizeRet;
};

FileReader::FileReader(IStorage *pStg) :
m_pPowerPointStg(pStg),
m_isPP(FALSE),
m_pParseContexts(NULL),
m_curTextPos(0),
m_pLastUserEdit( NULL ),
m_pPersistDirectory( NULL ),
m_pDocStream( NULL ),
m_pFirstChunk( NULL ),
m_curSlideNum(0),
m_pCurText( NULL ),
m_pClientBuf( NULL ),
m_clientBufSize( 0 ),
m_clientBufPos( 0 )
{
   IStream *pStm = NULL;
   m_pPowerPointStg->AddRef();
   HRESULT hr = pStg->OpenStream( CURRENT_USER_STREAM, NULL, STGM_READ | STGM_DIRECT | STGM_SHARE_EXCLUSIVE, NULL, &pStm );
   if ( SUCCEEDED(hr) && ReadCurrentUser(pStm) )
      m_isPP = TRUE;
   pStm->Release();
}

FileReader::~FileReader()
{
   m_pPowerPointStg->Release();
}

BOOL FileReader::FillBufferWithText()
{
   unsigned long amtToCopy = min( (m_curTextLength - m_curTextPos), (m_clientBufSize - m_clientBufPos) );
   unsigned long loop = amtToCopy;
   while ( loop-- )
      m_pClientBuf[ m_clientBufPos++ ] = m_pCurText[ m_curTextPos++ ];
   if ( m_curTextPos == m_curTextLength )
   {
      delete [] m_pCurText;
      m_pCurText = NULL;
      m_curTextPos = 0;
      m_curTextLength = 0;
   }
   *m_pSizeRet += amtToCopy;
   return(m_clientBufSize == m_clientBufPos); // If client's buffer is full return TRUE.
}

void FileReader::AddSlideToList( psrReference refToAdd )
{
   if ( m_pFirstChunk == NULL )
      m_pFirstChunk = new SlideListChunk(NULL, refToAdd);
   else
   {
      if ( m_pFirstChunk->numInChunk+1 > SLIDELISTCHUNKSIZE )
         m_pFirstChunk = new SlideListChunk(m_pFirstChunk, refToAdd);
      else
      {
         m_pFirstChunk->refs[m_pFirstChunk->numInChunk] = refToAdd;
         m_pFirstChunk->numInChunk++;
      }
   }
}

IStream *FileReader::GetDocStream()
{
   if ( m_pDocStream == NULL )
   {
      if ( !m_isPP )
         return NULL;
      HRESULT hr = m_pPowerPointStg->OpenStream( DOCUMENT_STREAM, NULL, STGM_READ | STGM_DIRECT | STGM_SHARE_EXCLUSIVE, NULL, &m_pDocStream );
      if (FAILED(hr))
      {
         fprintf(stderr,"Error (%d) opening PowerPoint Document Stream.\n",(int)hr);
         return NULL;
      }
   }
   return m_pDocStream;
}

BOOL FileReader::ReadCurrentUser(IStream *pStm)
{
   ULONG nRd=0;
   RecordHeader rh;
   BOOL isPP = FALSE;
   if ( SUCCEEDED( pStm->Read(&rh, sizeof(rh), &nRd) ) )
   {
      if ( SUCCEEDED( pStm->Read(&m_currentUser, sizeof(PSR_CurrentUserAtom), &nRd) ) )
      {
         if ( nRd != sizeof(PSR_CurrentUserAtom) )
            return FALSE;
      }
      isPP = ( m_currentUser.size == sizeof( m_currentUser ) )&&
             ( m_currentUser.magic == HEADER_MAGIC_NUM )&&
             ( m_currentUser.lenUserName <= 255 );
   }
   return isPP;
}

class PPSDirEntry
{
   PPSDirEntry()
   : m_pNext( NULL ), m_pOffsets( NULL ), m_tableSize( 0 )
   {
   }
   PPSDirEntry* m_pNext;
   DWord* m_pOffsets;
   DWord m_tableSize;
public:
   ~PPSDirEntry()
   {
      delete m_pOffsets; m_pOffsets = NULL;
   }
   friend class PPSPersistDirectory;
}; 

// class PPSDirEntry
class PPSPersistDirectory
{
public:
   PPSPersistDirectory();
   ~PPSPersistDirectory();
   void AddEntry( DWord cOffsets, DWord* pOffsets );
   DWord GetPersistObjStreamPos( DWord ref );
   DWord NumberOfAlreadySavedPersists();
private:
   PPSDirEntry* m_pFirstDirEntry;
};

PPSPersistDirectory::PPSPersistDirectory() : m_pFirstDirEntry( NULL )
{
}

PPSPersistDirectory::~PPSPersistDirectory()
{
   while ( m_pFirstDirEntry )
   {
      PPSDirEntry* pDirEntry = m_pFirstDirEntry;
      m_pFirstDirEntry = m_pFirstDirEntry->m_pNext;
      delete pDirEntry;
   }
}

void PPSPersistDirectory::AddEntry( DWord cOffsets, DWord* pOffsets )
{
   PPSDirEntry* pDirEntry = new PPSDirEntry();
   pDirEntry->m_tableSize = cOffsets;
   pDirEntry->m_pOffsets = new DWord[cOffsets];
   memcpy( pDirEntry->m_pOffsets, pOffsets, cOffsets * sizeof( DWord ) );
// append to the end of the entry list
   PPSDirEntry** ppDirEntry = &m_pFirstDirEntry;
   while ( NULL != *ppDirEntry )
      ppDirEntry = &(*ppDirEntry)->m_pNext;
   *ppDirEntry = pDirEntry;
}

DWord PPSPersistDirectory::GetPersistObjStreamPos( DWord ref )
{
   PPSDirEntry* pEntry = m_pFirstDirEntry;
   while ( pEntry )
   {
      DWord* pOffsets = pEntry->m_pOffsets;
      while ( (DWord)( (char*)pOffsets - (char*)pEntry->m_pOffsets ) < pEntry->m_tableSize * sizeof( DWord ) )
      {
         DWord nRefs = pOffsets[0] >> 20;
         DWord base = pOffsets[0] & 0xFFFFF; // 1-based
         if ( ( base <= ref )&&( ref < base + nRefs ) )
            return pOffsets[ 1 + ref - base ];
         pOffsets += nRefs + 1;
      }
      pEntry = pEntry->m_pNext;
   }
   return(DWord) -1;
}

DWord PPSPersistDirectory::NumberOfAlreadySavedPersists()
{
   DWord count = 0;
   PPSDirEntry* pEntry = m_pFirstDirEntry;
   while ( pEntry )
   {
      DWord* pOffsets = pEntry->m_pOffsets;
      while ( (DWord)( pEntry->m_pOffsets - pOffsets ) < pEntry->m_tableSize * sizeof( DWord ) )
      {
         DWord nRefs = pOffsets[0] >> 20;
         count += nRefs;
         pOffsets += nRefs + 1;
      }
      pEntry = pEntry->m_pNext;
   }
   return count;
}

void FileReader::PPSReadUserEditAtom( DWord offset, PSR_UserEditAtom& userEdit )
{
   LARGE_INTEGER li;
   li.LowPart = offset;
   li.HighPart = 0;
   GetDocStream()->Seek(li,STREAM_SEEK_SET, NULL);
   RecordHeader rh;
   GetDocStream()->Read(&rh, sizeof(rh), NULL);
   Assert( rh.recType == PST_UserEditAtom );
   Assert( rh.recLen == sizeof( PSR_UserEditAtom ) );
   li.LowPart = offset;
   GetDocStream()->Read(&userEdit, sizeof(userEdit), NULL);
}

void *FileReader::ReadRecord( RecordHeader& rh )
// Return values:
// NULL and rh.recVer == PSFLAG_CONTAINER: no record was read in.
// record header indicated start of container.
// NULL and rh.recVer != PSFLAG_CONTAINER: client must read in record.
{
   IStream *pStm = GetDocStream();
// read record header, verify
   pStm->Read(&rh, sizeof(rh), NULL); //AR: Check Error
// if client will read, do not read in record
   if ( DoesClientRead( rh.recType ) )
      return NULL;
// If container, return NULL
   if (rh.recVer == PSFLAG_CONTAINER)
      return NULL;
// Allocate buffer for disk record. Client must call ReleaseRecord() or
// pass the atom up to CObject::ConstructContents() which will
// then release it.
   void* buffer = new char[rh.recLen];
// read in record
   pStm->Read(buffer, rh.recLen, NULL);
// NOTE: ByteSwapping & versioning not done by this simple reader.
   return(buffer);
}

void FileReader::ReleaseRecord( RecordHeader& rh, void* diskRecBuf )
{
   if (rh.recType && rh.recVer!=PSFLAG_CONTAINER)
      delete [] (char*)diskRecBuf;
   rh.recType = 0; // consume the record so that record doesn't
// get processed again.
}

void FileReader::ReadPersistDirectory()
{
   if ( NULL != m_pLastUserEdit )
      return; // already read
   PSR_UserEditAtom userEdit;
   DWord offsetToEdit = m_currentUser.offsetToCurrentEdit;
   while ( 0 < offsetToEdit )
   {
      PPSReadUserEditAtom( offsetToEdit, userEdit );
      if ( NULL == m_pLastUserEdit )
      {
         m_pPersistDirectory = new PPSPersistDirectory();
         m_pLastUserEdit = new PSR_UserEditAtom;
         *m_pLastUserEdit = userEdit;
      }
      LARGE_INTEGER li;
      li.LowPart = userEdit.offsetPersistDirectory;
      li.HighPart = 0;
      GetDocStream()->Seek(li,STREAM_SEEK_SET, NULL); // AR: check that seek succeeded.
      RecordHeader rh;
      DWord *pDiskRecord = (DWord*) ReadRecord(rh);
      Assert( PST_PersistPtrIncrementalBlock == rh.recType );
      m_pPersistDirectory->AddEntry( rh.recLen / sizeof( DWord ), pDiskRecord );
      ReleaseRecord( rh, pDiskRecord );
      offsetToEdit = userEdit.offsetLastEdit;
   }
}

// PPStorage::ReadPersistDirectory
void FileReader::ReadSlideList()
{
   Assert( m_pLastUserEdit != NULL );
   DWord offsetToDoc = m_pPersistDirectory->GetPersistObjStreamPos( m_pLastUserEdit->documentRef );
   LARGE_INTEGER li;
   li.LowPart = offsetToDoc;
   li.HighPart = 0;
   GetDocStream()->Seek(li,STREAM_SEEK_SET, NULL);
   ParseForSlideLists();
}

DWord FileReader::ParseForSlideLists()
{
   IStream *pStm = GetDocStream();
   RecordHeader rh;
   DWord nRd=0;
// Stack based parsing for SlideLists
   pStm->Read(&rh, sizeof(rh), &nRd);
   if ( ( rh.recVer != PSFLAG_CONTAINER ) && ( (rh.recVer & 0x0F)!=0x0F ) )
   {
      if ( rh.recType == PST_SlidePersistAtom )
      {
         PSR_SlidePersistAtom spa;
         Assert( sizeof(spa) == rh.recLen );
         pStm->Read(&spa, sizeof(spa), &nRd);
         AddSlideToList( spa.psrReference );
      }
      else
      {
         LARGE_INTEGER li;
         li.LowPart = rh.recLen;
         li.HighPart = 0;
         pStm->Seek(li,STREAM_SEEK_CUR, NULL);
      }
      nRd += rh.recLen;
   }
   else
   {
      DWord nCur = 0;
      while ( nCur < rh.recLen )
      {
         nCur += ParseForSlideLists();
      }
      nRd += nCur;
   }
   return nRd;
}

BOOL FileReader::ReadText( WCHAR *pBuff, ULONG size, ULONG *pSizeRet )
{
   DWord offset;
   *pSizeRet = 0;
   m_pSizeRet = pSizeRet;
   m_pClientBuf = pBuff;
   m_clientBufSize = size;
   m_clientBufPos = 0;
   for ( ;; )
   {
      if ( ( m_pParseContexts == NULL ) )
      {
         if ( FindNextSlide(offset) )
         {
            if ( StartParse( offset ) )
               return TRUE;
         }
         else
            return FALSE; // DONE parsing, no more slides
      }
      else
      {
         if ( m_pClientBuf )
         {
            if ( FillBufferWithText() ) // Use existing text first.
               return TRUE;
         }
         if ( Parse() ) // restart parse where we left off.
            return TRUE;
      }
   }
}

BOOL FileReader::StartParse( DWord offset )
{
   LARGE_INTEGER li;
   li.LowPart = offset;
   li.HighPart = 0;
   GetDocStream()->Seek(li,STREAM_SEEK_SET, NULL);
   m_pParseContexts = new ParseContext( NULL );
   GetDocStream()->Read(&m_pParseContexts->m_rh, sizeof(RecordHeader), NULL);
   return Parse();
}

BOOL FileReader::Parse()
{
   IStream *pStm = GetDocStream();
   RecordHeader rh;
   DWord nRd=0;
   Assert( m_pParseContexts );
// Restarting a parse might complete a container so we test this initially.
   if ( m_pParseContexts->m_nCur >= m_pParseContexts->m_rh.recLen )
   {
      Assert( m_pParseContexts->m_nCur == m_pParseContexts->m_rh.recLen );
      ParseContext* pParseContext = m_pParseContexts;
      m_pParseContexts = m_pParseContexts->m_pNext;
      delete pParseContext;
   }
   do
   {
      pStm->Read(&rh, sizeof(RecordHeader), NULL);
      if ( ( rh.recVer != PSFLAG_CONTAINER ) && ( (rh.recVer & 0x0F)!=0x0F ) )
      {
         if ( rh.recType == PST_TextCharsAtom )
         {
            m_curTextPos = 0;
            m_curTextLength = rh.recLen/2;
            Assert( m_pCurText == NULL );
            m_pCurText = new WCHAR[rh.recLen/2];
            pStm->Read(m_pCurText, rh.recLen, &nRd);
            wprintf( L"-%s-\n", m_pCurText );
            if ( FillBufferWithText() )
               return TRUE; // Stop parsing if buffer is full, and return control to client
         }
         else if ( rh.recType == PST_TextBytesAtom )
         {
            Assert( m_pCurText == NULL );
            m_curTextPos = 0;
            m_curTextLength = rh.recLen;
            m_pCurText = new WCHAR[rh.recLen];
            pStm->Read(m_pCurText, rh.recLen, &nRd);
            char *pHack = (char *) m_pCurText;
            unsigned int back2 = rh.recLen*2-1;
            unsigned int back1 = rh.recLen-1;
            for (unsigned int i=0;i<rh.recLen;i++)
            {
               pHack[back2-1] = pHack[back1];
               pHack[back2] = 0;
               back2 -=2;
               back1--;
            }
            if ( FillBufferWithText() )
               return TRUE; // Stop parsing if buffer is full, and return control to client
         }
         else
         {
            LARGE_INTEGER li;
            ULARGE_INTEGER ul;
            li.LowPart = rh.recLen;
            li.HighPart = 0;
            pStm->Seek(li,STREAM_SEEK_CUR,&ul);
         }
         m_pParseContexts->m_nCur += rh.recLen;
         m_pParseContexts->m_nCur += sizeof( RecordHeader ); // Atom rh's add towards containing container's size.
      }
      else
      {
         m_pParseContexts = new ParseContext( m_pParseContexts );
         m_pParseContexts->m_rh = rh;
      }
      if ( m_pParseContexts->m_nCur >= m_pParseContexts->m_rh.recLen )
      {
         Assert( m_pParseContexts->m_nCur == m_pParseContexts->m_rh.recLen );
         ParseContext* pParseContext = m_pParseContexts;
         m_pParseContexts = m_pParseContexts->m_pNext;
         delete pParseContext;
      }
   } while ( m_pParseContexts && ( m_pParseContexts->m_nCur < m_pParseContexts->m_rh.recLen ) );
   return FALSE;
}

BOOL FileReader::FindNextSlide( DWord& offset )
{
   if ( m_curSlideNum == 0 )
   {
      Assert( m_pLastUserEdit != NULL );
      offset = m_pPersistDirectory->GetPersistObjStreamPos( m_pLastUserEdit->documentRef );
      m_curSlideNum++;
      return TRUE;
   }
   else
   {
      uint4 curSlideNum = m_curSlideNum++;
      SlideListChunk *pCur = m_pFirstChunk;
      while ( pCur && ( curSlideNum > pCur->numInChunk ) )
      {
         curSlideNum -= pCur->numInChunk;
         pCur = pCur->pNext;
      }
      if ( pCur == NULL )
         return FALSE;
      offset = m_pPersistDirectory->GetPersistObjStreamPos( pCur->refs[curSlideNum-1] );
      return TRUE;
   }
}

static BOOL ReadText( void** ppContext, IStorage* pStgFrom, WCHAR* buffer, unsigned long bufferSize, unsigned long* pSizeRet )
{
   FileReader* pFI = NULL;
   if ( *ppContext == NULL )
   {
      pFI = new FileReader( pStgFrom );
      *ppContext = pFI;
      if ( !pFI->IsPowerPoint() )
      {
         delete pFI;
         *pSizeRet = 0;
         return FALSE;
      }
      pFI->ReadPersistDirectory();
      pFI->ReadSlideList();
   }
   else
   {
      pFI = (FileReader *)*ppContext;
   }
   BOOL bRet = pFI->ReadText(buffer, bufferSize, pSizeRet);
   if ( !bRet )
   {
      delete pFI;
      *ppContext = NULL;
   }
   return bRet;
}

void main(int argc, char **argv)
{
   OLECHAR wc[256];
   HRESULT hr;
   IStorage *pStgFrom = NULL;
   if (argc < 2)
   {
      fprintf(stderr,"Usage dblock <file to be read>\n");
      exit(0);
   }
   MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, argv[1], -1, wc, 255);
   hr = StgOpenStorage(wc, NULL, STGM_READ | STGM_DIRECT |
                       STGM_SHARE_DENY_WRITE, NULL, 0, &pStgFrom);
   if (FAILED(hr))
   {
      fprintf(stderr,"Error (%d) opening docfile: %s\n",(int)hr,argv[1]);
   }
   else
   {
      WCHAR wcBuf[6];
      ULONG sizeUsed;
      BOOL fContinue = TRUE;
      void *pContext = NULL;
      while ( fContinue )
      {
         fContinue = ReadText( &pContext, pStgFrom, wcBuf, 5, &sizeUsed );
         wcBuf[sizeUsed] = 0;
         wprintf(L"-%s-\n", wcBuf);
      }
   }
}