URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [tui/] [tuiData.c] - Blame information for rev 1774

Go to most recent revision | Details | Compare with Previous | View Log

/*
   ** tuiData.c
   **    This module contains functions for manipulating the data
   **    structures used by the TUI
 */
 
#include "defs.h"
#include "tui.h"
#include "tuiData.h"
 
/****************************
** GLOBAL DECLARATIONS
****************************/
TuiWinInfoPtr winList[MAX_MAJOR_WINDOWS];
 
/***************************
** Private Definitions
****************************/
#define FILE_WIDTH   30
#define PROC_WIDTH   40
#define LINE_WIDTH   4
#define PC_WIDTH     8
 
/***************************
** Private data
****************************/
static char *_tuiNullStr = TUI_NULL_STR;
static char *_tuiBlankStr = "   ";
static char *_tuiLocationStr = "  >";
static char *_tuiBreakStr = " * ";
static char *_tuiBreakLocationStr = " *>";
static TuiLayoutType _currentLayout = UNDEFINED_LAYOUT;
static int _termHeight, _termWidth;
static int _historyLimit = DEFAULT_HISTORY_COUNT;
static TuiGenWinInfo _locator;
static TuiGenWinInfo _execInfo[2];
static TuiWinInfoPtr _srcWinList[2];
static TuiList _sourceWindows =
{(OpaqueList) _srcWinList, 0};
static int _defaultTabLen = DEFAULT_TAB_LEN;
static TuiWinInfoPtr _winWithFocus = (TuiWinInfoPtr) NULL;
static TuiLayoutDef _layoutDef =
{SRC_WIN,                       /* displayMode */
 FALSE,                         /* split */
 TUI_UNDEFINED_REGS,            /* regsDisplayType */
 TUI_SFLOAT_REGS};              /* floatRegsDisplayType */
static int _winResized = FALSE;
 
 
/*********************************
** Static function forward decls
**********************************/
static void freeContent PARAMS ((TuiWinContent, int, TuiWinType));
static void freeContentElements PARAMS ((TuiWinContent, int, TuiWinType));
 
 
 
/*********************************
** PUBLIC FUNCTIONS
**********************************/
 
/******************************************
** ACCESSORS & MUTATORS FOR PRIVATE DATA
******************************************/
 
/*
   ** tuiWinResized().
   **        Answer a whether the terminal window has been resized or not
 */
int
#ifdef __STDC__
tuiWinResized (void)
#else
tuiWinResized ()
#endif
{
  return _winResized;
}                               /* tuiWinResized */
 
 
/*
   ** tuiSetWinResized().
   **        Set a whether the terminal window has been resized or not
 */
void
#ifdef __STDC__
tuiSetWinResizedTo (
                     int resized)
#else
tuiSetWinResizedTo (resized)
     int resized;
#endif
{
  _winResized = resized;
 
  return;
}                               /* tuiSetWinResizedTo */
 
 
/*
   ** tuiLayoutDef().
   **        Answer a pointer to the current layout definition
 */
TuiLayoutDefPtr
#ifdef __STDC__
tuiLayoutDef (void)
#else
tuiLayoutDef ()
#endif
{
  return &_layoutDef;
}                               /* tuiLayoutDef */
 
 
/*
   ** tuiWinWithFocus().
   **        Answer the window with the logical focus
 */
TuiWinInfoPtr
#ifdef __STDC__
tuiWinWithFocus (void)
#else
tuiWinWithFocus ()
#endif
{
  return _winWithFocus;
}                               /* tuiWinWithFocus */
 
 
/*
   ** tuiSetWinWithFocus().
   **        Set the window that has the logical focus
 */
void
#ifdef __STDC__
tuiSetWinWithFocus (
                     TuiWinInfoPtr winInfo)
#else
tuiSetWinWithFocus (winInfo)
     TuiWinInfoPtr winInfo;
#endif
{
  _winWithFocus = winInfo;
 
  return;
}                               /* tuiSetWinWithFocus */
 
 
/*
   ** tuiDefaultTabLen().
   **        Answer the length in chars, of tabs
 */
int
#ifdef __STDC__
tuiDefaultTabLen (void)
#else
tuiDefaultTabLen ()
#endif
{
  return _defaultTabLen;
}                               /* tuiDefaultTabLen */
 
 
/*
   ** tuiSetDefaultTabLen().
   **        Set the length in chars, of tabs
 */
void
#ifdef __STDC__
tuiSetDefaultTabLen (
                      int len)
#else
tuiSetDefaultTabLen (len)
     int len;
#endif
{
  _defaultTabLen = len;
 
  return;
}                               /* tuiSetDefaultTabLen */
 
 
/*
   ** currentSourceWin()
   **        Accessor for the current source window.  Usually there is only
   **        one source window (either source or disassembly), but both can
   **        be displayed at the same time.
 */
TuiListPtr
#ifdef __STDC__
sourceWindows (void)
#else
sourceWindows ()
#endif
{
  return &_sourceWindows;
}                               /* currentSourceWindows */
 
 
/*
   ** clearSourceWindows()
   **        Clear the list of source windows.  Usually there is only one
   **        source window (either source or disassembly), but both can be
   **        displayed at the same time.
 */
void
#ifdef __STDC__
clearSourceWindows (void)
#else
clearSourceWindows ()
#endif
{
  _sourceWindows.list[0] = (Opaque) NULL;
  _sourceWindows.list[1] = (Opaque) NULL;
  _sourceWindows.count = 0;
 
  return;
}                               /* currentSourceWindows */
 
 
/*
   ** clearSourceWindowsDetail()
   **        Clear the pertinant detail in the source windows.
 */
void
#ifdef __STDC__
clearSourceWindowsDetail (void)
#else
clearSourceWindowsDetail ()
#endif
{
  int i;
 
  for (i = 0; i < (sourceWindows ())->count; i++)
    clearWinDetail ((TuiWinInfoPtr) (sourceWindows ())->list[i]);
 
  return;
}                               /* currentSourceWindows */
 
 
/*
   ** addSourceWindowToList().
   **       Add a window to the list of source windows.  Usually there is
   **       only one source window (either source or disassembly), but
   **       both can be displayed at the same time.
 */
void
#ifdef __STDC__
addToSourceWindows (
                     TuiWinInfoPtr winInfo)
#else
addToSourceWindows (winInfo)
     TuiWinInfoPtr winInfo;
#endif
{
  if (_sourceWindows.count < 2)
    _sourceWindows.list[_sourceWindows.count++] = (Opaque) winInfo;
 
  return;
}                               /* addToSourceWindows */
 
 
/*
   ** clearWinDetail()
   **        Clear the pertinant detail in the windows.
 */
void
#ifdef __STDC__
clearWinDetail (
                 TuiWinInfoPtr winInfo)
#else
clearWinDetail (winInfo)
     TuiWinInfoPtr winInfo;
#endif
{
  if (m_winPtrNotNull (winInfo))
    {
      switch (winInfo->generic.type)
        {
        case SRC_WIN:
        case DISASSEM_WIN:
          winInfo->detail.sourceInfo.startLineOrAddr.addr = (Opaque) NULL;
          winInfo->detail.sourceInfo.horizontalOffset = 0;
          break;
        case CMD_WIN:
          winInfo->detail.commandInfo.curLine =
            winInfo->detail.commandInfo.curch = 0;
          break;
        case DATA_WIN:
          winInfo->detail.dataDisplayInfo.dataContent =
            (TuiWinContent) NULL;
          winInfo->detail.dataDisplayInfo.dataContentCount = 0;
          winInfo->detail.dataDisplayInfo.regsContent =
            (TuiWinContent) NULL;
          winInfo->detail.dataDisplayInfo.regsContentCount = 0;
          winInfo->detail.dataDisplayInfo.regsDisplayType =
            TUI_UNDEFINED_REGS;
          winInfo->detail.dataDisplayInfo.regsColumnCount = 1;
          winInfo->detail.dataDisplayInfo.displayRegs = FALSE;
          break;
        default:
          break;
        }
    }
 
  return;
}                               /* clearWinDetail */
 
 
/*
   ** blankStr()
   **        Accessor for the blank string.
 */
char *
#ifdef __STDC__
blankStr (void)
#else
blankStr ()
#endif
{
  return _tuiBlankStr;
}                               /* blankStr */
 
 
/*
   ** locationStr()
   **        Accessor for the location string.
 */
char *
#ifdef __STDC__
locationStr (void)
#else
locationStr ()
#endif
{
  return _tuiLocationStr;
}                               /* locationStr */
 
 
/*
   ** breakStr()
   **        Accessor for the break string.
 */
char *
#ifdef __STDC__
breakStr (void)
#else
breakStr ()
#endif
{
  return _tuiBreakStr;
}                               /* breakStr */
 
 
/*
   ** breakLocationStr()
   **        Accessor for the breakLocation string.
 */
char *
#ifdef __STDC__
breakLocationStr (void)
#else
breakLocationStr ()
#endif
{
  return _tuiBreakLocationStr;
}                               /* breakLocationStr */
 
 
/*
   ** nullStr()
   **        Accessor for the null string.
 */
char *
#ifdef __STDC__
nullStr (void)
#else
nullStr ()
#endif
{
  return _tuiNullStr;
}                               /* nullStr */
 
 
/*
   ** sourceExecInfoPtr().
   **        Accessor for the source execution info ptr.
 */
TuiGenWinInfoPtr
#ifdef __STDC__
sourceExecInfoWinPtr (void)
#else
sourceExecInfoWinPtr ()
#endif
{
  return &_execInfo[0];
}                               /* sourceExecInfoWinPtr */
 
 
/*
   ** disassemExecInfoPtr().
   **        Accessor for the disassem execution info ptr.
 */
TuiGenWinInfoPtr
#ifdef __STDC__
disassemExecInfoWinPtr (void)
#else
disassemExecInfoWinPtr ()
#endif
{
  return &_execInfo[1];
}                               /* disassemExecInfoWinPtr */
 
 
/*
   ** locatorWinInfoPtr().
   **        Accessor for the locator win info.  Answers a pointer to the
   **        static locator win info struct.
 */
TuiGenWinInfoPtr
#ifdef __STDC__
locatorWinInfoPtr (void)
#else
locatorWinInfoPtr ()
#endif
{
  return &_locator;
}                               /* locatorWinInfoPtr */
 
 
/*
   ** historyLimit().
   **        Accessor for the history limit
 */
int
#ifdef __STDC__
historyLimit (void)
#else
historyLimit ()
#endif
{
  return _historyLimit;
}                               /* historyLimit */
 
 
/*
   ** setHistoryLimitTo().
   **        Mutator for the history limit
 */
void
#ifdef __STDC__
setHistoryLimitTo (
                    int h)
#else
setHistoryLimitTo (h)
     int h;
#endif
{
  _historyLimit = h;
 
  return;
}                               /* setHistoryLimitTo */
 
/*
   ** termHeight().
   **        Accessor for the termHeight
 */
int
#ifdef __STDC__
termHeight (void)
#else
termHeight ()
#endif
{
  return _termHeight;
}                               /* termHeight */
 
 
/*
   ** setTermHeightTo().
   **        Mutator for the term height
 */
void
#ifdef __STDC__
setTermHeightTo (
                  int h)
#else
setTermHeightTo (h)
     int h;
#endif
{
  _termHeight = h;
 
  return;
}                               /* setTermHeightTo */
 
 
/*
   ** termWidth().
   **        Accessor for the termWidth
 */
int
#ifdef __STDC__
termWidth (void)
#else
termWidth ()
#endif
{
  return _termWidth;
}                               /* termWidth */
 
 
/*
   ** setTermWidth().
   **        Mutator for the termWidth
 */
void
#ifdef __STDC__
setTermWidthTo (
                 int w)
#else
setTermWidthTo (w)
     int w;
#endif
{
  _termWidth = w;
 
  return;
}                               /* setTermWidthTo */
 
 
/*
   ** currentLayout().
   **        Accessor for the current layout
 */
TuiLayoutType
#ifdef __STDC__
currentLayout (void)
#else
currentLayout ()
#endif
{
  return _currentLayout;
}                               /* currentLayout */
 
 
/*
   ** setCurrentLayoutTo().
   **        Mutator for the current layout
 */
void
#ifdef __STDC__
setCurrentLayoutTo (
                     TuiLayoutType newLayout)
#else
setCurrentLayoutTo (newLayout)
     TuiLayoutType newLayout;
#endif
{
  _currentLayout = newLayout;
 
  return;
}                               /* setCurrentLayoutTo */
 
 
/*
   ** setGenWinOrigin().
   **        Set the origin of the window
 */
void
#ifdef __STDC__
setGenWinOrigin (
                  TuiGenWinInfoPtr winInfo,
                  int x,
                  int y)
#else
setGenWinOrigin (winInfo, x, y)
     TuiGenWinInfoPtr winInfo;
     int x;
     int y;
#endif
{
  winInfo->origin.x = x;
  winInfo->origin.y = y;
 
  return;
}                               /* setGenWinOrigin */
 
 
/*****************************
** OTHER PUBLIC FUNCTIONS
*****************************/
 
 
/*
   ** tuiNextWin().
   **        Answer the next window in the list, cycling back to the top
   **        if necessary
 */
TuiWinInfoPtr
#ifdef __STDC__
tuiNextWin (
             TuiWinInfoPtr curWin)
#else
tuiNextWin (curWin)
     TuiWinInfoPtr curWin;
#endif
{
  TuiWinType type = curWin->generic.type;
  TuiWinInfoPtr nextWin = (TuiWinInfoPtr) NULL;
 
  if (curWin->generic.type == CMD_WIN)
    type = SRC_WIN;
  else
    type = curWin->generic.type + 1;
  while (type != curWin->generic.type && m_winPtrIsNull (nextWin))
    {
      if (winList[type]->generic.isVisible)
        nextWin = winList[type];
      else
        {
          if (type == CMD_WIN)
            type = SRC_WIN;
          else
            type++;
        }
    }
 
  return nextWin;
}                               /* tuiNextWin */
 
 
/*
   ** tuiPrevWin().
   **        Answer the prev window in the list, cycling back to the bottom
   **        if necessary
 */
TuiWinInfoPtr
#ifdef __STDC__
tuiPrevWin (
             TuiWinInfoPtr curWin)
#else
tuiPrevWin (curWin)
     TuiWinInfoPtr curWin;
#endif
{
  TuiWinType type = curWin->generic.type;
  TuiWinInfoPtr prev = (TuiWinInfoPtr) NULL;
 
  if (curWin->generic.type == SRC_WIN)
    type = CMD_WIN;
  else
    type = curWin->generic.type - 1;
  while (type != curWin->generic.type && m_winPtrIsNull (prev))
    {
      if (winList[type]->generic.isVisible)
        prev = winList[type];
      else
        {
          if (type == SRC_WIN)
            type = CMD_WIN;
          else
            type--;
        }
    }
 
  return prev;
}                               /* tuiPrevWin */
 
 
/*
   ** displayableWinContentOf().
   **        Answer a the content at the location indicated by index.  Note
   **        that if this is a locator window, the string returned should be
   **        freed after use.
 */
char *
#ifdef __STDC__
displayableWinContentOf (
                          TuiGenWinInfoPtr winInfo,
                          TuiWinElementPtr elementPtr)
#else
displayableWinContentOf (winInfo, elementPtr)
     TuiGenWinInfoPtr winInfo;
     TuiWinElementPtr elementPtr;
#endif
{
 
  char *string = nullStr ();
 
  if (elementPtr != (TuiWinElementPtr) NULL || winInfo->type == LOCATOR_WIN)
    {
      /*
         ** Now convert the line to a displayable string
       */
      switch (winInfo->type)
        {
        case SRC_WIN:
        case DISASSEM_WIN:
          string = elementPtr->whichElement.source.line;
          break;
        case CMD_WIN:
          string = elementPtr->whichElement.command.line;
          break;
        case LOCATOR_WIN:
          if ((string = (char *) xmalloc (
                      (termWidth () + 1) * sizeof (char))) == (char *) NULL)
              string = nullStr ();
          else
            {
              char lineNo[50], pc[50], buf[50], *fname, *pname;
              register int strSize = termWidth (), i, procWidth, fileWidth;
 
              /*
                 ** First determine the amount of file/proc name width
                 ** we have available
               */
              i = strSize - (PC_WIDTH + LINE_WIDTH
                             + 25       /* pc and line labels */
                             + strlen (FILE_PREFIX) + 1         /* file label */
                             + 15 /* procedure label */ );
              if (i >= FILE_WIDTH + PROC_WIDTH)
                {
                  fileWidth = FILE_WIDTH;
                  procWidth = PROC_WIDTH;
                }
              else
                {
                  fileWidth = i / 2;
                  procWidth = i - fileWidth;
                }
 
              /* Now convert elements to string form */
              if (elementPtr != (TuiWinElementPtr) NULL &&
                  *elementPtr->whichElement.locator.fileName != (char) 0 &&
                  srcWin->generic.isVisible)
                fname = elementPtr->whichElement.locator.fileName;
              else
                fname = "??";
              if (elementPtr != (TuiWinElementPtr) NULL &&
                  *elementPtr->whichElement.locator.procName != (char) 0)
                pname = elementPtr->whichElement.locator.procName;
              else
                pname = "??";
              if (elementPtr != (TuiWinElementPtr) NULL &&
                  elementPtr->whichElement.locator.lineNo > 0)
                sprintf (lineNo, "%d",
                         elementPtr->whichElement.locator.lineNo);
              else
                strcpy (lineNo, "??");
              if (elementPtr != (TuiWinElementPtr) NULL &&
                  elementPtr->whichElement.locator.addr > (Opaque) 0)
                sprintf (pc, "0x%x",
                         elementPtr->whichElement.locator.addr);
              else
                strcpy (pc, "??");
              /*
                 ** Now create the locator line from the string version
                 ** of the elements.  We could use sprintf() here but
                 ** that wouldn't ensure that we don't overrun the size
                 ** of the allocated buffer.  strcat_to_buf() will.
               */
              *string = (char) 0;
              /* Filename */
              strcat_to_buf (string, strSize, " ");
              strcat_to_buf (string, strSize, FILE_PREFIX);
              if (strlen (fname) > fileWidth)
                {
                  strncpy (buf, fname, fileWidth - 1);
                  buf[fileWidth - 1] = '*';
                  buf[fileWidth] = (char) 0;
                }
              else
                strcpy (buf, fname);
              strcat_to_buf (string, strSize, buf);
              /* procedure/class name */
              sprintf (buf, "%15s", PROC_PREFIX);
              strcat_to_buf (string, strSize, buf);
              if (strlen (pname) > procWidth)
                {
                  strncpy (buf, pname, procWidth - 1);
                  buf[procWidth - 1] = '*';
                  buf[procWidth] = (char) 0;
                }
              else
                strcpy (buf, pname);
              strcat_to_buf (string, strSize, buf);
              sprintf (buf, "%10s", LINE_PREFIX);
              strcat_to_buf (string, strSize, buf);
              strcat_to_buf (string, strSize, lineNo);
              sprintf (buf, "%10s", PC_PREFIX);
              strcat_to_buf (string, strSize, buf);
              strcat_to_buf (string, strSize, pc);
              for (i = strlen (string); i < strSize; i++)
                string[i] = ' ';
              string[strSize] = (char) 0;
            }
          break;
        case EXEC_INFO_WIN:
          string = elementPtr->whichElement.simpleString;
          break;
        default:
          break;
        }
    }
  return string;
}                               /* displayableWinContentOf */
 
 
/*
   **    winContentAt().
   **        Answer a the content at the location indicated by index
 */
char *
#ifdef __STDC__
displayableWinContentAt (
                          TuiGenWinInfoPtr winInfo,
                          int index)
#else
displayableWinContentAt (winInfo, index)
     TuiGenWinInfoPtr winInfo;
     int index;
#endif
{
  return (displayableWinContentOf (winInfo, (TuiWinElementPtr) winInfo->content[index]));
}                               /* winContentAt */
 
 
/*
   ** winElementHeight().
   **        Answer the height of the element in lines
 */
int
#ifdef __STDC__
winElementHeight (
                   TuiGenWinInfoPtr winInfo,
                   TuiWinElementPtr element)
#else
winElementHeight (winInfo, element)
     TuiGenWinInfoPtr winInfo;
     TuiWinElementPtr element;
#endif
{
  int h;
 
  if (winInfo->type == DATA_WIN)
/* FOR NOW SAY IT IS ONLY ONE LINE HIGH */
    h = 1;
  else
    h = 1;
 
  return h;
}                               /* winElementHeight */
 
 
/*
   **  winByName().
   **      Answer the window represented by name
 */
TuiWinInfoPtr
#ifdef __STDC__
winByName (
            char *name)
#else
winByName (name)
     char *name;
#endif
{
  TuiWinInfoPtr winInfo = (TuiWinInfoPtr) NULL;
  int i = 0;
 
  while (i < MAX_MAJOR_WINDOWS && m_winPtrIsNull (winInfo))
    {
      if (strcmp (name, winName (&(winList[i]->generic))) == 0)
        winInfo = winList[i];
      i++;
    }
 
  return winInfo;
}                               /* winByName */
 
 
/*
   **  partialWinByName().
   **      Answer the window represented by name
 */
TuiWinInfoPtr
#ifdef __STDC__
partialWinByName (
                   char *name)
#else
partialWinByName (name)
     char *name;
#endif
{
  TuiWinInfoPtr winInfo = (TuiWinInfoPtr) NULL;
 
  if (name != (char *) NULL)
    {
      int i = 0;
 
      while (i < MAX_MAJOR_WINDOWS && m_winPtrIsNull (winInfo))
        {
          char *curName = winName (&winList[i]->generic);
          if (strlen (name) <= strlen (curName) &&
              strncmp (name, curName, strlen (name)) == 0)
            winInfo = winList[i];
          i++;
        }
    }
 
  return winInfo;
}                               /* partialWinByName */
 
 
/*
   ** winName().
   **      Answer the name of the window
 */
char *
#ifdef __STDC__
winName (
          TuiGenWinInfoPtr winInfo)
#else
winName (winInfo)
     TuiGenWinInfoPtr winInfo;
#endif
{
  char *name = (char *) NULL;
 
  switch (winInfo->type)
    {
    case SRC_WIN:
      name = SRC_NAME;
      break;
    case CMD_WIN:
      name = CMD_NAME;
      break;
    case DISASSEM_WIN:
      name = DISASSEM_NAME;
      break;
    case DATA_WIN:
      name = DATA_NAME;
      break;
    default:
      name = "";
      break;
    }
 
  return name;
}                               /* winName */
 
 
/*
   ** initializeStaticData
 */
void
#ifdef __STDC__
initializeStaticData (void)
#else
initializeStaticData ()
#endif
{
  initGenericPart (sourceExecInfoWinPtr ());
  initGenericPart (disassemExecInfoWinPtr ());
  initGenericPart (locatorWinInfoPtr ());
 
  return;
}                               /* initializeStaticData */
 
 
/*
   ** allocGenericWinInfo().
 */
TuiGenWinInfoPtr
#ifdef __STDC__
allocGenericWinInfo (void)
#else
allocGenericWinInfo ()
#endif
{
  TuiGenWinInfoPtr win;
 
  if ((win = (TuiGenWinInfoPtr) xmalloc (
                     sizeof (TuiGenWinInfoPtr))) != (TuiGenWinInfoPtr) NULL)
    initGenericPart (win);
 
  return win;
}                               /* allocGenericWinInfo */
 
 
/*
   ** initGenericPart().
 */
void
#ifdef __STDC__
initGenericPart (
                  TuiGenWinInfoPtr win)
#else
initGenericPart (win)
     TuiGenWinInfoPtr win;
#endif
{
  win->width =
    win->height =
    win->origin.x =
    win->origin.y =
    win->viewportHeight =
    win->contentSize =
    win->lastVisibleLine = 0;
  win->handle = (WINDOW *) NULL;
  win->content = (OpaquePtr) NULL;
  win->contentInUse =
    win->isVisible = FALSE;
 
  return;
}                               /* initGenericPart */
 
 
/*
   ** initContentElement().
 */
void
#ifdef __STDC__
initContentElement (
                     TuiWinElementPtr element,
                     TuiWinType type)
#else
initContentElement (element, type)
     TuiWinElementPtr element;
     TuiWinType type;
#endif
{
  element->highlight = FALSE;
  switch (type)
    {
    case SRC_WIN:
    case DISASSEM_WIN:
      element->whichElement.source.line = (char *) NULL;
      element->whichElement.source.lineOrAddr.lineNo = 0;
      element->whichElement.source.isExecPoint = FALSE;
      element->whichElement.source.hasBreak = FALSE;
      break;
    case DATA_WIN:
      initGenericPart (&element->whichElement.dataWindow);
      element->whichElement.dataWindow.type = DATA_ITEM_WIN;
      ((TuiGenWinInfoPtr) & element->whichElement.dataWindow)->content =
        (OpaquePtr) allocContent (1, DATA_ITEM_WIN);
      ((TuiGenWinInfoPtr)
       & element->whichElement.dataWindow)->contentSize = 1;
      break;
    case CMD_WIN:
      element->whichElement.command.line = (char *) NULL;
      break;
    case DATA_ITEM_WIN:
      element->whichElement.data.name = (char *) NULL;
      element->whichElement.data.type = TUI_REGISTER;
      element->whichElement.data.itemNo = UNDEFINED_ITEM;
      element->whichElement.data.value = (Opaque) NULL;
      element->whichElement.data.highlight = FALSE;
      break;
    case LOCATOR_WIN:
      element->whichElement.locator.fileName[0] =
        element->whichElement.locator.procName[0] = (char) 0;
      element->whichElement.locator.lineNo = 0;
      element->whichElement.locator.addr = 0;
      break;
    case EXEC_INFO_WIN:
      element->whichElement.simpleString = blankStr ();
      break;
    default:
      break;
    }
  return;
}                               /* initContentElement */
 
/*
   ** initWinInfo().
 */
void
#ifdef __STDC__
initWinInfo (
              TuiWinInfoPtr winInfo)
#else
initWinInfo (winInfo)
     TuiWinInfoPtr winInfo;
#endif
{
  initGenericPart (&winInfo->generic);
  winInfo->canHighlight =
    winInfo->isHighlighted = FALSE;
  switch (winInfo->generic.type)
    {
    case SRC_WIN:
    case DISASSEM_WIN:
      winInfo->detail.sourceInfo.executionInfo = (TuiGenWinInfoPtr) NULL;
      winInfo->detail.sourceInfo.hasLocator = FALSE;
      winInfo->detail.sourceInfo.horizontalOffset = 0;
      winInfo->detail.sourceInfo.startLineOrAddr.addr = (Opaque) NULL;
      break;
    case DATA_WIN:
      winInfo->detail.dataDisplayInfo.dataContent = (TuiWinContent) NULL;
      winInfo->detail.dataDisplayInfo.dataContentCount = 0;
      winInfo->detail.dataDisplayInfo.regsContent = (TuiWinContent) NULL;
      winInfo->detail.dataDisplayInfo.regsContentCount = 0;
      winInfo->detail.dataDisplayInfo.regsDisplayType =
        TUI_UNDEFINED_REGS;
      winInfo->detail.dataDisplayInfo.regsColumnCount = 1;
      winInfo->detail.dataDisplayInfo.displayRegs = FALSE;
      break;
    case CMD_WIN:
      winInfo->detail.commandInfo.curLine = 0;
      winInfo->detail.commandInfo.curch = 0;
      break;
    default:
      winInfo->detail.opaque = (Opaque) NULL;
      break;
    }
 
  return;
}                               /* initWinInfo */
 
 
/*
   ** allocWinInfo().
 */
TuiWinInfoPtr
#ifdef __STDC__
allocWinInfo (
               TuiWinType type)
#else
allocWinInfo (type)
     TuiWinType type;
#endif
{
  TuiWinInfoPtr winInfo = (TuiWinInfoPtr) NULL;
 
  winInfo = (TuiWinInfoPtr) xmalloc (sizeof (TuiWinInfo));
  if (m_winPtrNotNull (winInfo))
    {
      winInfo->generic.type = type;
      initWinInfo (winInfo);
    }
 
  return winInfo;
}                               /* allocWinInfo */
 
 
/*
   ** allocContent().
   **        Allocates the content and elements in a block.
 */
TuiWinContent
#ifdef __STDC__
allocContent (
               int numElements,
               TuiWinType type)
#else
allocContent (numElements, type)
     int numElements;
     TuiWinType type;
#endif
{
  TuiWinContent content = (TuiWinContent) NULL;
  char *elementBlockPtr = (char *) NULL;
  int i;
 
  if ((content = (TuiWinContent)
  xmalloc (sizeof (TuiWinElementPtr) * numElements)) != (TuiWinContent) NULL)
    {                           /*
                                   ** All windows, except the data window, can allocate the elements
                                   ** in a chunk.  The data window cannot because items can be
                                   ** added/removed from the data display by the user at any time.
                                 */
      if (type != DATA_WIN)
        {
          if ((elementBlockPtr = (char *)
           xmalloc (sizeof (TuiWinElement) * numElements)) != (char *) NULL)
            {
              for (i = 0; i < numElements; i++)
                {
                  content[i] = (TuiWinElementPtr) elementBlockPtr;
                  initContentElement (content[i], type);
                  elementBlockPtr += sizeof (TuiWinElement);
                }
            }
          else
            {
              tuiFree ((char *) content);
              content = (TuiWinContent) NULL;
            }
        }
    }
 
  return content;
}                               /* allocContent */
 
 
/*
   ** addContentElements().
   **        Adds the input number of elements to the windows's content.  If
   **        no content has been allocated yet, allocContent() is called to
   **        do this.  The index of the first element added is returned,
   **        unless there is a memory allocation error, in which case, (-1)
   **        is returned.
 */
int
#ifdef __STDC__
addContentElements (
                     TuiGenWinInfoPtr winInfo,
                     int numElements)
#else
addContentElements (winInfo, numElements)
     TuiGenWinInfoPtr winInfo;
     int numElements;
#endif
{
  TuiWinElementPtr elementPtr;
  int i, indexStart;
 
  if (winInfo->content == (OpaquePtr) NULL)
    {
      winInfo->content = (OpaquePtr) allocContent (numElements, winInfo->type);
      indexStart = 0;
    }
  else
    indexStart = winInfo->contentSize;
  if (winInfo->content != (OpaquePtr) NULL)
    {
      for (i = indexStart; (i < numElements + indexStart); i++)
        {
          if ((elementPtr = (TuiWinElementPtr)
               xmalloc (sizeof (TuiWinElement))) != (TuiWinElementPtr) NULL)
            {
              winInfo->content[i] = (Opaque) elementPtr;
              initContentElement (elementPtr, winInfo->type);
              winInfo->contentSize++;
            }
          else                  /* things must be really hosed now! We ran out of memory!? */
            return (-1);
        }
    }
 
  return indexStart;
}                               /* addContentElements */
 
 
/*
   **  tuiDelWindow().
   **     Delete all curses windows associated with winInfo, leaving everything
   **     else in tact.
 */
void
#ifdef __STDC__
tuiDelWindow (
               TuiWinInfoPtr winInfo)
#else
tuiDelWindow (winInfo)
     TuiWinInfoPtr winInfo;
#endif
{
  Opaque detail;
  int i;
  TuiGenWinInfoPtr genericWin;
 
 
  switch (winInfo->generic.type)
    {
    case SRC_WIN:
    case DISASSEM_WIN:
      genericWin = locatorWinInfoPtr ();
      if (genericWin != (TuiGenWinInfoPtr) NULL)
        {
          tuiDelwin (genericWin->handle);
          genericWin->handle = (WINDOW *) NULL;
          genericWin->isVisible = FALSE;
        }
      genericWin = winInfo->detail.sourceInfo.executionInfo;
      if (genericWin != (TuiGenWinInfoPtr) NULL)
        {
          tuiDelwin (genericWin->handle);
          genericWin->handle = (WINDOW *) NULL;
          genericWin->isVisible = FALSE;
        }
      break;
    case DATA_WIN:
      if (winInfo->generic.content != (OpaquePtr) NULL)
        {
          int i;
 
          tuiDelDataWindows (
                              winInfo->detail.dataDisplayInfo.regsContent,
                          winInfo->detail.dataDisplayInfo.regsContentCount);
          tuiDelDataWindows (
                              winInfo->detail.dataDisplayInfo.dataContent,
                          winInfo->detail.dataDisplayInfo.dataContentCount);
        }
      break;
    default:
      break;
    }
  if (winInfo->generic.handle != (WINDOW *) NULL)
    {
      tuiDelwin (winInfo->generic.handle);
      winInfo->generic.handle = (WINDOW *) NULL;
      winInfo->generic.isVisible = FALSE;
    }
 
  return;
}                               /* tuiDelWindow */
 
 
/*
   **  freeWindow().
 */
void
#ifdef __STDC__
freeWindow (
             TuiWinInfoPtr winInfo)
#else
freeWindow (winInfo)
     TuiWinInfoPtr winInfo;
#endif
{
  Opaque detail;
  int i;
  TuiGenWinInfoPtr genericWin;
 
 
  switch (winInfo->generic.type)
    {
    case SRC_WIN:
    case DISASSEM_WIN:
      genericWin = locatorWinInfoPtr ();
      if (genericWin != (TuiGenWinInfoPtr) NULL)
        {
          tuiDelwin (genericWin->handle);
          genericWin->handle = (WINDOW *) NULL;
        }
      freeWinContent (genericWin);
      genericWin = winInfo->detail.sourceInfo.executionInfo;
      if (genericWin != (TuiGenWinInfoPtr) NULL)
        {
          tuiDelwin (genericWin->handle);
          genericWin->handle = (WINDOW *) NULL;
          freeWinContent (genericWin);
        }
      break;
    case DATA_WIN:
      if (winInfo->generic.content != (OpaquePtr) NULL)
        {
          freeDataContent (
                            winInfo->detail.dataDisplayInfo.regsContent,
                          winInfo->detail.dataDisplayInfo.regsContentCount);
          winInfo->detail.dataDisplayInfo.regsContent =
            (TuiWinContent) NULL;
          winInfo->detail.dataDisplayInfo.regsContentCount = 0;
          freeDataContent (
                            winInfo->detail.dataDisplayInfo.dataContent,
                          winInfo->detail.dataDisplayInfo.dataContentCount);
          winInfo->detail.dataDisplayInfo.dataContent =
            (TuiWinContent) NULL;
          winInfo->detail.dataDisplayInfo.dataContentCount = 0;
          winInfo->detail.dataDisplayInfo.regsDisplayType =
            TUI_UNDEFINED_REGS;
          winInfo->detail.dataDisplayInfo.regsColumnCount = 1;
          winInfo->detail.dataDisplayInfo.displayRegs = FALSE;
          winInfo->generic.content = (OpaquePtr) NULL;
          winInfo->generic.contentSize = 0;
        }
      break;
    default:
      break;
    }
  if (winInfo->generic.handle != (WINDOW *) NULL)
    {
      tuiDelwin (winInfo->generic.handle);
      winInfo->generic.handle = (WINDOW *) NULL;
      freeWinContent (&winInfo->generic);
    }
  free (winInfo);
 
  return;
}                               /* freeWindow */
 
 
/*
   ** freeAllSourceWinsContent().
 */
void
#ifdef __STDC__
freeAllSourceWinsContent (void)
#else
freeAllSourceWinsContent ()
#endif
{
  int i;
 
  for (i = 0; i < (sourceWindows ())->count; i++)
    {
      TuiWinInfoPtr winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[i];
 
      if (m_winPtrNotNull (winInfo))
        {
          freeWinContent (&(winInfo->generic));
          freeWinContent (winInfo->detail.sourceInfo.executionInfo);
        }
    }
 
  return;
}                               /* freeAllSourceWinsContent */
 
 
/*
   ** freeWinContent().
 */
void
#ifdef __STDC__
freeWinContent (
                 TuiGenWinInfoPtr winInfo)
#else
freeWinContent (winInfo)
     TuiGenWinInfoPtr winInfo;
#endif
{
  if (winInfo->content != (OpaquePtr) NULL)
    {
      freeContent ((TuiWinContent) winInfo->content,
                   winInfo->contentSize,
                   winInfo->type);
      winInfo->content = (OpaquePtr) NULL;
    }
  winInfo->contentSize = 0;
 
  return;
}                               /* freeWinContent */
 
 
/*
   ** freeAllWindows().
 */
void
#ifdef __STDC__
freeAllWindows (void)
#else
freeAllWindows ()
#endif
{
  TuiWinType type = SRC_WIN;
 
  for (; type < MAX_MAJOR_WINDOWS; type++)
    if (m_winPtrNotNull (winList[type]) &&
        winList[type]->generic.type != UNDEFINED_WIN)
      freeWindow (winList[type]);
  return;
}                               /* freeAllWindows */
 
 
void
#ifdef __STDC__
tuiDelDataWindows (
                    TuiWinContent content,
                    int contentSize)
#else
tuiDelDataWindows (content, contentSize)
     TuiWinContent content;
     int contentSize;
#endif
{
  int i;
 
  /*
     ** Remember that data window content elements are of type TuiGenWinInfoPtr,
     ** each of which whose single element is a data element.
   */
  for (i = 0; i < contentSize; i++)
    {
      TuiGenWinInfoPtr genericWin = &content[i]->whichElement.dataWindow;
 
      if (genericWin != (TuiGenWinInfoPtr) NULL)
        {
          tuiDelwin (genericWin->handle);
          genericWin->handle = (WINDOW *) NULL;
          genericWin->isVisible = FALSE;
        }
    }
 
  return;
}                               /* tuiDelDataWindows */
 
 
void
#ifdef __STDC__
freeDataContent (
                  TuiWinContent content,
                  int contentSize)
#else
freeDataContent (content, contentSize)
     TuiWinContent content;
     int contentSize;
#endif
{
  int i;
 
  /*
     ** Remember that data window content elements are of type TuiGenWinInfoPtr,
     ** each of which whose single element is a data element.
   */
  for (i = 0; i < contentSize; i++)
    {
      TuiGenWinInfoPtr genericWin = &content[i]->whichElement.dataWindow;
 
      if (genericWin != (TuiGenWinInfoPtr) NULL)
        {
          tuiDelwin (genericWin->handle);
          genericWin->handle = (WINDOW *) NULL;
          freeWinContent (genericWin);
        }
    }
  freeContent (content,
               contentSize,
               DATA_WIN);
 
  return;
}                               /* freeDataContent */
 
 
/**********************************
** LOCAL STATIC FUNCTIONS        **
**********************************/
 
 
/*
   ** freeContent().
 */
static void
#ifdef __STDC__
freeContent (
              TuiWinContent content,
              int contentSize,
              TuiWinType winType)
#else
freeContent (content, contentSize, winType)
     TuiWinContent content;
     int contentSize;
     TuiWinType winType;
#endif
{
  if (content != (TuiWinContent) NULL)
    {
      freeContentElements (content, contentSize, winType);
      tuiFree ((char *) content);
    }
 
  return;
}                               /* freeContent */
 
 
/*
   ** freeContentElements().
 */
static void
#ifdef __STDC__
freeContentElements (
                      TuiWinContent content,
                      int contentSize,
                      TuiWinType type)
#else
freeContentElements (content, contentSize, type)
     TuiWinContent content;
     int contentSize;
     TuiWinType type;
#endif
{
  if (content != (TuiWinContent) NULL)
    {
      int i;
 
      if (type == SRC_WIN || type == DISASSEM_WIN)
        {
          /* free whole source block */
          if (content[0]->whichElement.source.line != (char *) NULL)
            tuiFree (content[0]->whichElement.source.line);
        }
      else
        {
          for (i = 0; i < contentSize; i++)
            {
              TuiWinElementPtr element;
 
              element = content[i];
              if (element != (TuiWinElementPtr) NULL)
                {
                  switch (type)
                    {
                    case DATA_WIN:
                      tuiFree ((char *) element);
                      break;
                    case DATA_ITEM_WIN:
                      /*
                         ** Note that data elements are not allocated
                         ** in a single block, but individually, as needed.
                       */
                      if (element->whichElement.data.type != TUI_REGISTER)
                        tuiFree ((char *)
                                 element->whichElement.data.name);
                      tuiFree ((char *) element->whichElement.data.value);
                      tuiFree ((char *) element);
                      break;
                    case CMD_WIN:
                      tuiFree ((char *) element->whichElement.command.line);
                      break;
                    default:
                      break;
                    }
                }
            }
        }
      if (type != DATA_WIN && type != DATA_ITEM_WIN)
        tuiFree ((char *) content[0]);   /* free the element block */
    }
 
  return;
}                               /* freeContentElements */
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [tui/] [tuiData.c] - Blame information for rev 1774

Line No.	Rev	Author	Line
1	106	markom	`/*`
2			`** tuiData.c`
3			`** This module contains functions for manipulating the data`
4			`** structures used by the TUI`
5			`*/`
6
7			`#include "defs.h"`
8			`#include "tui.h"`
9			`#include "tuiData.h"`
10
11			`/****************************`
12			`** GLOBAL DECLARATIONS`
13			`****************************/`
14			`TuiWinInfoPtr winList[MAX_MAJOR_WINDOWS];`
15
16			`/***************************`
17			`** Private Definitions`
18			`****************************/`
19			`#define FILE_WIDTH 30`
20			`#define PROC_WIDTH 40`
21			`#define LINE_WIDTH 4`
22			`#define PC_WIDTH 8`
23
24			`/***************************`
25			`** Private data`
26			`****************************/`
27			`static char *_tuiNullStr = TUI_NULL_STR;`
28			`static char *_tuiBlankStr = " ";`
29			`static char *_tuiLocationStr = " >";`
30			`static char _tuiBreakStr = " ";`
31			`static char _tuiBreakLocationStr = " >";`
32			`static TuiLayoutType _currentLayout = UNDEFINED_LAYOUT;`
33			`static int _termHeight, _termWidth;`
34			`static int _historyLimit = DEFAULT_HISTORY_COUNT;`
35			`static TuiGenWinInfo _locator;`
36			`static TuiGenWinInfo _execInfo[2];`
37			`static TuiWinInfoPtr _srcWinList[2];`
38			`static TuiList _sourceWindows =`
39			`{(OpaqueList) _srcWinList, 0};`
40			`static int _defaultTabLen = DEFAULT_TAB_LEN;`