internal_io.h

Go to the documentation of this file.

/*
**  Command & Conquer Generals Zero Hour(tm)
**  Copyright 2025 Electronic Arts Inc.
**
**  This program is free software: you can redistribute it and/or modify
**  it under the terms of the GNU General Public License as published by
**  the Free Software Foundation, either version 3 of the License, or
**  (at your option) any later version.
**
**  This program is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// $File: //depot/GeneralsMD/Staging/code/Libraries/Source/debug/internal_io.h $
// $Author: mhoffe $
// $Revision: #1 $
// $DateTime: 2003/07/03 11:55:26 $
//
// ©2003 Electronic Arts
//
// Internal header: I/O classes
#ifdef _MSC_VER
#  pragma once
#endif
#ifndef INTERNAL_IO_H // Include guard
#define INTERNAL_IO_H

class DebugIOCon: public DebugIOInterface
{
  bool m_allocatedConsole;    

  char m_input[256];

  unsigned m_inputUsed;

  unsigned m_inputRead;
  
public:
  explicit DebugIOCon(void);
  virtual ~DebugIOCon();
  virtual int Read(char *buf, int maxchar);
  virtual void Write(StringType type, const char *src, const char *str);
  virtual void EmergencyFlush(void) {}
  virtual void Execute(class Debug& dbg, const char *cmd, bool structuredCmd,
                       unsigned argn, const char * const * argv);
  static DebugIOInterface *Create(void);
  virtual void Delete(void);
};

class DebugIOFlat: public DebugIOInterface
{
  class OutputStream
  {
    OutputStream(const OutputStream&);
    OutputStream& operator=(const OutputStream&);

    char *m_fileName;

    HANDLE m_fileHandle;

    bool m_limitedFileSize;

    char *m_buffer;

    unsigned m_bufferUsed;

    unsigned m_bufferSize;

    unsigned m_nextChar;
 
    // these are private so that we are forced to use Create/Destroy
    OutputStream(const char *filename, unsigned maxSize);
    ~OutputStream();

    void InternalWrite(const char *src, unsigned len);
    
  public:

    static OutputStream *Create(const char *filename, unsigned maxSize);

    void Delete(const char *path=NULL);

    const char *GetFilename(void) { return m_fileName; }

    void Write(const char *src);

    void Flush(void);
  };

  struct SplitListEntry
  {
    SplitListEntry *next;

    unsigned stringTypes;

    char items[256];

    char name[256];
    
    OutputStream *stream;
  };

  struct StreamListEntry
  {
    StreamListEntry *next;

    OutputStream *stream;
  };

  SplitListEntry *m_firstSplit;

  SplitListEntry **m_lastSplitPtr;

  StreamListEntry *m_firstStream;

  StreamListEntry **m_lastStreamPtr;

  char m_baseFilename[256];

  char m_copyDir[256];

  static void ExpandMagic(const char *src, const char *splitName, char *buf);
 
public:
  explicit DebugIOFlat(void);
  virtual ~DebugIOFlat();
  virtual int Read(char *buf, int maxchar) { return 0; }
  virtual void Write(StringType type, const char *src, const char *str);
  virtual void EmergencyFlush(void);
  virtual void Execute(class Debug& dbg, const char *cmd, bool structuredCmd,
                       unsigned argn, const char * const * argv);
  static DebugIOInterface *Create(void);
  virtual void Delete(void);
};

class DebugIONet: public DebugIOInterface
{
  HANDLE m_pipe;
  
public:
  explicit DebugIONet(void);
  virtual ~DebugIONet();
  virtual int Read(char *buf, int maxchar);
  virtual void Write(StringType type, const char *src, const char *str);
  virtual void EmergencyFlush(void);
  virtual void Execute(class Debug& dbg, const char *cmd, bool structuredCmd,
                       unsigned argn, const char * const * argv);
  static DebugIOInterface *Create(void);
  virtual void Delete(void);
};

class DebugIOOds: public DebugIOInterface
{
public:
  explicit DebugIOOds(void) {}
  virtual int Read(char *buf, int maxchar) { return 0; }
  virtual void Write(StringType type, const char *src, const char *str);
  virtual void EmergencyFlush(void) {}
  virtual void Execute(class Debug& dbg, const char *cmd, bool structuredCmd,
                       unsigned argn, const char * const * argv) {}
  static DebugIOInterface *Create(void);
  virtual void Delete(void);
};
 
#endif // INTERNAL_IO_H