debug_debug.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/debug_debug.h $
// $Author: mhoffe $
// $Revision: #1 $
// $DateTime: 2003/07/03 11:55:26 $
//
// ©2003 Electronic Arts
//
// main Debug object (singleton)
#ifdef _MSC_VER
#  pragma once
#endif
#ifndef DEBUG_DEBUG_H // Include guard
#define DEBUG_DEBUG_H
 
// this makes sure that whenever this header is included
// the accompanying OBJ file is linked in as well
#pragma comment(linker,"/include:___DebugIncludeInLink1")

class Debug
{
  // necessary because all debug commands operate directly on this class
  friend class DebugCmdInterfaceDebug;
 
  // necessary because exception handler needs direct access
  friend class DebugExceptionhandler;
 
public:
  enum
  {
    MAX_CHECK_HITS  =   20
  };

  typedef bool (*HResultTranslator)(Debug &debug, long hresult, void *user);

  class MemDump
  {
    // necessary because Debug needs access to the following private members
    friend Debug; 
    
    const unsigned char *m_startPtr;  
    unsigned m_numItems;              
    unsigned m_bytePerItem;           
    bool m_absAddr;                   
    bool m_withChars;                 
    
    // constructor is private on purpose so that nobody can 
    // create instances of this class except the static functions
    // provided herein
    MemDump(const void *ptr, unsigned num, unsigned bpi, bool absAddr, bool withChars):
      m_startPtr((const unsigned char *)ptr), m_numItems(num),
      m_bytePerItem(bpi), m_absAddr(absAddr), m_withChars(withChars) {}
  public:

    static MemDump Raw(const void *startPtr, unsigned numItems, unsigned bytePerItem=1)
    {
      return MemDump(startPtr,numItems,bytePerItem,true,false);
    }

    static MemDump RawRel(const void *startPtr, unsigned numItems, unsigned bytePerItem=1)
    {
      return MemDump(startPtr,numItems,bytePerItem,false,false);
    }

    static MemDump Char(const void *startPtr, unsigned numItems, unsigned bytePerItem=1)
    {
      return MemDump(startPtr,numItems,bytePerItem,true,true);
    }

    static MemDump CharRel(const void *startPtr, unsigned numItems, unsigned bytePerItem=1)
    {
      return MemDump(startPtr,numItems,bytePerItem,false,true);
    }
  };

  class HResult
  {
    // necessary because Debug needs access to the following private members
    friend Debug; 
    
    long m_hresult;                   
    
  public:

    explicit HResult(long hresult): m_hresult(hresult) {}
  };

  class LogDescription
  {
    // sorry, no copies or assignments
    LogDescription(const LogDescription&);
    LogDescription& operator=(const LogDescription&);
 
  public:

    LogDescription(const char *fileOrGroup, const char *description);
  };

  class Hex {};
  
  Debug& operator<<(Hex &)
  {
    SetPrefixAndRadix("0x",16);
    return *this;
  }

  class Dec {};

  Debug& operator<<(Dec &)
  {
    SetPrefixAndRadix("",10);
    return *this;
  }

  class Bin {};

  Debug& operator<<(Bin &)
  {
    SetPrefixAndRadix("%",2);
    return *this;
  }

  class Width
  {
    // necessary because Debug needs access to the following private members
    friend Debug; 
 
    int m_width;  
 
  public:
    explicit Width(int width): m_width(width) {}
  };

  Debug& operator<<(Width &w)
  {
    m_width=w.m_width;
    return *this;
  }

  class FillChar
  {
    // necessary because Debug needs access to the following private members
    friend Debug; 
 
    char m_fill;  
 
  public:
    explicit FillChar(char ch=' '): m_fill(ch) {}
  };

  Debug& operator<<(FillChar &c)
  {
    m_fillChar=c.m_fill;
    return *this;
  }

  class RepeatChar
  {
    // necessary because Debug needs access to the following private members
    friend Debug; 
 
    char m_char;  
    int m_count;  
 
  public:
    explicit RepeatChar(char ch, int count): m_char(ch), m_count(count) {}
  };

  Debug& operator<<(RepeatChar &c);

  class Format
  {
    // necessary because Debug needs access to the following private members
    friend Debug; 
 
    // no CC, AOp
    Format(const Format &);
    Format& operator=(const Format&);
 
    char m_buffer[512]; 
 
  public:
    explicit Format(const char *format, ...);
  };

  Debug& operator<<(const Format &f)
  {
    operator<<(f.m_buffer);
    return *this;
  }
  
  // this is necessary because LogDescription needs to call AddLogGroup
  friend class LogDescription;
  
  ~Debug();

  static void InstallExceptionHandler(void);

  static bool SkipNext(void);

  static Debug &AssertBegin(const char *file, int line, const char *expr);

  bool AssertDone(void);

  static Debug &CheckBegin(const char *file, int line, const char *expr);

  bool CheckDone(void);

  static Debug &LogBegin(const char *fileOrGroup);

  bool LogDone(void);

  static Debug &CrashBegin(const char *file, int line);

  bool CrashDone(bool die);

  Debug& operator<<(const char *str);

  void SetPrefixAndRadix(const char *prefix, int radix);

  Debug& operator<<(int val);

  Debug& operator<<(unsigned val);

  Debug& operator<<(long val);

  Debug& operator<<(unsigned long val);

  Debug& operator<<(bool val);

  Debug& operator<<(float val);

  Debug& operator<<(double val);

  Debug& operator<<(short val);

  Debug& operator<<(unsigned short val);

  Debug& operator<<(__int64 val);

  Debug& operator<<(unsigned __int64 val);

  Debug& operator<<(const void *ptr);

  Debug& operator<<(const MemDump &dump);

  Debug& operator<<(HResult hres);

  static bool IsLogEnabled(const char *fileOrGroup);

  static void AddHResultTranslator(unsigned prio, HResultTranslator func, void *user=0);

  static void RemoveHResultTranslator(HResultTranslator func, void *user=0);

  static bool AddIOFactory(const char *io_id, const char *descr, 
                           DebugIOInterface* (*func)(void));

  static bool AddCommands(const char *cmdgroup, DebugCmdInterface *cmdif);

  static void RemoveCommands(DebugCmdInterface *cmdif);

  static void Command(const char *cmd);

  static void Update(void);

  static bool SimpleMatch(const char *str, const char *pattern);

  static void SetBuildInfo(const char *version,
                           const char *internalVersion,
                           const char *buildDate);

  void WriteBuildInfo(void);
 
private:
  // no assignment, no copy constructor
  Debug(const Debug&);
  Debug& operator=(const Debug&);

  Debug(void);

  static void PreStaticInit(void);

  static void PostStaticInit(void);

  static void StaticExit(void);

  static Debug Instance;

  static void *PreStatic;    

  static void *PostStatic;    

  struct HResultTranslatorEntry
  {
    unsigned prio;

    HResultTranslator func;

    void *user;
  };

  HResultTranslatorEntry *hrTranslators;

  unsigned numHrTranslators;

  struct IOFactoryListEntry
  {
    IOFactoryListEntry *next;

    const char *ioID;

    const char *descr;

    DebugIOInterface* (*factory)(void);

    DebugIOInterface *io;

    char *input;

    unsigned inputUsed;

    unsigned inputAlloc;
  };

  IOFactoryListEntry *firstIOFactory;

  struct CmdInterfaceListEntry
  {
    CmdInterfaceListEntry *next;

    const char *group;

    DebugCmdInterface *cmdif;
  };

  CmdInterfaceListEntry *firstCmdGroup;

  static unsigned curStackFrame;

  enum
  {
    FrameTypeAssert = 0x00000001,

    FrameTypeCheck  = 0x00000002,

    FrameTypeLog    = 0x00000004
  };

  enum FrameStatus
  {
    Unknown = 0,

    Skip,

    NoSkip
  };

  struct FrameHashEntry
  {
    FrameHashEntry *next;

    unsigned frameAddr;

    unsigned frameType;

    const char *fileOrGroup;

    int line;

    int hits;

    FrameStatus status;
  };

  enum { FRAME_HASH_SIZE = 10007 };

  FrameHashEntry *frameHash[FRAME_HASH_SIZE];

  enum { FRAME_HASH_ALLOC_COUNT = 100 };

  FrameHashEntry *nextUnusedFrameHash;

  unsigned numAvailableFrameHash;

  __forceinline FrameHashEntry *LookupFrame(unsigned addr)
  {
    for (FrameHashEntry *e=frameHash[addr%FRAME_HASH_SIZE];e;e=e->next)
      if (e->frameAddr==addr)
        return e;
    return 0;
  }

  FrameHashEntry *AddFrameEntry(unsigned addr, unsigned type,
                                const char *fileOrGroup, int line);

  void UpdateFrameStatus(FrameHashEntry &entry);

  FrameHashEntry *GetFrameEntry(unsigned addr, unsigned type,
                                const char *fileOrGroup, int line)
  {
    FrameHashEntry *e=LookupFrame(addr);
    if (!e)
      e=AddFrameEntry(addr,type,fileOrGroup,line);
    if (e->status==Unknown)
      UpdateFrameStatus(*e);
    return e;
  }

  struct KnownLogGroupList
  {
    KnownLogGroupList *next;

    char *nameGroup;

    const char *descr;
  };

  KnownLogGroupList *firstLogGroup;

  const char *AddLogGroup(const char *fileOrGroup, const char *descr);

  struct
  {
    char *buffer;

    unsigned used;

    unsigned alloc;

    bool lastWasCR;
  } ioBuffer[DebugIOInterface::StringType::MAX];

  DebugIOInterface::StringType curType;

  char curSource[256];

  int disableAssertsEtc;

  void StartOutput(DebugIOInterface::StringType type, const char *fmt, ...);

  void AddOutput(const char *str, unsigned len);

  void FlushOutput(bool defaultLog=true);

  FrameHashEntry *curFrameEntry;

  struct PatternListEntry
  {
    PatternListEntry *next;

    unsigned frameTypes;

    bool isActive;

    char *pattern;
  };

  PatternListEntry *firstPatternEntry;

  PatternListEntry *lastPatternEntry;

  void AddPatternEntry(unsigned types, bool isActive, const char *pattern);

  void ExecCommand(const char *cmdstart, const char *cmdend);

  bool IsWindowed(void);

  char curCommandGroup[100];

  bool alwaysFlush;

  bool timeStamp;

  DebugStackwalk m_stackWalk;

  char m_prefix[16];

  int m_radix;

  char m_version[64];

  char m_intVersion[64];

  char m_buildDate[64];

  int m_width;

  char m_fillChar;
  
  char m_isWindowed;
};


const char *DebugGetDefaultCommands(void);

 
#endif // DEBUG_DEBUG_H