2008-10-06 03:48:37 +00:00
|
|
|
/* Copyright 1994, 1995 by Abacus Research and
|
|
|
|
* Development, Inc. All rights reserved.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#if !defined (OMIT_RCSID_STRINGS)
|
|
|
|
char ROMlib_rcsid_dump[] =
|
|
|
|
"$Id: dump.c 88 2005-05-25 03:59:37Z ctm $";
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if !defined (NDEBUG)
|
|
|
|
|
|
|
|
/* dump.c; convenience functions for dumping various mac datastructures */
|
|
|
|
|
|
|
|
#if !defined (THINK_C)
|
|
|
|
/* executor */
|
|
|
|
#include "rsys/common.h"
|
|
|
|
#include "QuickDraw.h"
|
|
|
|
#include "CQuickDraw.h"
|
|
|
|
#include "MemoryMgr.h"
|
|
|
|
#include "DialogMgr.h"
|
|
|
|
#include "ControlMgr.h"
|
|
|
|
#include "MenuMgr.h"
|
2009-06-15 02:58:21 +00:00
|
|
|
#include "FileMgr.h"
|
2008-10-06 03:48:37 +00:00
|
|
|
|
|
|
|
#include "rsys/cquick.h"
|
|
|
|
#include "rsys/wind.h"
|
|
|
|
#include "rsys/ctl.h"
|
|
|
|
#include "rsys/itm.h"
|
|
|
|
#include "rsys/menu.h"
|
|
|
|
#include "rsys/dump.h"
|
|
|
|
#include "rsys/string.h"
|
|
|
|
#include "rsys/mman_private.h"
|
|
|
|
|
|
|
|
#include "rsys/print.h"
|
|
|
|
|
|
|
|
#define deref(x) STARH (x)
|
|
|
|
|
|
|
|
#define pmWindow(p) ((p)->pmWindow)
|
|
|
|
#define pmPrivate(p) ((p)->pmPrivate)
|
|
|
|
#define pmDevices(p) ((p)->pmDevices)
|
|
|
|
#define pmSeeds(p) ((p)->pmSeeds)
|
|
|
|
|
|
|
|
#define ciFlags(ci) ((ci)->ciFlags)
|
|
|
|
#define ciPrivate(ci) ((ci)->ciPrivate)
|
|
|
|
|
|
|
|
#else /* mac */
|
|
|
|
|
|
|
|
#define deref(x) (*(x))
|
|
|
|
#define Cx(x) (x)
|
|
|
|
#define CW(x) (x)
|
|
|
|
#define CWC(x) (x)
|
|
|
|
#define CL(x) (x)
|
|
|
|
#define CLC(x) (x)
|
|
|
|
#define theCPort ((CGrafPtr) thePort)
|
|
|
|
#define CGrafPort_p(port) (((char *)(port))[6] & 0xC0)
|
|
|
|
|
|
|
|
#define ROWBYTES_VALUE_BITS (0x3FFF)
|
|
|
|
|
|
|
|
#define RECT_HEIGHT(r) (CW ((r)->bottom) - CW ((r)->top))
|
|
|
|
#define RECT_WIDTH(r) (CW ((r)->right) - CW ((r)->left))
|
|
|
|
|
|
|
|
/* window accessors */
|
|
|
|
#define WINDOW_PORT(wp) (&((WindowPeek) (wp))->port)
|
|
|
|
#define CWINDOW_PORT(wp) (&((WindowPeek) (wp))->port)
|
|
|
|
|
|
|
|
/* big endian byte order */
|
|
|
|
#define WINDOW_KIND_X(wp) (((WindowPeek) (wp))->windowKind)
|
|
|
|
#define WINDOW_VISIBLE_X(wp) (((WindowPeek) (wp))->visible)
|
|
|
|
#define WINDOW_HILITED_X(wp) (((WindowPeek) (wp))->hilited)
|
|
|
|
#define WINDOW_GO_AWAY_FLAG_X(wp) (((WindowPeek) (wp))->goAwayFlag)
|
|
|
|
#define WINDOW_SPARE_FLAG_X(wp) (((WindowPeek) (wp))->spareFlag)
|
|
|
|
|
|
|
|
#define WINDOW_STRUCT_REGION_X(wp) (((WindowPeek) (wp))->strucRgn)
|
|
|
|
#define WINDOW_CONT_REGION_X(wp) (((WindowPeek) (wp))->contRgn)
|
|
|
|
#define WINDOW_UPDATE_REGION_X(wp) (((WindowPeek) (wp))->updateRgn)
|
|
|
|
#define WINDOW_DEF_PROC_X(wp) (((WindowPeek) (wp))->windowDefProc)
|
|
|
|
#define WINDOW_DATA_X(wp) (((WindowPeek) (wp))->dataHandle)
|
|
|
|
#define WINDOW_TITLE_X(wp) (((WindowPeek) (wp))->titleHandle)
|
|
|
|
#define WINDOW_TITLE_WIDTH_X(wp) (((WindowPeek) (wp))->titleWidth)
|
|
|
|
#define WINDOW_CONTROL_LIST_X(wp) (((WindowPeek) (wp))->controlList)
|
|
|
|
#define WINDOW_NEXT_WINDOW_X(wp) (((WindowPeek) (wp))->nextWindow)
|
|
|
|
#define WINDOW_PIC_X(wp) (((WindowPeek) (wp))->windowPic)
|
|
|
|
#define WINDOW_REF_CON_X(wp) (((WindowPeek) (wp))->refCon)
|
|
|
|
|
|
|
|
/* native byte order */
|
|
|
|
#define WINDOW_KIND(wp) (Cx (WINDOW_KIND_X (wp)))
|
|
|
|
#define WINDOW_VISIBLE(wp) (Cx (WINDOW_VISIBLE_X (wp)))
|
|
|
|
#define WINDOW_HILITED(wp) (Cx (WINDOW_HILITED_X (wp)))
|
|
|
|
#define WINDOW_GO_AWAY_FLAG(wp) (Cx (WINDOW_GO_AWAY_FLAG_X (wp)))
|
|
|
|
#define WINDOW_SPARE_FLAG(wp) (Cx (WINDOW_SPARE_FLAG_X (wp)))
|
|
|
|
|
|
|
|
#define WINDOW_STRUCT_REGION(wp) (Cx (WINDOW_STRUCT_REGION_X (wp)))
|
|
|
|
#define WINDOW_CONT_REGION(wp) (Cx (WINDOW_CONT_REGION_X (wp)))
|
|
|
|
#define WINDOW_UPDATE_REGION(wp) (Cx (WINDOW_UPDATE_REGION_X (wp)))
|
|
|
|
#define WINDOW_DEF_PROC(wp) (Cx (WINDOW_DEF_PROC_X (wp)))
|
|
|
|
#define WINDOW_DATA(wp) (Cx (WINDOW_DATA_X (wp)))
|
|
|
|
#define WINDOW_TITLE(wp) (Cx (WINDOW_TITLE_X (wp)))
|
|
|
|
#define WINDOW_TITLE_WIDTH(wp) (Cx (WINDOW_TITLE_WIDTH_X (wp)))
|
|
|
|
#define WINDOW_CONTROL_LIST(wp) (Cx (WINDOW_CONTROL_LIST_X (wp)))
|
|
|
|
#define WINDOW_NEXT_WINDOW(wp) (Cx (WINDOW_NEXT_WINDOW_X (wp)))
|
|
|
|
#define WINDOW_PIC(wp) (Cx (WINDOW_PIC_X (wp)))
|
|
|
|
#define WINDOW_REF_CON(wp) (Cx (WINDOW_REF_CON_X (wp)))
|
|
|
|
|
|
|
|
/* dialog accessors */
|
|
|
|
#define DIALOG_WINDOW(dialog) ((WindowPtr) &((DialogPeek) (dialog))->window)
|
|
|
|
|
|
|
|
#define DIALOG_ITEMS_X(dialog) (((DialogPeek) (dialog))->items)
|
|
|
|
#define DIALOG_TEXTH_X(dialog) (((DialogPeek) (dialog))->textH)
|
|
|
|
#define DIALOG_EDIT_FIELD_X(dialog) (((DialogPeek) (dialog))->editField)
|
|
|
|
#define DIALOG_EDIT_OPEN_X(dialog) (((DialogPeek) (dialog))->editOpen)
|
|
|
|
#define DIALOG_ADEF_ITEM_X(dialog) (((DialogPeek) (dialog))->aDefItem)
|
|
|
|
|
|
|
|
#define DIALOG_ITEMS(dialog) (CL (DIALOG_ITEMS_X (dialog)))
|
|
|
|
#define DIALOG_TEXTH(dialog) (CL (DIALOG_TEXTH_X (dialog)))
|
|
|
|
#define DIALOG_EDIT_FIELD(dialog) (CW (DIALOG_EDIT_FIELD_X (dialog)))
|
|
|
|
#define DIALOG_EDIT_OPEN(dialog) (CW (DIALOG_EDIT_OPEN_X (dialog)))
|
|
|
|
#define DIALOG_ADEF_ITEM(dialog) (CW (DIALOG_ADEF_ITEM_X (dialog)))
|
|
|
|
|
|
|
|
enum pixpat_pattern_types
|
|
|
|
{
|
|
|
|
pixpat_type_orig = 0,
|
|
|
|
pixpat_type_color = 1,
|
|
|
|
pixpat_type_rgb = 2
|
|
|
|
};
|
|
|
|
|
|
|
|
#define pmWindow(p) (*(GrafPtr *) (&(p)->pmDataFields[0]))
|
|
|
|
#define pmPrivate(p) (*(short *) (&(p)->pmDataFields[2]))
|
|
|
|
#define pmDevices(p) (*(long *) (&(p)->pmDataFields[3]))
|
|
|
|
#define pmSeeds(p) (*(long *) (&(p)->pmDataFields[5]))
|
|
|
|
|
|
|
|
#define ciFlags(ci) (*(short *) (&(ci)->ciDataFields[0]))
|
|
|
|
#define ciPrivate(ci) (*(long *) (&(ci)->ciDataFields[1]))
|
|
|
|
|
|
|
|
#include "dump.h"
|
|
|
|
#endif /* mac */
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
FILE *o_fp = NULL;
|
|
|
|
|
|
|
|
#ifdef MSDOS
|
|
|
|
/* useful for overriding when under dos */
|
|
|
|
FILE *stderr_fp = stderr;
|
|
|
|
FILE *stdout_fp = stdout;
|
|
|
|
#endif /* MSDOS */
|
|
|
|
|
|
|
|
static int indent = 0;
|
|
|
|
|
|
|
|
static char *field_name = "";
|
|
|
|
|
|
|
|
/* dump everything recursively; but no ctab tables... */
|
|
|
|
enum dump_flags
|
|
|
|
{
|
|
|
|
dump_normal_flag = 1,
|
|
|
|
dump_bitmap_data_flag = 2,
|
|
|
|
dump_ctab_flag = 4,
|
|
|
|
dump_xfields_flag = 8,
|
|
|
|
dump_pixpat_fields_flag = 16
|
|
|
|
};
|
|
|
|
|
|
|
|
int dump_verbosity = 1;
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_set_field (int field)
|
|
|
|
{
|
|
|
|
dump_verbosity |= field;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_clear_field (int field)
|
|
|
|
{
|
|
|
|
dump_verbosity &= ~field;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define dump_field(dump_fn, dump_arg, field) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
field_name = field" "; \
|
|
|
|
dump_fn (dump_arg); \
|
|
|
|
field_name = ""; \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define iprintf(args) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
dump_spaces (indent); \
|
|
|
|
fprintf args; \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
Rect big_rect = { CWC (-32767), CWC (-32767), CWC (32767), CWC (32767) };
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_init (char *dst)
|
|
|
|
{
|
|
|
|
if (dst)
|
|
|
|
{
|
|
|
|
o_fp = Ufopen (dst, "w");
|
|
|
|
if (o_fp == NULL)
|
|
|
|
exit (1);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
o_fp = stderr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_finish (void)
|
|
|
|
{
|
|
|
|
fflush (o_fp);
|
|
|
|
if (o_fp != stderr)
|
|
|
|
fclose (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
dump_spaces (int nspaces)
|
|
|
|
{
|
|
|
|
while (nspaces --)
|
|
|
|
fputc (' ', o_fp);
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_ptr_real (Ptr x)
|
|
|
|
{
|
|
|
|
if (x)
|
|
|
|
iprintf ((o_fp, "%s%p[0x%lx]\n", field_name, x,
|
|
|
|
(long) GetPtrSize (x)));
|
|
|
|
else
|
|
|
|
iprintf ((o_fp, "%s%p\n", field_name, x));
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_handle_real (Handle x)
|
|
|
|
{
|
|
|
|
if (x)
|
|
|
|
iprintf ((o_fp, "%s%p[0x%x] (%p)\n", field_name, x,
|
|
|
|
GetHandleSize (x), deref (x)));
|
|
|
|
else
|
|
|
|
iprintf ((o_fp, "%s%p\n", field_name, x));
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_rect (Rect *r)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "%s(Rect *%p) {\n", field_name, r)); indent += 2;
|
|
|
|
iprintf ((o_fp, "top 0x%x; left 0x%x;\n", CW (r->top), CW (r->left)));
|
|
|
|
iprintf ((o_fp, "bottom 0x%x; right 0x%x; }\n",
|
|
|
|
CW (r->bottom), CW (r->right))); indent -= 2;
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_pattern (Pattern x)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "%s0x%02x%02x%02x%02x%02x%02x%02x%02x;\n", field_name,
|
|
|
|
x[0], x[1], x[2], x[3],
|
|
|
|
x[4], x[5], x[6], x[7]));
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_point (Point x)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "%s(Point) { v 0x%x; h 0x%x; }\n",
|
|
|
|
field_name, CW (x.v), CW (x.h)));
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_bitmap_data (BitMap *x, int depth, Rect *rect)
|
|
|
|
{
|
|
|
|
int rows, bytes_per_row;
|
|
|
|
int row_bytes;
|
|
|
|
int r, rb;
|
|
|
|
char *addr;
|
|
|
|
|
|
|
|
iprintf ((o_fp, "...%s data\n", field_name)); indent += 2;
|
|
|
|
|
|
|
|
if (!rect)
|
|
|
|
rect = &x->bounds;
|
|
|
|
|
|
|
|
row_bytes = CW (x->rowBytes) & ROWBYTES_VALUE_BITS;
|
|
|
|
addr = (char *)
|
|
|
|
&MR (x->baseAddr)[(CW (rect->top) - CW (x->bounds.top)) * row_bytes
|
|
|
|
+ ((CW (rect->left) - CW (x->bounds.left))
|
|
|
|
* depth) / 8];
|
|
|
|
rows = RECT_HEIGHT (&x->bounds);
|
|
|
|
bytes_per_row = (RECT_WIDTH (&x->bounds) * depth + 7) / 8;
|
|
|
|
|
|
|
|
for (r = 0; r < rows; r ++)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "%p: ", addr));
|
|
|
|
for (rb = 0; rb < bytes_per_row; rb ++)
|
|
|
|
{
|
|
|
|
char byte;
|
|
|
|
static const char x_digit[] =
|
|
|
|
{
|
|
|
|
'0', '1', '2', '3', '4', '5', '6', '7',
|
|
|
|
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
|
|
|
|
};
|
|
|
|
|
|
|
|
byte = addr[rb];
|
|
|
|
fprintf (o_fp, "%c%c",
|
|
|
|
x_digit[(byte >> 4) & 15], x_digit[byte & 15]);
|
|
|
|
}
|
|
|
|
fprintf (o_fp, "\n");
|
|
|
|
addr += row_bytes;
|
|
|
|
}
|
|
|
|
indent -= 2;
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_bits16 (Bits16 data)
|
|
|
|
{
|
|
|
|
if (dump_verbosity >= 3)
|
|
|
|
{
|
|
|
|
BitMap x;
|
|
|
|
|
|
|
|
x.baseAddr = RM ((Ptr) data);
|
|
|
|
x.rowBytes = CWC (2);
|
|
|
|
x.bounds.top = x.bounds.left = 0;
|
|
|
|
x.bounds.bottom = CWC (16);
|
|
|
|
x.bounds.right = CWC (16);
|
|
|
|
|
|
|
|
dump_bitmap_data (&x, 1, NULL);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
iprintf ((o_fp, "[%s field omitted]\n", field_name));
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_bitmap (BitMap *x, Rect *rect)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "%s(BitMap *%p) {\n", field_name, x)); indent += 2;
|
|
|
|
iprintf ((o_fp, "baseAddr %p;\n", MR (x->baseAddr)));
|
|
|
|
if (dump_verbosity >= 3)
|
|
|
|
dump_bitmap_data (x, 1, rect);
|
|
|
|
iprintf ((o_fp, "rowBytes 0x%hx;\n", (unsigned short) CW (x->rowBytes)));
|
|
|
|
dump_field (dump_rect, &x->bounds, "bounds");
|
|
|
|
indent -= 2; iprintf ((o_fp, "}\n"));
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_bitmap_null_rect (BitMap *x)
|
|
|
|
{
|
|
|
|
dump_bitmap (x, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_grafport (GrafPtr x)
|
|
|
|
{
|
|
|
|
if (CGrafPort_p (x))
|
|
|
|
dump_cgrafport_real ((CGrafPtr) x);
|
|
|
|
else
|
|
|
|
dump_grafport_real (x);
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_qdprocs (QDProcsPtr x)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "%s(QDProcsPtr *%p) {\n", field_name, x)); indent += 2;
|
|
|
|
if (x != NULL)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "textProc %p;\n", MR (x->textProc)));
|
|
|
|
iprintf ((o_fp, "lineProc %p;\n", MR (x->lineProc)));
|
|
|
|
iprintf ((o_fp, "rectProc %p;\n", MR (x->rectProc)));
|
|
|
|
iprintf ((o_fp, "rRectProc %p;\n", MR (x->rRectProc)));
|
|
|
|
iprintf ((o_fp, "ovalProc %p;\n", MR (x->ovalProc)));
|
|
|
|
iprintf ((o_fp, "arcProc %p;\n", MR (x->arcProc)));
|
|
|
|
iprintf ((o_fp, "polyProc %p;\n", MR (x->polyProc)));
|
|
|
|
iprintf ((o_fp, "rgnProc %p;\n", MR (x->rgnProc)));
|
|
|
|
iprintf ((o_fp, "bitsProc %p;\n", MR (x->bitsProc)));
|
|
|
|
iprintf ((o_fp, "commentProc %p;\n", MR (x->commentProc)));
|
|
|
|
iprintf ((o_fp, "txMeasProc %p;\n", MR (x->txMeasProc)));
|
|
|
|
iprintf ((o_fp, "getPicProc %p;\n", MR (x->getPicProc)));
|
|
|
|
iprintf ((o_fp, "putPicProc %p;\n", MR (x->putPicProc)));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
iprintf ((o_fp, "<default grafprocs used>\n"));
|
|
|
|
indent -= 2; iprintf ((o_fp, "}\n"));
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_grafport_real (GrafPtr x)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "%s(GrafPort *%p) {\n", field_name, x)); indent += 2;
|
|
|
|
iprintf ((o_fp, "device %d;\n", CW (x->device)));
|
|
|
|
dump_field (dump_bitmap_null_rect, &x->portBits, "portBits");
|
|
|
|
dump_field (dump_rect, &x->portRect, "portRect");
|
|
|
|
dump_field (dump_handle, MR (x->visRgn), "visRgn");
|
|
|
|
dump_field (dump_handle, MR (x->clipRgn), "clipRgn");
|
|
|
|
dump_field (dump_pattern, x->bkPat, "bkPat");
|
|
|
|
dump_field (dump_pattern, x->fillPat, "fillPat");
|
|
|
|
dump_field (dump_point, x->pnLoc, "pnLoc");
|
|
|
|
dump_field (dump_point, x->pnSize, "pnSize");
|
|
|
|
iprintf ((o_fp, "pnMode %d;\n", CW (x->pnMode)));
|
|
|
|
dump_field (dump_pattern, x->pnPat, "pnPat");
|
|
|
|
iprintf ((o_fp, "pnVis %d;\n", CW (x->pnVis)));
|
|
|
|
iprintf ((o_fp, "txFont %d;\n", CW (x->txFont)));
|
|
|
|
iprintf ((o_fp, "txFace %d;\n", x->txFace));
|
|
|
|
iprintf ((o_fp, "txMode %d;\n", CW (x->txMode)));
|
|
|
|
iprintf ((o_fp, "txSize %d;\n", CW (x->txSize)));
|
|
|
|
iprintf ((o_fp, "spExtra %d;\n", CL (x->spExtra)));
|
|
|
|
iprintf ((o_fp, "fgColor 0x%x;\n", CL (x->fgColor)));
|
|
|
|
iprintf ((o_fp, "bkColor 0x%x;\n", CL (x->bkColor)));
|
|
|
|
iprintf ((o_fp, "colrBit %d;\n", CW (x->colrBit)));
|
|
|
|
iprintf ((o_fp, "patStretch %d;\n", CW (x->patStretch)));
|
|
|
|
dump_field (dump_handle, MR (x->picSave), "picSave");
|
|
|
|
dump_field (dump_handle, MR (x->rgnSave), "rgnSave");
|
|
|
|
dump_field (dump_handle, MR (x->polySave), "polySave");
|
|
|
|
dump_field (dump_qdprocs, MR (x->grafProcs), "grafProcs");
|
|
|
|
indent -= 2; iprintf ((o_fp, "}\n"));
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
GrafPtr
|
|
|
|
theport (void)
|
|
|
|
{
|
|
|
|
return thePort;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_theport (void)
|
|
|
|
{
|
|
|
|
dump_grafport (thePort);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_rgb_color (RGBColor *x)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "%s(RGBColor) { red 0x%lx; green 0x%lx, blue 0x%lx; }\n",
|
|
|
|
field_name,
|
|
|
|
(long) CW (x->red),
|
|
|
|
(long) CW (x->green),
|
|
|
|
(long) CW (x->blue)));
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_ctab (CTabHandle ctab)
|
|
|
|
{
|
|
|
|
CTabPtr x = deref (ctab);
|
|
|
|
|
|
|
|
iprintf ((o_fp, "%s(ColorTable **%p) {\n", field_name, ctab)); indent += 2;
|
|
|
|
iprintf ((o_fp, "ctSeed 0x%x;\n", CL (x->ctSeed)));
|
|
|
|
iprintf ((o_fp, "ctFlags 0x%x;\n", CW (x->ctFlags)));
|
|
|
|
iprintf ((o_fp, "ctSize %d;\n", CW (x->ctSize)));
|
|
|
|
if (dump_verbosity >= 2)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
iprintf ((o_fp, "ctTable\n"));
|
|
|
|
for (i = 0; i <= CW (x->ctSize); i ++)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "%d:[0x%x] { 0x%lx, 0x%lx, 0x%lx }\n",
|
|
|
|
i, CW (x->ctTable[i].value),
|
|
|
|
(long) CW (x->ctTable[i].rgb.red),
|
|
|
|
(long) CW (x->ctTable[i].rgb.green),
|
|
|
|
(long) CW (x->ctTable[i].rgb.blue)));
|
|
|
|
}
|
|
|
|
indent -= 2; iprintf ((o_fp, "}\n"));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "[ctTable field omitted]; }\n")); indent -= 2;
|
|
|
|
}
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_itab (ITabHandle itab)
|
|
|
|
{
|
|
|
|
ITabPtr x = deref (itab);
|
|
|
|
|
|
|
|
iprintf ((o_fp, "%s(ITab **%p) {\n", field_name, itab)); indent += 2;
|
|
|
|
iprintf ((o_fp, "iTabSeed 0x%x;\n", CL (x->iTabSeed)));
|
|
|
|
iprintf ((o_fp, "iTabRes %d;\n", CW (x->iTabRes)));
|
|
|
|
|
|
|
|
/* we always omit the inverse table... */
|
|
|
|
iprintf ((o_fp, "[iTTable field omitted]; }\n")); indent -= 2;
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_pixpat (PixPatHandle pixpat)
|
|
|
|
{
|
|
|
|
PixPatPtr x = deref (pixpat);
|
|
|
|
|
|
|
|
iprintf ((o_fp, "%s(PixPat **%p) {\n", field_name, pixpat)); indent += 2;
|
|
|
|
iprintf ((o_fp, "patType %s;\n",
|
|
|
|
x->patType == CWC (pixpat_old_style_pattern)
|
|
|
|
? "old_style_pattern"
|
|
|
|
: (x->patType == CWC (pixpat_color_pattern)
|
|
|
|
? "color_pattern"
|
|
|
|
: (x->patType == CWC (pixpat_rgb_pattern)
|
|
|
|
? "rgb_pattern"
|
|
|
|
: "<unknown!>"))));
|
|
|
|
|
|
|
|
if (x->patType != CWC (pixpat_type_orig))
|
|
|
|
{
|
|
|
|
if (dump_verbosity
|
|
|
|
&& x->patMap)
|
|
|
|
dump_field (dump_pixmap_null_rect, MR (x->patMap), "patMap");
|
|
|
|
else
|
|
|
|
dump_field (dump_handle, MR (x->patMap), "patMap");
|
|
|
|
dump_field (dump_handle, MR (x->patData), "patData");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "[pat{Map, Data} field omitted]; }\n"));
|
|
|
|
}
|
|
|
|
dump_field (dump_handle, MR (x->patXData), "patXData");
|
|
|
|
iprintf ((o_fp, "patXValid %d;\n", CW (x->patXValid)));
|
|
|
|
if (dump_verbosity
|
|
|
|
&& x->patXMap
|
|
|
|
&& !x->patXValid)
|
|
|
|
dump_field (dump_pixmap_null_rect, (PixMapHandle) MR (x->patXMap),
|
|
|
|
"patXMap");
|
|
|
|
else
|
|
|
|
dump_field (dump_handle, MR (x->patXMap), "patXMap");
|
|
|
|
dump_field (dump_pattern, x->pat1Data, "pat1Data");
|
|
|
|
indent -= 2; iprintf ((o_fp, "}\n"));
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_pixmap_ptr (PixMapPtr x, Rect *rect)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "%s(PixMap *%p) {\n", field_name, x)); indent += 2;
|
|
|
|
iprintf ((o_fp, "baseAddr %p;\n", MR (x->baseAddr)));
|
|
|
|
if (dump_verbosity >= 3
|
|
|
|
&& x->baseAddr)
|
|
|
|
{
|
|
|
|
if (!rect)
|
|
|
|
rect = &x->bounds;
|
|
|
|
dump_bitmap_data ((BitMap *) x, CW (x->pixelSize), rect);
|
|
|
|
}
|
|
|
|
iprintf ((o_fp, "rowBytes 0x%hx;\n", (unsigned short) CW (x->rowBytes)));
|
|
|
|
dump_field (dump_rect, &x->bounds, "bounds");
|
|
|
|
iprintf ((o_fp, "pmVersion 0x%x;\n", CW (x->pmVersion)));
|
|
|
|
iprintf ((o_fp, "packType 0x%x;\n", CW (x->packType)));
|
|
|
|
iprintf ((o_fp, "packSize 0x%x;\n", CW (x->packSize)));
|
|
|
|
iprintf ((o_fp, "hRes 0x%x, vRes 0x%x;\n",
|
|
|
|
CW (x->hRes), CW (x->vRes)));
|
|
|
|
iprintf ((o_fp, "pixelType 0x%x;\n", CW (x->pixelType)));
|
|
|
|
iprintf ((o_fp, "pixelSize %d;\n", CW (x->pixelSize)));
|
|
|
|
iprintf ((o_fp, "cmpCount %d;\n", CW (x->cmpCount)));
|
|
|
|
iprintf ((o_fp, "cmpSize %d;\n", CW (x->cmpSize)));
|
|
|
|
iprintf ((o_fp, "planeBytes 0x%x;\n", CL (x->planeBytes)));
|
|
|
|
if (dump_verbosity
|
|
|
|
&& x->pmTable)
|
|
|
|
dump_field (dump_ctab, MR (x->pmTable), "pmTable");
|
|
|
|
else
|
|
|
|
dump_field (dump_handle, MR (x->pmTable), "pmTable");
|
|
|
|
iprintf ((o_fp, "[Reserved field omitted]; }\n")); indent -= 2;
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_pixmap_null_rect (PixMapHandle pixmap)
|
|
|
|
{
|
|
|
|
dump_pixmap (pixmap, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_pixmap (PixMapHandle pixmap, Rect *rect)
|
|
|
|
{
|
|
|
|
PixMapPtr x = deref (pixmap);
|
|
|
|
|
|
|
|
iprintf ((o_fp, "%s(PixMap **%p) {\n", field_name, pixmap)); indent += 2;
|
|
|
|
iprintf ((o_fp, "baseAddr %p;\n", MR (x->baseAddr)));
|
|
|
|
if (dump_verbosity >= 3
|
|
|
|
&& x->baseAddr)
|
|
|
|
{
|
|
|
|
if (!rect)
|
|
|
|
rect = &x->bounds;
|
|
|
|
dump_bitmap_data ((BitMap *) x, CW (x->pixelSize), rect);
|
|
|
|
}
|
|
|
|
iprintf ((o_fp, "rowBytes 0x%hx;\n", (unsigned short) CW (x->rowBytes)));
|
|
|
|
dump_field (dump_rect, &x->bounds, "bounds");
|
|
|
|
iprintf ((o_fp, "pmVersion 0x%x;\n", CW (x->pmVersion)));
|
|
|
|
iprintf ((o_fp, "packType 0x%x;\n", CW (x->packType)));
|
|
|
|
iprintf ((o_fp, "packSize 0x%x;\n", CW (x->packSize)));
|
|
|
|
iprintf ((o_fp, "hRes 0x%x, vRes 0x%x;\n",
|
|
|
|
CW (x->hRes), CW (x->vRes)));
|
|
|
|
iprintf ((o_fp, "pixelType 0x%x;\n", CW (x->pixelType)));
|
|
|
|
iprintf ((o_fp, "pixelSize %d;\n", CW (x->pixelSize)));
|
|
|
|
iprintf ((o_fp, "cmpCount %d;\n", CW (x->cmpCount)));
|
|
|
|
iprintf ((o_fp, "cmpSize %d;\n", CW (x->cmpSize)));
|
|
|
|
iprintf ((o_fp, "planeBytes 0x%x;\n", CL (x->planeBytes)));
|
|
|
|
if (dump_verbosity
|
|
|
|
&& x->pmTable)
|
|
|
|
dump_field (dump_ctab, MR (x->pmTable), "pmTable");
|
|
|
|
else
|
|
|
|
dump_field (dump_handle, MR (x->pmTable), "pmTable");
|
|
|
|
iprintf ((o_fp, "[Reserved field omitted]; }\n")); indent -= 2;
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_cqdprocs (CQDProcsPtr x)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "%s(CQDProcsPtr *%p) {\n", field_name, x)); indent += 2;
|
|
|
|
if (x != NULL)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "textProc %p;\n", MR (x->textProc)));
|
|
|
|
iprintf ((o_fp, "lineProc %p;\n", MR (x->lineProc)));
|
|
|
|
iprintf ((o_fp, "rectProc %p;\n", MR (x->rectProc)));
|
|
|
|
iprintf ((o_fp, "rRectProc %p;\n", MR (x->rRectProc)));
|
|
|
|
iprintf ((o_fp, "ovalProc %p;\n", MR (x->ovalProc)));
|
|
|
|
iprintf ((o_fp, "arcProc %p;\n", MR (x->arcProc)));
|
|
|
|
iprintf ((o_fp, "polyProc %p;\n", MR (x->polyProc)));
|
|
|
|
iprintf ((o_fp, "rgnProc %p;\n", MR (x->rgnProc)));
|
|
|
|
iprintf ((o_fp, "bitsProc %p;\n", MR (x->bitsProc)));
|
|
|
|
iprintf ((o_fp, "commentProc %p;\n", MR (x->commentProc)));
|
|
|
|
iprintf ((o_fp, "txMeasProc %p;\n", MR (x->txMeasProc)));
|
|
|
|
iprintf ((o_fp, "getPicProc %p;\n", MR (x->getPicProc)));
|
|
|
|
iprintf ((o_fp, "putPicProc %p;\n", MR (x->putPicProc)));
|
|
|
|
iprintf ((o_fp, "newProc1Proc %p;\n", MR (x->newProc1Proc)));
|
|
|
|
iprintf ((o_fp, "newProc2Proc %p;\n", MR (x->newProc2Proc)));
|
|
|
|
iprintf ((o_fp, "newProc3Proc %p;\n", MR (x->newProc3Proc)));
|
|
|
|
iprintf ((o_fp, "newProc4Proc %p;\n", MR (x->newProc4Proc)));
|
|
|
|
iprintf ((o_fp, "newProc5Proc %p;\n", MR (x->newProc5Proc)));
|
|
|
|
iprintf ((o_fp, "newProc6Proc %p;\n", MR (x->newProc6Proc)));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
iprintf ((o_fp, "<default grafprocs used>\n"));
|
|
|
|
indent -= 2; iprintf ((o_fp, "}\n"));
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_cgrafport_real (CGrafPtr x)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "%s(CGrafPort *%p) {\n", field_name, x)); indent += 2;
|
|
|
|
iprintf ((o_fp, "device 0x%x;\n", CW (x->device)));
|
|
|
|
if (dump_verbosity
|
|
|
|
&& x->portPixMap)
|
|
|
|
dump_field (dump_pixmap_null_rect, MR (x->portPixMap), "portPixMap");
|
|
|
|
else
|
|
|
|
dump_field (dump_handle, MR (x->portPixMap), "portPixMap");
|
|
|
|
iprintf ((o_fp, "portVersion 0x%x;\n", CW (x->portVersion)));
|
|
|
|
dump_field (dump_handle, MR (x->grafVars), "grafVars");
|
|
|
|
iprintf ((o_fp, "chExtra %d;\n", CW (x->chExtra)));
|
|
|
|
iprintf ((o_fp, "pnLocHFrac 0x%x;\n", CW (x->pnLocHFrac)));
|
|
|
|
dump_field (dump_rect, &x->portRect, "portRect");
|
|
|
|
dump_field (dump_handle, MR (x->visRgn), "visRgn");
|
|
|
|
dump_field (dump_handle, MR (x->clipRgn), "clipRgn");
|
|
|
|
if (dump_verbosity
|
|
|
|
&& x->bkPixPat)
|
|
|
|
dump_field (dump_pixpat, MR (x->bkPixPat), "bkPixPat");
|
|
|
|
else
|
|
|
|
dump_field (dump_handle, MR (x->bkPixPat), "bkPixPat");
|
|
|
|
dump_field (dump_rgb_color, &x->rgbFgColor, "rgbFgColor");
|
|
|
|
dump_field (dump_rgb_color, &x->rgbBkColor, "rgbBkColor");
|
|
|
|
dump_field (dump_point, x->pnLoc, "pnLoc");
|
|
|
|
dump_field (dump_point, x->pnSize, "pnSize");
|
|
|
|
iprintf ((o_fp, "pnMode %d;\n", CW (x->pnMode)));
|
|
|
|
if (dump_verbosity
|
|
|
|
&& x->pnPixPat)
|
|
|
|
dump_field (dump_pixpat, MR (x->pnPixPat), "pnPixPat");
|
|
|
|
else
|
|
|
|
dump_field (dump_handle, MR (x->pnPixPat), "pnPixPat");
|
|
|
|
if (dump_verbosity
|
|
|
|
&& x->fillPixPat)
|
|
|
|
dump_field (dump_pixpat, MR (x->fillPixPat), "fillPixPat");
|
|
|
|
else
|
|
|
|
dump_field (dump_handle, MR (x->fillPixPat), "fillPixPat");
|
|
|
|
iprintf ((o_fp, "pnVis %d;\n", CW (x->pnVis)));
|
|
|
|
iprintf ((o_fp, "txFont %d;\n", CW (x->txFont)));
|
|
|
|
iprintf ((o_fp, "txFace %d;\n", x->txFace));
|
|
|
|
iprintf ((o_fp, "txMode %d;\n", CW (x->txMode)));
|
|
|
|
iprintf ((o_fp, "txSize %d;\n", CW (x->txSize)));
|
|
|
|
iprintf ((o_fp, "spExtra %d;\n", CL (x->spExtra)));
|
|
|
|
iprintf ((o_fp, "fgColor 0x%x;\n", CL (x->fgColor)));
|
|
|
|
iprintf ((o_fp, "bkColor 0x%x;\n", CL (x->bkColor)));
|
|
|
|
iprintf ((o_fp, "colrBit %d;\n", CW (x->colrBit)));
|
|
|
|
iprintf ((o_fp, "patStretch %x;\n", CW (x->patStretch)));
|
|
|
|
dump_field (dump_handle, MR (x->picSave), "picSave");
|
|
|
|
dump_field (dump_handle, MR (x->rgnSave), "rgnSave");
|
|
|
|
dump_field (dump_handle, MR (x->polySave), "polySave");
|
|
|
|
dump_field (dump_cqdprocs, MR (x->grafProcs), "grafProcs");
|
|
|
|
indent -= 2; iprintf ((o_fp, "}\n"));
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_gdevice (GDHandle gdev)
|
|
|
|
{
|
|
|
|
GDPtr x = deref (gdev);
|
|
|
|
SProcHndl proc;
|
|
|
|
|
|
|
|
iprintf ((o_fp, "%s(GDevice **%p) {\n", field_name, gdev)); indent += 2;
|
|
|
|
iprintf ((o_fp, "gdID 0x%x;\n", CW (x->gdID)));
|
|
|
|
iprintf ((o_fp, "gdType 0x%x;\n", CW (x->gdType)));
|
|
|
|
if (dump_verbosity
|
|
|
|
&& x->gdITable)
|
|
|
|
dump_field (dump_itab, MR (x->gdITable), "gdITable");
|
|
|
|
else
|
|
|
|
dump_field (dump_handle, MR (x->gdITable), "gdITable");
|
|
|
|
iprintf ((o_fp, "gdResPref 0x%x;\n", CW (x->gdResPref)));
|
|
|
|
#if 0
|
|
|
|
dump_field (dump_handle, CL (x->gdSearchProc), "gdSearchProc");
|
|
|
|
#else
|
|
|
|
iprintf ((o_fp, "gdSearchProc %p;\n", MR (x->gdSearchProc)));
|
|
|
|
for (proc = MR (x->gdSearchProc); proc; proc = HxP (proc, nxtSrch))
|
|
|
|
iprintf ((o_fp, " proc [%p, %p]; %p\n",
|
|
|
|
proc, HxP (proc, nxtSrch), HxP (proc, srchProc)));
|
|
|
|
#endif
|
|
|
|
dump_field (dump_handle, MR (x->gdCompProc), "gdCompProc");
|
|
|
|
iprintf ((o_fp, "gdFlags 0x%hx;\n", (unsigned short) CW (x->gdFlags)));
|
|
|
|
if (dump_verbosity
|
|
|
|
&& x->gdPMap)
|
|
|
|
dump_field (dump_pixmap_null_rect, MR (x->gdPMap), "gdPMap");
|
|
|
|
else
|
|
|
|
dump_field (dump_handle, MR (x->gdPMap), "gdPMap");
|
|
|
|
iprintf ((o_fp, "gdRefCon 0x%x;\n", CL (x->gdRefCon)));
|
|
|
|
if (dump_verbosity
|
|
|
|
&& x->gdNextGD)
|
|
|
|
dump_field (dump_gdevice, (GDHandle) MR (x->gdNextGD), "gdNextGD");
|
|
|
|
else
|
|
|
|
dump_field (dump_handle, MR (x->gdNextGD), "gdNextGD");
|
|
|
|
dump_field (dump_rect, &x->gdRect, "gdRect");
|
|
|
|
iprintf ((o_fp, "gdMode 0x%x;\n", CW (x->gdMode)));
|
|
|
|
iprintf ((o_fp, "[CC, Reserved fields omitted]; }\n")); indent -= 2;
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_thegdevice (void)
|
|
|
|
{
|
|
|
|
dump_gdevice (MR (TheGDevice));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_maindevice (void)
|
|
|
|
{
|
|
|
|
dump_gdevice (MR (MainDevice));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_string (unsigned char *s)
|
|
|
|
{
|
|
|
|
/* pascal string */
|
|
|
|
unsigned char t[256];
|
|
|
|
int len;
|
|
|
|
|
|
|
|
len = *s;
|
|
|
|
strncpy ((char *) t, (char *) &s[1], len);
|
|
|
|
t[len] = '\0';
|
|
|
|
iprintf ((o_fp, "%s %p \"%s\";\n",
|
|
|
|
field_name, s, t));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_palette (PaletteHandle palette)
|
|
|
|
{
|
|
|
|
PalettePtr x = deref (palette);
|
|
|
|
|
|
|
|
iprintf ((o_fp, "%s(PaletteHandle **%p) {\n", field_name, palette));
|
|
|
|
indent += 2;
|
|
|
|
iprintf ((o_fp, "pmEntries 0x%x;\n", CW (x->pmEntries)));
|
|
|
|
if (pmWindow (x)
|
|
|
|
&& dump_verbosity >= 2
|
|
|
|
&& 0)
|
|
|
|
dump_grafport ((GrafPtr) MR (pmWindow (x)));
|
|
|
|
else
|
|
|
|
dump_field (dump_handle, MR (pmWindow (x)), "pmWindow");
|
|
|
|
iprintf ((o_fp, "pmPrivate 0x%x\n", CW (pmPrivate (x))));
|
|
|
|
iprintf ((o_fp, "pmDevices 0x%lx\n", (long) CL (pmDevices (x))));
|
|
|
|
iprintf ((o_fp, "pmSeeds 0x%lx\n", (long) MR (pmSeeds (x))));
|
|
|
|
if (dump_verbosity >= 2)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
iprintf ((o_fp, "pmInfo\n"));
|
|
|
|
for (i = 0; i < CW (x->pmEntries); i ++)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "%3x { rgb { 0x%lx, 0x%lx, 0x%lx }\n",
|
|
|
|
i,
|
|
|
|
(long) CW (x->pmInfo[i].ciRGB.red),
|
|
|
|
(long) CW (x->pmInfo[i].ciRGB.green),
|
|
|
|
(long) CW (x->pmInfo[i].ciRGB.blue)));
|
|
|
|
iprintf ((o_fp, " usage 0x%x; tolerance 0x%x;\n",
|
|
|
|
CW (x->pmInfo[i].ciUsage),
|
|
|
|
CW (x->pmInfo[i].ciTolerance)));
|
|
|
|
iprintf ((o_fp, " flags 0x%x; private 0x%lx; };\n",
|
|
|
|
CW (ciFlags (&x->pmInfo[i])),
|
|
|
|
(unsigned long) CL (ciPrivate (&x->pmInfo[i]))));
|
|
|
|
}
|
|
|
|
indent -= 2; iprintf ((o_fp, "}\n"));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
indent -= 2; iprintf ((o_fp, "[pmInfo field omitted]; }\n"));
|
|
|
|
}
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_ccrsr (CCrsrHandle ccrsr)
|
|
|
|
{
|
|
|
|
CCrsrPtr x = deref (ccrsr);
|
|
|
|
|
|
|
|
iprintf ((o_fp, "%s(CCrsrHandle **%p) {\n", field_name, ccrsr));
|
|
|
|
indent += 2;
|
|
|
|
iprintf ((o_fp, "crsrType 0x%hx;\n", CW (x->crsrType)));
|
|
|
|
if (x->crsrMap
|
|
|
|
&& dump_verbosity >= 1)
|
|
|
|
dump_field (dump_pixmap_null_rect, MR (x->crsrMap), "crsrMap");
|
|
|
|
else
|
|
|
|
dump_field (dump_handle, MR (x->crsrMap), "crsrMap");
|
|
|
|
dump_field (dump_handle, MR (x->crsrData), "crsrData");
|
|
|
|
if (dump_verbosity >= 3
|
|
|
|
&& x->crsrXData
|
|
|
|
&& x->crsrXValid != 0)
|
|
|
|
{
|
|
|
|
BitMap bm;
|
|
|
|
int depth;
|
|
|
|
/* dump the expanded pixel data */
|
|
|
|
|
|
|
|
depth = CW (x->crsrXValid);
|
|
|
|
bm.baseAddr = RM (deref (MR (x->crsrXData)));
|
|
|
|
bm.rowBytes = CW (2 * depth);
|
|
|
|
bm.bounds.top = bm.bounds.left = CWC (0);
|
|
|
|
bm.bounds.bottom = CWC (16);
|
|
|
|
bm.bounds.right = CWC (16);
|
|
|
|
|
|
|
|
|
|
|
|
field_name = "crsrXData";
|
|
|
|
dump_bitmap_data (&bm, depth, NULL);
|
|
|
|
field_name = "";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
dump_field (dump_handle, MR (x->crsrXData), "crsrXData");
|
|
|
|
iprintf ((o_fp, "crsrXValid %d;\n", CW (x->crsrXValid)));
|
|
|
|
dump_field (dump_handle, MR (x->crsrXHandle), "crsrXHandle");
|
|
|
|
dump_field (dump_bits16, x->crsr1Data, "crsr1Data");
|
|
|
|
dump_field (dump_bits16, x->crsrMask, "crsrMask");
|
|
|
|
dump_field (dump_point, x->crsrHotSpot, "crsrHotSpot");
|
|
|
|
iprintf ((o_fp, "crsrXTable %x\n", CW (x->crsrXTable)));
|
|
|
|
iprintf ((o_fp, "crsrID 0x%x; }\n", CW (x->crsrID))); indent -= 2;
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_wmgrport (void)
|
|
|
|
{
|
|
|
|
dump_grafport (MR (WMgrPort));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_wmgrcport (void)
|
|
|
|
{
|
|
|
|
dump_grafport ((GrafPtr) MR (WMgrCPort));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_string_handle (StringHandle sh)
|
|
|
|
{
|
|
|
|
/* pascal string */
|
|
|
|
unsigned char *s, t[256];
|
|
|
|
int size, len;
|
|
|
|
|
|
|
|
s = deref (sh);
|
|
|
|
size = GetHandleSize ((Handle) sh);
|
|
|
|
len = *s;
|
|
|
|
strncpy ((char *) t, (char *) &s[1], len);
|
|
|
|
t[len] = '\0';
|
|
|
|
iprintf ((o_fp, "%s %p[%d] \"%s\";\n",
|
|
|
|
field_name, sh, size, t));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_window_peek (WindowPeek w)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "%s(WindowPeek %p) {\n", field_name, w));
|
|
|
|
indent += 2;
|
|
|
|
|
|
|
|
dump_field (dump_grafport, WINDOW_PORT (w), "port");
|
|
|
|
iprintf ((o_fp, "windowKind %lx;\n", (long) WINDOW_KIND (w)));
|
|
|
|
iprintf ((o_fp, "visible %x;\n", WINDOW_VISIBLE (w)));
|
|
|
|
iprintf ((o_fp, "hilited %x;\n", WINDOW_HILITED (w)));
|
|
|
|
iprintf ((o_fp, "goAwayFlag %x;\n", WINDOW_GO_AWAY_FLAG (w)));
|
|
|
|
iprintf ((o_fp, "spareFlag %x;\n", WINDOW_SPARE_FLAG (w)));
|
|
|
|
|
|
|
|
dump_field (dump_handle, WINDOW_STRUCT_REGION (w), "strucRgn");
|
|
|
|
dump_field (dump_handle, WINDOW_CONT_REGION (w), "contRgn");
|
|
|
|
dump_field (dump_handle, WINDOW_UPDATE_REGION (w), "updateRgn");
|
|
|
|
|
|
|
|
dump_field (dump_handle, WINDOW_DEF_PROC (w), "windowDefProc");
|
|
|
|
dump_field (dump_handle, WINDOW_DATA (w), "dataHandle");
|
|
|
|
dump_field (dump_string_handle, WINDOW_TITLE (w), "titleHandle");
|
|
|
|
|
|
|
|
iprintf ((o_fp, "titleWidth %lx;\n", (long) WINDOW_TITLE_WIDTH (w)));
|
|
|
|
|
|
|
|
dump_field (dump_handle, WINDOW_CONTROL_LIST (w), "controlList");
|
|
|
|
dump_field (dump_ptr, WINDOW_NEXT_WINDOW (w), "nextWindow");
|
|
|
|
dump_field (dump_handle, WINDOW_PIC (w), "picHandle");
|
|
|
|
|
|
|
|
iprintf ((o_fp, "refCon %lx; }\n", (long) WINDOW_REF_CON (w)));
|
|
|
|
indent -= 2;
|
|
|
|
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_dialog_peek (DialogPeek d)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "%s(DialogPeek %p) {\n", field_name, d));
|
|
|
|
indent += 2;
|
|
|
|
|
|
|
|
dump_field (dump_window_peek, (WindowPeek) DIALOG_WINDOW (d), "window");
|
|
|
|
dump_field (dump_handle, DIALOG_ITEMS (d), "items");
|
|
|
|
dump_field (dump_handle, DIALOG_TEXTH (d), "textH");
|
|
|
|
iprintf ((o_fp, "editField 0x%x;\n", DIALOG_EDIT_FIELD (d)));
|
|
|
|
iprintf ((o_fp, "editOpen 0x%x;\n", DIALOG_EDIT_OPEN (d)));
|
|
|
|
iprintf ((o_fp, "aDefItem 0x%x; }\n", DIALOG_ADEF_ITEM (d)));
|
|
|
|
indent -= 2;
|
|
|
|
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_dialog_items (DialogPeek dp)
|
|
|
|
{
|
|
|
|
int16 *item_data;
|
|
|
|
int n_items;
|
|
|
|
itmp items;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
item_data = (int16 *) STARH (DIALOG_ITEMS (dp));
|
|
|
|
n_items = CW (*item_data);
|
|
|
|
items = (itmp) &item_data[1];
|
|
|
|
fprintf (o_fp, "%d items:\n", n_items);
|
|
|
|
for (i = 0; i < n_items; i ++)
|
|
|
|
{
|
|
|
|
itmp item;
|
|
|
|
|
|
|
|
item = items;
|
|
|
|
fprintf (o_fp, "item %d; type %d, hand %p, (%d, %d, %d, %d)\n",
|
|
|
|
i, CW ((int16) item->itmtype),
|
|
|
|
MR (item->itmhand),
|
|
|
|
CW (item->itmr.top), CW (item->itmr.left),
|
|
|
|
CW (item->itmr.bottom), CW (item->itmr.right));
|
|
|
|
BUMPIP (items);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_aux_win_list (void)
|
|
|
|
{
|
|
|
|
AuxWinHandle t;
|
|
|
|
|
|
|
|
for (t = MR (AuxWinHead); t; t = MR (deref (t)->awNext))
|
|
|
|
{
|
|
|
|
dump_aux_win (t);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_aux_win (AuxWinHandle awh)
|
|
|
|
{
|
|
|
|
AuxWinPtr aw = deref (awh);
|
|
|
|
|
|
|
|
iprintf ((o_fp, "%s(AuxWinHandle **%p) {\n", field_name, awh));
|
|
|
|
indent += 2;
|
|
|
|
iprintf ((o_fp, "awNext %p;\n", MR (aw->awNext)));
|
|
|
|
iprintf ((o_fp, "awOwner %p;\n", MR (aw->awOwner)));
|
|
|
|
dump_field (dump_ctab, MR (aw->awCTable), "awCTable");
|
|
|
|
dump_field (dump_handle, MR (aw->dialogCItem), "dialogCItem");
|
|
|
|
iprintf ((o_fp, "awFlags 0x%lx;\n", (long) CL (aw->awFlags)));
|
|
|
|
iprintf ((o_fp, "awReserved 0x%lx;\n", (long) MR (aw->awReserved)));
|
|
|
|
iprintf ((o_fp, "awRefCon 0x%lx; }\n", (long) CL (aw->awRefCon)));
|
|
|
|
indent -= 2;
|
|
|
|
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_window_list (WindowPeek w)
|
|
|
|
{
|
|
|
|
WindowPeek t_w;
|
|
|
|
WindowPeek front_w;
|
|
|
|
|
|
|
|
front_w = (WindowPeek) FrontWindow ();
|
|
|
|
for (t_w = MR (WindowList);
|
|
|
|
t_w;
|
|
|
|
t_w = WINDOW_NEXT_WINDOW (t_w))
|
|
|
|
{
|
|
|
|
fprintf (o_fp, "%p", t_w);
|
|
|
|
if (t_w == w)
|
|
|
|
fprintf (o_fp, " arg");
|
|
|
|
if (t_w == front_w)
|
|
|
|
fprintf (o_fp, " front");
|
|
|
|
fprintf (o_fp, "\n");
|
|
|
|
dump_string_handle (WINDOW_TITLE (t_w));
|
|
|
|
}
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_rgn (RgnHandle rgn)
|
|
|
|
{
|
|
|
|
RgnPtr x;
|
|
|
|
|
|
|
|
iprintf ((o_fp, "%s(RgnHandle **%p) {\n", field_name, rgn)); indent += 2;
|
|
|
|
x = deref (rgn);
|
|
|
|
iprintf ((o_fp, "rgnSize %d\n", CW (x->rgnSize)));
|
|
|
|
dump_field (dump_rect, &x->rgnBBox, "rgnBBox");
|
|
|
|
iprintf ((o_fp, "[special data omitted]; }\n")); indent -= 2;
|
|
|
|
fflush (o_fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_menu_info (MenuHandle x)
|
|
|
|
{
|
|
|
|
dump_field (dump_handle, x, "MenuHandle");
|
|
|
|
iprintf ((o_fp, "%s(MenuHandle **%p) {\n", field_name, x));
|
|
|
|
indent += 2;
|
|
|
|
iprintf ((o_fp, "menuID %d\n", MI_ID (x)));
|
|
|
|
iprintf ((o_fp, "menuWidth %d\n", MI_WIDTH (x)));
|
|
|
|
iprintf ((o_fp, "menuHeight %d\n", MI_HEIGHT (x)));
|
|
|
|
dump_field (dump_handle, MI_PROC (x), "menuProc");
|
|
|
|
iprintf ((o_fp, "enableFlags %x\n", MI_ENABLE_FLAGS (x)));
|
|
|
|
dump_field (dump_string, MI_DATA (x), "menuTitle");
|
|
|
|
|
|
|
|
indent += 2;
|
|
|
|
{
|
|
|
|
unsigned char *p;
|
|
|
|
|
|
|
|
p = MI_DATA (x) + ((unsigned char *)MI_DATA (x))[0] + 1;
|
|
|
|
while (*p)
|
|
|
|
{
|
|
|
|
dump_field (dump_string, p, "item name");
|
|
|
|
p += p[0] + 1;
|
|
|
|
iprintf ((o_fp, "icon = 0x%02x, keyeq = 0x%02x, marker = 0x%02x,"
|
|
|
|
" style = 0x%02x\n", p[0], p[1], p[2], p[3]));
|
|
|
|
p += 4;
|
|
|
|
}
|
|
|
|
indent -= 2;
|
|
|
|
iprintf ((o_fp, "total chars = %d\n", p - (unsigned char *) STARH(x)));
|
|
|
|
}
|
|
|
|
indent -= 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_control_list (WindowPeek w)
|
|
|
|
{
|
|
|
|
ControlHandle x;
|
|
|
|
|
|
|
|
for (x = WINDOW_CONTROL_LIST (w); x; x = CTL_NEXT_CONTROL (x))
|
|
|
|
{
|
|
|
|
char buf[256];
|
|
|
|
int len;
|
|
|
|
|
|
|
|
len = *CTL_TITLE (x);
|
|
|
|
strncpy (buf, (char *) &CTL_TITLE (x)[1], len);
|
|
|
|
buf[len] = '\0';
|
|
|
|
|
|
|
|
fprintf (o_fp, "%p %s\n", x, buf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_control (ControlHandle x)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "%s(ControlHandle **%p) {\n", field_name, x));
|
|
|
|
indent += 2;
|
|
|
|
|
|
|
|
dump_field (dump_handle, CTL_NEXT_CONTROL (x), "nextControl");
|
|
|
|
dump_field (dump_ptr, CTL_OWNER (x), "contrlOwner");
|
|
|
|
dump_field (dump_rect, &CTL_RECT (x), "contrlRect");
|
|
|
|
iprintf ((o_fp, "contrlVis %d\n", (int) CTL_VIS (x)));
|
|
|
|
iprintf ((o_fp, "contrlHilite %d\n", (int) CTL_HILITE (x)));
|
|
|
|
|
|
|
|
iprintf ((o_fp, "contrlValue %d\n", (int) CTL_VALUE (x)));
|
|
|
|
iprintf ((o_fp, "contrlMin %d\n", (int) CTL_MIN (x)));
|
|
|
|
iprintf ((o_fp, "contrlMax %d\n", (int) CTL_MAX (x)));
|
|
|
|
|
|
|
|
dump_field (dump_handle, CTL_DEFPROC (x), "contrlDefProc");
|
|
|
|
dump_field (dump_ptr, CTL_DATA (x), "contrlData");
|
|
|
|
|
|
|
|
iprintf ((o_fp, "contrlAction %p\n", CTL_ACTION (x)));
|
|
|
|
iprintf ((o_fp, "contrlRfCon %d\n", (int) CTL_REF_CON (x)));
|
|
|
|
dump_field (dump_string, CTL_TITLE (x), "contrlTitle");
|
|
|
|
indent -= 2;
|
|
|
|
iprintf ((o_fp, "}\n"));
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_memlocs( uint32 to_look_for, int size, const void *start_addr,
|
|
|
|
const void *end_addr )
|
|
|
|
{
|
|
|
|
const uint8 *ucp;
|
|
|
|
const uint16 *usp;
|
|
|
|
const uint32 *ulp;
|
|
|
|
|
|
|
|
switch (size)
|
|
|
|
{
|
|
|
|
case 1:
|
|
|
|
for (ucp = start_addr; ucp < (uint8 *) end_addr; ++ucp)
|
|
|
|
if (*ucp == (uint8) to_look_for)
|
|
|
|
iprintf ((o_fp, "%p\n", ucp));
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
for (usp = start_addr; usp < (uint16 *) end_addr; ++usp)
|
|
|
|
if (*usp == (uint16) to_look_for)
|
|
|
|
iprintf ((o_fp, "%p\n", usp));
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
for (ulp = start_addr; ulp < (uint32 *) end_addr;
|
|
|
|
ulp = (const uint32 *) ((char *)ulp + 2))
|
|
|
|
if (*ulp == to_look_for)
|
|
|
|
iprintf ((o_fp, "%p\n", ulp));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
iprintf ((o_fp, "Bad Size\n"));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_te (TEHandle te)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
iprintf ((o_fp, "%s(TEHandle **%p) {\n", field_name, te));
|
|
|
|
indent += 2;
|
|
|
|
|
|
|
|
dump_field (dump_rect, &TE_DEST_RECT (te), "destRect");
|
|
|
|
dump_field (dump_rect, &TE_VIEW_RECT (te), "viewRect");
|
|
|
|
dump_field (dump_rect, &TE_SEL_RECT (te), "selRect");
|
|
|
|
|
|
|
|
iprintf ((o_fp, "lineHeight %d\n", TE_LINE_HEIGHT (te)));
|
|
|
|
iprintf ((o_fp, "fontAscent %d\n", TE_FONT_ASCENT (te)));
|
|
|
|
|
|
|
|
iprintf ((o_fp, "selStart %d\n", TE_SEL_START (te)));
|
|
|
|
iprintf ((o_fp, "selEnd %d\n", TE_SEL_END (te)));
|
|
|
|
iprintf ((o_fp, "caretState %d\n", TE_CARET_STATE (te)));
|
|
|
|
|
|
|
|
iprintf ((o_fp, "just %d\n", TE_JUST (te)));
|
|
|
|
iprintf ((o_fp, "teLength %d\n", TE_LENGTH (te)));
|
|
|
|
|
|
|
|
iprintf ((o_fp, "txFont %d\n", TE_TX_FONT (te)));
|
|
|
|
iprintf ((o_fp, "txFace %d\n", TE_TX_FACE (te)));
|
|
|
|
iprintf ((o_fp, "txMode %d\n", TE_TX_MODE (te)));
|
|
|
|
iprintf ((o_fp, "txSize %d\n", TE_TX_SIZE (te)));
|
|
|
|
|
|
|
|
iprintf ((o_fp, "nLines %d\n", TE_N_LINES (te)));
|
|
|
|
|
|
|
|
{
|
|
|
|
char buf[40000];
|
|
|
|
int16 length;
|
|
|
|
|
|
|
|
length = TE_LENGTH (te);
|
|
|
|
memcpy (buf, STARH (TE_HTEXT (te)), length);
|
|
|
|
buf[length] = '\0';
|
|
|
|
|
|
|
|
fprintf (o_fp, "`%s'\n", buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
int16 n_lines, *line_starts;
|
|
|
|
|
|
|
|
n_lines = TE_N_LINES (te);
|
|
|
|
line_starts = TE_LINE_STARTS (te);
|
|
|
|
|
|
|
|
for (i = 0; i <= n_lines; i ++)
|
|
|
|
iprintf ((o_fp, "lineStart[%d]: %d\n", i, CW (line_starts[i])));
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
STHandle style_table;
|
|
|
|
StyleRun *runs;
|
|
|
|
int16 n_lines, n_runs, n_styles;
|
|
|
|
TEStyleHandle te_style;
|
|
|
|
LHHandle lh_table;
|
|
|
|
LHElement *lh;
|
|
|
|
|
|
|
|
n_lines = TE_N_LINES (te);
|
|
|
|
te_style = TE_GET_STYLE (te);
|
|
|
|
lh_table = TE_STYLE_LH_TABLE (te_style);
|
|
|
|
n_runs = TE_STYLE_N_RUNS (te_style);
|
|
|
|
lh = STARH (lh_table);
|
|
|
|
|
|
|
|
n_styles = TE_STYLE_N_STYLES (te_style);
|
|
|
|
|
|
|
|
iprintf ((o_fp, "(TEStyleHandle **%p) {\n", te_style));
|
|
|
|
indent += 2;
|
|
|
|
|
|
|
|
iprintf ((o_fp, "nRuns %d\n", TE_STYLE_N_RUNS (te_style)));
|
|
|
|
iprintf ((o_fp, "nStyles %d\n", n_styles));
|
|
|
|
|
|
|
|
for (i = 0; i <= n_lines; i ++)
|
|
|
|
iprintf ((o_fp, "lhTab[%d]: lhHeight %d, lhAscent %d\n",
|
|
|
|
i, LH_HEIGHT (&lh[i]), LH_ASCENT (&lh[i])));
|
|
|
|
|
|
|
|
runs = TE_STYLE_RUNS (te_style);
|
|
|
|
for (i = 0; i <= n_runs; i ++)
|
|
|
|
iprintf ((o_fp, "runs[%d]: startChar %d, styleIndex %d\n", i,
|
|
|
|
STYLE_RUN_START_CHAR (&runs[i]),
|
|
|
|
STYLE_RUN_STYLE_INDEX (&runs[i])));
|
|
|
|
|
|
|
|
style_table = TE_STYLE_STYLE_TABLE (te_style);
|
|
|
|
for (i = 0; i < n_styles; i ++)
|
|
|
|
{
|
|
|
|
STElement *style;
|
|
|
|
|
|
|
|
style = ST_ELT (style_table, i);
|
|
|
|
iprintf ((o_fp, "style[%d] stCount %d, stHieght %d, stAscent %d\n",
|
|
|
|
i, ST_ELT_COUNT (style),
|
|
|
|
ST_ELT_HEIGHT (style), ST_ELT_ASCENT (style)));
|
|
|
|
}
|
|
|
|
|
|
|
|
indent -= 2;
|
|
|
|
iprintf ((o_fp, "}\n"));
|
|
|
|
}
|
|
|
|
indent -= 2;
|
|
|
|
iprintf ((o_fp, "}\n"));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dump_scrap (StScrpHandle scrap)
|
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#define MAP_SAVE_EXCURSION(map, body) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
INTEGER save_map; \
|
|
|
|
\
|
|
|
|
save_map = CurMap; \
|
|
|
|
CurMap = map; \
|
|
|
|
{ body } \
|
|
|
|
CurMap = save_map; \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
static INTEGER
|
|
|
|
CountResourcesRN (LONGINT type, INTEGER rn)
|
|
|
|
{
|
|
|
|
INTEGER retval;
|
|
|
|
|
|
|
|
MAP_SAVE_EXCURSION
|
|
|
|
(CW (rn),
|
|
|
|
{
|
|
|
|
retval = Count1Resources (type);
|
|
|
|
});
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Handle
|
|
|
|
GetIndResourceRN (LONGINT type, INTEGER i, INTEGER rn)
|
|
|
|
{
|
|
|
|
Handle retval;
|
|
|
|
|
|
|
|
MAP_SAVE_EXCURSION
|
|
|
|
(CW (rn),
|
|
|
|
{
|
|
|
|
retval = Get1IndResource (type, i);
|
|
|
|
});
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
AddResourceRN (Handle h, LONGINT type, INTEGER id, Str255 name, INTEGER rn)
|
|
|
|
{
|
|
|
|
MAP_SAVE_EXCURSION
|
|
|
|
(CW (rn),
|
|
|
|
{
|
|
|
|
AddResource (h, type, id, name);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
static OSErr
|
|
|
|
copy_resources (INTEGER new_rn, INTEGER old_rn, LONGINT type)
|
|
|
|
{
|
|
|
|
INTEGER num_res;
|
|
|
|
BOOLEAN save_res_load;
|
|
|
|
INTEGER i;
|
|
|
|
|
|
|
|
save_res_load = ResLoad;
|
|
|
|
ResLoad = TRUE;
|
|
|
|
num_res = CountResourcesRN (type, old_rn);
|
|
|
|
for (i = 1; i <= num_res; ++i)
|
|
|
|
{
|
|
|
|
Handle h;
|
|
|
|
INTEGER id;
|
|
|
|
Str255 name;
|
|
|
|
LONGINT ignored;
|
|
|
|
|
|
|
|
h = GetIndResourceRN (type, i, old_rn);
|
|
|
|
GetResInfo (h, &id, &ignored, name);
|
|
|
|
id = CW (id);
|
|
|
|
DetachResource (h);
|
|
|
|
AddResourceRN (h, type, id, name, new_rn);
|
|
|
|
}
|
|
|
|
ResLoad = save_res_load;
|
|
|
|
return noErr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* NOTE: dump_code_resources detachs the current (CODE '0'), so you will
|
|
|
|
not be able to continue after calling this function */
|
|
|
|
|
|
|
|
/* EXAMPLE: dump_code_resources ("/:tmp:filename"); */
|
|
|
|
|
|
|
|
OSErr
|
|
|
|
dump_code_resources (const char *filename)
|
|
|
|
{
|
|
|
|
Str255 pfilename;
|
|
|
|
OSErr retval;
|
|
|
|
|
|
|
|
str255_from_c_string (pfilename, filename);
|
|
|
|
CreateResFile (pfilename);
|
|
|
|
retval = ResError ();
|
|
|
|
if (retval == noErr)
|
|
|
|
{
|
|
|
|
Handle h;
|
|
|
|
INTEGER old_rn, new_rn;
|
|
|
|
|
|
|
|
h = GetResource (TICK("CODE"), 0);
|
|
|
|
retval = ResError ();
|
|
|
|
if (retval == noErr)
|
|
|
|
{
|
|
|
|
old_rn = HomeResFile (h);
|
|
|
|
DetachResource (h);
|
|
|
|
retval = ResError ();
|
|
|
|
if (retval == noErr)
|
|
|
|
{
|
|
|
|
new_rn = OpenRFPerm (pfilename, 0, fsRdWrPerm);
|
|
|
|
retval = ResError ();
|
|
|
|
if (retval == noErr)
|
|
|
|
retval = copy_resources (new_rn, old_rn, TICK("CODE"));
|
|
|
|
if (new_rn)
|
|
|
|
{
|
|
|
|
CloseResFile (new_rn);
|
|
|
|
if (retval == noErr)
|
|
|
|
retval = ResError ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined (SYN68K)
|
|
|
|
/* This is just a linker hack to make sure we pull in the syn68k .o file
|
|
|
|
* containing the m68kaddr function.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <syn68k_public.h>
|
|
|
|
|
|
|
|
void (*m68kaddr_linker_hack)(const uint16 *) = m68kaddr;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
PRIVATE const char *
|
|
|
|
just_name (unsigned char just)
|
|
|
|
{
|
|
|
|
const char *names[] =
|
|
|
|
{
|
|
|
|
"none", "left", "center", "right", "full", "INVALID"
|
|
|
|
};
|
|
|
|
const char *retval;
|
|
|
|
|
|
|
|
retval = just < NELEM (names) ? names[just] : names[NELEM(names-1)];
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRIVATE const char *
|
|
|
|
flop_name (unsigned char flop)
|
|
|
|
{
|
|
|
|
const char *names[] =
|
|
|
|
{
|
|
|
|
"none", "horizontal", "vertical", "INVALID"
|
|
|
|
};
|
|
|
|
const char *retval;
|
|
|
|
|
|
|
|
retval = flop < NELEM (names) ? names[flop] : names[NELEM(names-1)];
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
PUBLIC void
|
|
|
|
dump_textbegin (TTxtPicHdl h)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "just = %d(%s)\n", TEXTPIC_JUST (h),
|
|
|
|
just_name (TEXTPIC_JUST (h))));
|
|
|
|
iprintf ((o_fp, "flop = %d(%s)\n", TEXTPIC_FLOP (h),
|
|
|
|
flop_name (TEXTPIC_FLOP (h))));
|
|
|
|
iprintf ((o_fp, "angle = %d\n", TEXTPIC_ANGLE (h)));
|
|
|
|
iprintf ((o_fp, "line = %d\n", TEXTPIC_LINE (h)));
|
|
|
|
iprintf ((o_fp, "comment = %d\n", TEXTPIC_COMMENT (h)));
|
|
|
|
if (GetHandleSize ((Handle) h) >= 10)
|
|
|
|
iprintf ((o_fp, "angle_fixed = 0x%08x\n", TEXTPIC_ANGLE_FIXED (h)));
|
|
|
|
}
|
|
|
|
|
|
|
|
PUBLIC void
|
|
|
|
dump_textcenter (TCenterRecHdl h)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "y = 0x%08x\n", TEXTCENTER_Y (h)));
|
|
|
|
iprintf ((o_fp, "x = 0x%08x\n", TEXTCENTER_X (h)));
|
|
|
|
}
|
|
|
|
|
|
|
|
PUBLIC void
|
|
|
|
dump_zone_stats (void)
|
|
|
|
{
|
|
|
|
iprintf ((o_fp, "applzone free = %d\n", ZONE_ZCB_FREE (MR (ApplZone))));
|
|
|
|
iprintf ((o_fp, " syszone free = %d\n", ZONE_ZCB_FREE (MR (SysZone))));
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* !NDEBUG */
|