old-cross-binutils/gdb/mac-xdep.c

1100 lines
22 KiB
C
Raw Normal View History

/* Top level support for Mac interface to GDB, the GNU debugger.
Copyright 1994 Free Software Foundation, Inc.
Contributed by Cygnus Support. Written by Stan Shebs.
1999-07-07 20:19:36 +00:00
This file is part of GDB.
1999-07-07 20:19:36 +00:00
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 2 of the License, or
(at your option) any later version.
1999-07-07 20:19:36 +00:00
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.
1999-07-07 20:19:36 +00:00
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include "defs.h"
#include <readline/readline.h>
#include <readline/history.h>
#include <Types.h>
#include <Resources.h>
#include <QuickDraw.h>
#include <Fonts.h>
#include <Events.h>
#include <Windows.h>
#include <Menus.h>
#include <TextEdit.h>
#include <Dialogs.h>
#include <Desk.h>
#include <ToolUtils.h>
#include <Memory.h>
#include <SegLoad.h>
#include <Files.h>
#include <Folders.h>
#include <OSUtils.h>
#include <OSEvents.h>
#include <DiskInit.h>
#include <Packages.h>
#include <Traps.h>
#include <Lists.h>
#include <Gestalt.h>
#include <PPCToolbox.h>
#include <AppleEvents.h>
#include <StandardFile.h>
#include <Sound.h>
#ifdef MPW
#define QD(whatever) (qd.##whatever)
#define QDPat(whatever) (&(qd.##whatever))
#endif /* MPW */
#ifdef THINK_C
#define QD(whatever) (whatever)
#endif
#define p2c(pstr,cbuf) \
strncpy(cbuf, ((char *) (pstr) + 1), pstr[0]); \
cbuf[pstr[0]] = '\0';
#define pascalify(STR) \
sprintf(tmpbuf, " %s", STR); \
tmpbuf[0] = strlen(STR);
#include "gdbcmd.h"
#include "call-cmds.h"
#include "symtab.h"
#include "inferior.h"
#include "signals.h"
#include "target.h"
#include "breakpoint.h"
#include "gdbtypes.h"
#include "expression.h"
#include "language.h"
#include "mac-defs.h"
int debug_openp = 0;
/* This is true if we are running as a standalone application. */
int mac_app;
/* This is true if we are using WaitNextEvent. */
int use_wne;
/* This is true if we have Color Quickdraw. */
int has_color_qd;
/* This is true if we are using Color Quickdraw. */
int use_color_qd;
int inbackground;
1999-07-07 20:19:36 +00:00
Rect dragrect =
{-32000, -32000, 32000, 32000};
Rect sizerect;
int sbarwid = 15;
/* Globals for the console window. */
WindowPtr console_window;
ControlHandle console_v_scrollbar;
Rect console_v_scroll_rect;
TEHandle console_text;
Rect console_text_rect;
/* This will go away eventually. */
1999-07-07 20:19:36 +00:00
gdb_has_a_terminal ()
{
return 1;
}
mac_init ()
{
SysEnvRec se;
int eventloopdone = 0;
char *str;
Boolean gotevent;
Point mouse;
EventRecord event;
WindowPtr win;
RgnHandle cursorRgn;
int i;
Handle menubar;
MenuHandle menu;
Handle siow_resource;
mac_app = 0;
1999-07-07 20:19:36 +00:00
str = getenv ("DEBUG_GDB");
if (str != NULL && str[0] != '\0')
{
1999-07-07 20:19:36 +00:00
if (strcmp (str, "openp") == 0)
debug_openp = 1;
}
1999-07-07 20:19:36 +00:00
/* Don't do anything if we`re running under MPW. */
if (!StandAlone)
return;
/* Don't do anything if we're using SIOW. */
/* This test requires that the siow 0 resource, as defined in
{RIncludes}siow.r, not be messed with. If it is, then the
standard Mac setup below will step on SIOW's Mac setup and
most likely crash the machine. */
1999-07-07 20:19:36 +00:00
siow_resource = GetResource ('siow', 0);
if (siow_resource != nil)
return;
mac_app = 1;
/* Do the standard Mac environment setup. */
InitGraf (&QD (thePort));
InitFonts ();
FlushEvents (everyEvent, 0);
InitWindows ();
InitMenus ();
TEInit ();
InitDialogs (NULL);
InitCursor ();
/* Color Quickdraw is different from Classic QD. */
1999-07-07 20:19:36 +00:00
SysEnvirons (2, &se);
has_color_qd = se.hasColorQD;
/* Use it if we got it. */
use_color_qd = has_color_qd;
sizerect.top = 50;
sizerect.left = 50;
sizerect.bottom = 1000;
1999-07-07 20:19:36 +00:00
sizerect.right = 1000;
#if 0
sizerect.bottom = screenBits.bounds.bottom - screenBits.bounds.top;
1999-07-07 20:19:36 +00:00
sizerect.right = screenBits.bounds.right - screenBits.bounds.left;
#endif
/* Set up the menus. */
menubar = GetNewMBar (mbMain);
SetMenuBar (menubar);
/* Add the DAs etc as usual. */
menu = GetMHandle (mApple);
1999-07-07 20:19:36 +00:00
if (menu != nil)
{
AddResMenu (menu, 'DRVR');
}
DrawMenuBar ();
new_console_window ();
}
new_console_window ()
{
/* Create the main window we're going to play in. */
if (has_color_qd)
1999-07-07 20:19:36 +00:00
console_window = GetNewCWindow (wConsole, NULL, (WindowPtr) - 1L);
else
1999-07-07 20:19:36 +00:00
console_window = GetNewWindow (wConsole, NULL, (WindowPtr) - 1L);
SetPort (console_window);
console_text_rect = console_window->portRect;
/* Leave 8 pixels of blank space, for aesthetic reasons and to
make it easier to select from the beginning of a line. */
console_text_rect.left += 8;
console_text_rect.bottom -= sbarwid - 1;
console_text_rect.right -= sbarwid - 1;
console_text = TENew (&console_text_rect, &console_text_rect);
TESetSelect (0, 40000, console_text);
TEDelete (console_text);
TEAutoView (1, console_text);
console_v_scroll_rect = console_window->portRect;
console_v_scroll_rect.bottom -= sbarwid - 1;
console_v_scroll_rect.left = console_v_scroll_rect.right - sbarwid;
console_v_scrollbar =
NewControl (console_window, &console_v_scroll_rect,
"\p", 1, 0, 0, 0, scrollBarProc, 0L);
ShowWindow (console_window);
SelectWindow (console_window);
}
1999-07-07 20:19:36 +00:00
mac_command_loop ()
{
SysEnvRec se;
int eventloopdone = 0;
Boolean gotevent;
Point mouse;
EventRecord event;
WindowPtr win;
RgnHandle cursorRgn;
int i, tm;
Handle menubar;
MenuHandle menu;
/* Figure out if the WaitNextEvent Trap is available. */
use_wne =
(NGetTrapAddress (0x60, ToolTrap) != NGetTrapAddress (0x9f, ToolTrap));
/* Pass WaitNextEvent an empty region the first time through. */
cursorRgn = NewRgn ();
/* Go into the main event-handling loop. */
while (!eventloopdone)
{
/* Use WaitNextEvent if it is available, otherwise GetNextEvent. */
if (use_wne)
{
get_global_mouse (&mouse);
adjust_cursor (mouse, cursorRgn);
1999-07-07 20:19:36 +00:00
tm = GetCaretTime ();
gotevent = WaitNextEvent (everyEvent, &event, tm, cursorRgn);
}
else
{
SystemTask ();
gotevent = GetNextEvent (everyEvent, &event);
}
/* First decide if the event is for a dialog or is just any old event. */
if (FrontWindow () != nil && IsDialogEvent (&event))
{
short itemhit;
DialogPtr dialog;
1999-07-07 20:19:36 +00:00
/* Handle all the modeless dialogs here. */
if (DialogSelect (&event, &dialog, &itemhit))
{
}
}
else if (gotevent)
{
/* Make sure we have the right cursor before handling the event. */
adjust_cursor (event.where, cursorRgn);
do_event (&event);
}
else
{
do_idle ();
}
}
}
/* Collect the global coordinates of the mouse pointer. */
get_global_mouse (mouse)
1999-07-07 20:19:36 +00:00
Point *mouse;
{
EventRecord evt;
1999-07-07 20:19:36 +00:00
OSEventAvail (0, &evt);
*mouse = evt.where;
}
/* Change the cursor's appearance to be appropriate for the given mouse
location. */
adjust_cursor (mouse, region)
1999-07-07 20:19:36 +00:00
Point mouse;
RgnHandle region;
{
}
/* Decipher an event, maybe do something with it. */
do_event (evt)
1999-07-07 20:19:36 +00:00
EventRecord *evt;
{
short part, err, rslt = 0;
WindowPtr win;
Boolean hit;
char key;
Point pnt;
switch (evt->what)
{
case mouseDown:
/* See if the click happened in a special part of the screen. */
part = FindWindow (evt->where, &win);
switch (part)
{
case inMenuBar:
adjust_menus ();
do_menu_command (MenuSelect (evt->where));
break;
case inSysWindow:
SystemClick (evt, win);
break;
case inContent:
if (win != FrontWindow ())
{
/* Bring the clicked-on window to the front. */
SelectWindow (win);
/* Fix the menu to match the new front window. */
adjust_menus ();
/* We always want to discard the event now, since clicks in a
1999-07-07 20:19:36 +00:00
windows are often irreversible actions. */
}
else
/* Mouse clicks in the front window do something useful. */
do_mouse_down (win, evt);
break;
case inDrag:
/* Standard drag behavior, no tricks necessary. */
DragWindow (win, evt->where, &dragrect);
break;
case inGrow:
grow_window (win, evt->where);
break;
case inZoomIn:
case inZoomOut:
zoom_window (win, evt->where, part);
break;
case inGoAway:
close_window (win);
break;
}
break;
case keyDown:
case autoKey:
key = evt->message & charCodeMask;
/* Check for menukey equivalents. */
if (evt->modifiers & cmdKey)
{
if (evt->what == keyDown)
{
adjust_menus ();
do_menu_command (MenuKey (key));
}
}
else
{
if (evt->what == keyDown)
{
/* Random keypress, interpret it. */
do_keyboard_command (key);
}
}
break;
case activateEvt:
activate_window ((WindowPtr) evt->message, evt->modifiers & activeFlag);
break;
case updateEvt:
update_window ((WindowPtr) evt->message);
break;
case diskEvt:
/* Call DIBadMount in response to a diskEvt, so that the user can format
1999-07-07 20:19:36 +00:00
a floppy. (from DTS Sample) */
if (HiWord (evt->message) != noErr)
{
SetPt (&pnt, 50, 50);
err = DIBadMount (pnt, evt->message);
}
break;
case app4Evt:
/* Grab only a single byte. */
switch ((evt->message >> 24) & 0xFF)
{
case 0xfa:
break;
case 1:
inbackground = !(evt->message & 1);
activate_window (FrontWindow (), !inbackground);
break;
}
break;
case kHighLevelEvent:
AEProcessAppleEvent (evt);
break;
case nullEvent:
do_idle ();
rslt = 1;
break;
default:
break;
}
return rslt;
}
/* Do any idle-time activities. */
do_idle ()
{
TEIdle (console_text);
}
grow_window (win, where)
1999-07-07 20:19:36 +00:00
WindowPtr win;
Point where;
{
long winsize;
int h, v;
GrafPtr oldport;
winsize = GrowWindow (win, where, &sizerect);
/* Only do anything if it actually changed size. */
if (winsize != 0)
{
GetPort (&oldport);
SetPort (win);
if (win == console_window)
{
EraseRect (&win->portRect);
h = LoWord (winsize);
v = HiWord (winsize);
SizeWindow (win, h, v, 1);
resize_console_window ();
}
SetPort (oldport);
}
}
zoom_window (win, where, part)
1999-07-07 20:19:36 +00:00
WindowPtr win;
Point where;
short part;
{
ZoomWindow (win, part, (win == FrontWindow ()));
if (win == console_window)
{
resize_console_window ();
}
}
resize_console_window ()
{
adjust_console_sizes ();
adjust_console_scrollbars ();
adjust_console_text ();
InvalRect (&console_window->portRect);
}
close_window (win)
1999-07-07 20:19:36 +00:00
WindowPtr win;
{
}
pascal void
v_scroll_proc (ControlHandle control, short part)
{
int oldval, amount = 0, newval;
int pagesize = ((*console_text)->viewRect.bottom - (*console_text)->viewRect.top) / (*console_text)->lineHeight;
if (part)
{
oldval = GetCtlValue (control);
switch (part)
{
case inUpButton:
amount = 1;
break;
case inDownButton:
amount = -1;
break;
case inPageUp:
amount = pagesize;
break;
case inPageDown:
1999-07-07 20:19:36 +00:00
amount = -pagesize;
break;
default:
/* (should freak out) */
break;
}
1999-07-07 20:19:36 +00:00
SetCtlValue (control, oldval - amount);
newval = GetCtlValue (control);
amount = oldval - newval;
if (amount)
TEScroll (0, amount * (*console_text)->lineHeight, console_text);
}
}
1999-07-07 20:19:36 +00:00
do_mouse_down (WindowPtr win, EventRecord * event)
{
short part, value;
Point mouse;
ControlHandle control;
1999-07-07 20:19:36 +00:00
if (1 /*is_app_window(win) */ )
{
SetPort (win);
mouse = event->where;
GlobalToLocal (&mouse);
1999-07-07 20:19:36 +00:00
part = FindControl (mouse, win, &control);
if (control == console_v_scrollbar)
{
switch (part)
{
case inThumb:
value = GetCtlValue (control);
part = TrackControl (control, mouse, nil);
if (part)
{
value -= GetCtlValue (control);
if (value)
1999-07-07 20:19:36 +00:00
TEScroll (0, value * (*console_text)->lineHeight,
console_text);
}
break;
default:
1999-07-07 20:19:36 +00:00
#if 0 /* don't deal with right now */
#if 1 /* universal headers */
value = TrackControl (control, mouse, (ControlActionUPP) v_scroll_proc);
#else
value = TrackControl (control, mouse, (ProcPtr) v_scroll_proc);
#endif
#endif
break;
}
}
else
{
TEClick (mouse, 0, console_text);
}
}
}
scroll_text (hlines, vlines)
1999-07-07 20:19:36 +00:00
int hlines, vlines;
{
}
activate_window (win, activate)
1999-07-07 20:19:36 +00:00
WindowPtr win;
int activate;
{
Rect grow_rect;
1999-07-07 20:19:36 +00:00
if (win == nil)
return;
/* It's convenient to make the activated window also be the
current GrafPort. */
if (activate)
1999-07-07 20:19:36 +00:00
SetPort (win);
/* Activate the console window's scrollbar. */
if (win == console_window)
{
if (activate)
{
TEActivate (console_text);
/* Cause the grow icon to be redrawn at the next update. */
grow_rect = console_window->portRect;
grow_rect.top = grow_rect.bottom - sbarwid;
grow_rect.left = grow_rect.right - sbarwid;
InvalRect (&grow_rect);
}
else
{
TEDeactivate (console_text);
DrawGrowIcon (console_window);
}
HiliteControl (console_v_scrollbar, (activate ? 0 : 255));
}
}
update_window (win)
1999-07-07 20:19:36 +00:00
WindowPtr win;
{
int controls = 1, growbox = 0;
GrafPtr oldport;
/* Set the updating window to be the current grafport. */
GetPort (&oldport);
SetPort (win);
/* recalc_depths(); */
BeginUpdate (win);
if (win == console_window)
{
draw_console ();
controls = 1;
growbox = 1;
}
if (controls)
UpdateControls (win, win->visRgn);
if (growbox)
DrawGrowIcon (win);
EndUpdate (win);
SetPort (oldport);
}
adjust_menus ()
{
}
do_menu_command (which)
1999-07-07 20:19:36 +00:00
long which;
{
short menuid, menuitem;
short itemHit;
Str255 daname;
short daRefNum;
Boolean handledbyda;
WindowPtr win;
short ditem;
int i;
char cmdbuf[300];
cmdbuf[0] = '\0';
menuid = HiWord (which);
menuitem = LoWord (which);
switch (menuid)
{
case mApple:
switch (menuitem)
{
case miAbout:
Alert (128, nil);
break;
#if 0
case miHelp:
/* (should pop up help info) */
break;
#endif
default:
GetItem (GetMHandle (mApple), menuitem, daname);
daRefNum = OpenDeskAcc (daname);
}
break;
case mFile:
switch (menuitem)
{
case miFileNew:
if (console_window == FrontWindow ())
{
close_window (console_window);
}
new_console_window ();
break;
case miFileOpen:
SysBeep (20);
break;
case miFileQuit:
ExitToShell ();
break;
}
break;
case mEdit:
/* handledbyda = SystemEdit(menuitem-1); */
switch (menuitem)
{
case miEditCut:
TECut (console_text);
break;
case miEditCopy:
TECopy (console_text);
break;
case miEditPaste:
TEPaste (console_text);
break;
case miEditClear:
TEDelete (console_text);
break;
}
/* All of these operations need the same postprocessing. */
adjust_console_sizes ();
adjust_console_scrollbars ();
adjust_console_text ();
break;
case mDebug:
switch (menuitem)
{
case miDebugTarget:
sprintf (cmdbuf, "target %s", "remote");
break;
case miDebugRun:
sprintf (cmdbuf, "run");
break;
case miDebugContinue:
sprintf (cmdbuf, "continue");
break;
case miDebugStep:
sprintf (cmdbuf, "step");
break;
case miDebugNext:
sprintf (cmdbuf, "next");
break;
}
break;
}
HiliteMenu (0);
/* Execute a command if one had been given. Do here because a command
may longjmp before we get a chance to unhilite the menu. */
if (strlen (cmdbuf) > 0)
execute_command (cmdbuf, 0);
}
char commandbuf[1000];
do_keyboard_command (key)
1999-07-07 20:19:36 +00:00
int key;
{
int startpos, endpos, i, len;
char *last_newline;
char buf[10], *text_str, *command, *cmd_start;
CharsHandle text;
if (key == '\015' || key == '\003')
{
text = TEGetText (console_text);
HLock ((Handle) text);
text_str = *text;
startpos = (*console_text)->selStart;
endpos = (*console_text)->selEnd;
if (startpos != endpos)
{
len = endpos - startpos;
cmd_start = text_str + startpos;
}
else
{
for (i = startpos - 1; i >= 0; --i)
if (text_str[i] == '\015')
break;
last_newline = text_str + i;
len = (text_str + startpos) - 1 - last_newline;
cmd_start = last_newline + 1;
}
1999-07-07 20:19:36 +00:00
if (len > 1000)
len = 999;
if (len < 0)
len = 0;
strncpy (commandbuf + 1, cmd_start, len);
commandbuf[1 + len] = 0;
command = commandbuf + 1;
HUnlock ((Handle) text);
1999-07-07 20:19:36 +00:00
commandbuf[0] = strlen (command);
/* Insert a newline and recalculate before doing any command. */
key = '\015';
TEKey (key, console_text);
TEInsert (buf, 1, console_text);
adjust_console_sizes ();
adjust_console_scrollbars ();
adjust_console_text ();
if (strlen (command) > 0)
{
execute_command (command, 0);
bpstat_do_actions (&stop_bpstat);
}
}
else
{
/* A self-inserting character. This includes delete. */
TEKey (key, console_text);
}
}
/* Draw all graphical stuff in the console window. */
draw_console ()
{
SetPort (console_window);
TEUpdate (&(console_window->portRect), console_text);
}
/* Cause an update of a given window's entire contents. */
force_update (win)
1999-07-07 20:19:36 +00:00
WindowPtr win;
{
GrafPtr oldport;
1999-07-07 20:19:36 +00:00
if (win == nil)
return;
GetPort (&oldport);
SetPort (win);
EraseRect (&win->portRect);
InvalRect (&win->portRect);
SetPort (oldport);
}
adjust_console_sizes ()
{
Rect tmprect;
tmprect = console_window->portRect;
/* Move and size the scrollbar. */
MoveControl (console_v_scrollbar, tmprect.right - sbarwid, 0);
SizeControl (console_v_scrollbar, sbarwid + 1, tmprect.bottom - sbarwid + 1);
/* Move and size the text. */
tmprect.left += 7;
tmprect.right -= sbarwid;
tmprect.bottom -= sbarwid;
1999-07-07 20:19:36 +00:00
InsetRect (&tmprect, 1, 1);
(*console_text)->destRect = tmprect;
/* Fiddle bottom of viewrect to be even multiple of text lines. */
tmprect.bottom = tmprect.top
+ ((tmprect.bottom - tmprect.top) / (*console_text)->lineHeight)
1999-07-07 20:19:36 +00:00
* (*console_text)->lineHeight;
(*console_text)->viewRect = tmprect;
}
adjust_console_scrollbars ()
{
int lines, newmax, value;
(*console_v_scrollbar)->contrlVis = 0;
lines = (*console_text)->nLines;
newmax = lines - (((*console_text)->viewRect.bottom
- (*console_text)->viewRect.top)
/ (*console_text)->lineHeight);
1999-07-07 20:19:36 +00:00
if (newmax < 0)
newmax = 0;
SetCtlMax (console_v_scrollbar, newmax);
value = ((*console_text)->viewRect.top - (*console_text)->destRect.top)
/ (*console_text)->lineHeight;
SetCtlValue (console_v_scrollbar, value);
(*console_v_scrollbar)->contrlVis = 0xff;
ShowControl (console_v_scrollbar);
}
/* Scroll the TE record so that it is consistent with the scrollbar(s). */
adjust_console_text ()
{
TEScroll (((*console_text)->viewRect.left
- (*console_text)->destRect.left)
1999-07-07 20:19:36 +00:00
- 0 /* get h scroll value */ ,
((((*console_text)->viewRect.top - (*console_text)->destRect.top)
/ (*console_text)->lineHeight)
- GetCtlValue (console_v_scrollbar))
* (*console_text)->lineHeight,
console_text);
}
/* Readline substitute. */
char *
readline (char *prrompt)
{
return gdb_readline (prrompt);
}
char *rl_completer_word_break_characters;
char *rl_completer_quote_characters;
int (*rl_completion_entry_function) ();
int rl_point;
char *rl_line_buffer;
char *rl_readline_name;
/* History substitute. */
void
add_history (char *buf)
{
}
void
stifle_history (int n)
{
}
int
unstifle_history ()
{
}
int
read_history (char *name)
{
}
int
write_history (char *name)
{
}
int
history_expand (char *x, char **y)
{
}
extern HIST_ENTRY *
history_get (int xxx)
{
return NULL;
}
int history_base;
char *
filename_completion_function (char *text, char *name)
{
return "?";
}
char *
tilde_expand (char *str)
{
return strsave (str);
}
/* Modified versions of standard I/O. */
#undef fprintf
int
1999-07-07 20:19:36 +00:00
hacked_fprintf (FILE * fp, const char *fmt,...)
{
int ret;
va_list ap;
va_start (ap, fmt);
if (mac_app && (fp == stdout || fp == stderr))
{
char buf[1000];
1999-07-07 20:19:36 +00:00
ret = vsprintf (buf, fmt, ap);
TEInsert (buf, strlen (buf), console_text);
}
else
ret = vfprintf (fp, fmt, ap);
va_end (ap);
return ret;
}
#undef printf
int
1999-07-07 20:19:36 +00:00
hacked_printf (const char *fmt,...)
{
int ret;
va_list ap;
va_start (ap, fmt);
1999-07-07 20:19:36 +00:00
ret = hacked_vfprintf (stdout, fmt, ap);
va_end (ap);
return ret;
}
#undef vfprintf
1999-07-07 20:19:36 +00:00
int
hacked_vfprintf (FILE * fp, const char *format, va_list args)
{
if (mac_app && (fp == stdout || fp == stderr))
{
char buf[1000];
int ret;
1999-07-07 20:19:36 +00:00
ret = vsprintf (buf, format, args);
TEInsert (buf, strlen (buf), console_text);
if (strchr (buf, '\n'))
{
adjust_console_sizes ();
adjust_console_scrollbars ();
adjust_console_text ();
}
return ret;
}
else
return vfprintf (fp, format, args);
}
#undef fputs
1999-07-07 20:19:36 +00:00
hacked_fputs (const char *s, FILE * fp)
{
if (mac_app && (fp == stdout || fp == stderr))
{
1999-07-07 20:19:36 +00:00
TEInsert (s, strlen (s), console_text);
if (strchr (s, '\n'))
{
adjust_console_sizes ();
adjust_console_scrollbars ();
adjust_console_text ();
}
return 0;
}
else
return fputs (s, fp);
}
#undef fputc
1999-07-07 20:19:36 +00:00
hacked_fputc (const char c, FILE * fp)
{
if (mac_app && (fp == stdout || fp == stderr))
{
char buf[1];
buf[0] = c;
TEInsert (buf, 1, console_text);
if (c == '\n')
{
adjust_console_sizes ();
adjust_console_scrollbars ();
adjust_console_text ();
}
return c;
}
else
return fputc (c, fp);
}
#undef putc
1999-07-07 20:19:36 +00:00
hacked_putc (const char c, FILE * fp)
{
if (mac_app && (fp == stdout || fp == stderr))
{
char buf[1];
buf[0] = c;
TEInsert (buf, 1, console_text);
if (c == '\n')
{
adjust_console_sizes ();
adjust_console_scrollbars ();
adjust_console_text ();
}
return c;
}
else
return fputc (c, fp);
}
#undef fflush
1999-07-07 20:19:36 +00:00
hacked_fflush (FILE * fp)
{
if (mac_app && (fp == stdout || fp == stderr))
{
adjust_console_sizes ();
adjust_console_scrollbars ();
adjust_console_text ();
return 0;
}
return fflush (fp);
}
#undef fgetc
1999-07-07 20:19:36 +00:00
hacked_fgetc (FILE * fp)
{
if (mac_app && (fp == stdin))
{
/* Catch any attempts to use this. */
1999-07-07 20:19:36 +00:00
DebugStr ("\pShould not be reading from stdin!");
return '\n';
}
return fgetc (fp);
}