github.com/Interlisp.maiko
1
0
Fork 0
mirror of https://github.com/Interlisp/maiko.git synced 2026-01-16 00:04:59 +00:00
Code Issues Projects Releases Wiki Activity
Interlisp.maiko/src/uraid.c
Nick Briggs 35b4ad4350 Fix ups for new llstk.h. 
modified:   bin/makefile-darwin.386-x
	modified:   bin/makefile-tail
	new file:   inc/llstk.h
	modified:   src/gcfinal.c
	modified:   src/hardrtn.c
	modified:   src/llstk.c
	modified:   src/uraid.c
	modified:   src/xc.c
	modified:   src/xc.c.orig
2017-06-30 17:42:46 -07:00

1414 lines
41 KiB
C
Raw Blame History

/* @(#) uraid.c Version 1.52 (4/23/92). copyright Venue & Fuji Xerox */
static char *id = "@(#) uraid.c 1.52 4/23/92 (Venue & Fuji Xerox)";
/************************************************************************/
/* */
/* (C) Copyright 1989-1995 Venue. All Rights Reserved. */
/* Manufactured in the United States of America. */
/* */
/* The contents of this file are proprietary information */
/* belonging to Venue, and are provided to you under license. */
/* They may not be further distributed or disclosed to third */
/* parties without the specific permission of Venue. */
/* */
/************************************************************************/
#include "version.h"
/************************************************************************/
/************************************************************************/
/* */
/* U R A I D . C */
/* */
/* URAID is the low-level debugger for Medley. */
/* */
/************************************************************************/
/************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#ifdef ISC
#include <sys/bsdtypes.h>
#define vfork fork
#endif /* ISC */
#ifdef INDIGO
#define vfork fork
#endif /* INDIGO */
#include <sys/types.h>
#ifndef DOS
#include <sys/file.h>
#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/wait.h>
#endif /* DOS */
#include <fcntl.h>
#ifndef XWINDOW
#ifdef SUNDISPLAY
#include <sundev/kbd.h>
#include <sundev/kbio.h>
#endif /* SUNDISPLAY */
#include <errno.h>
#ifndef NOPIXRECT
#include <sunwindow/window_hs.h>
#include <sunwindow/win_ioctl.h>
#include <pixrect/pixrect_hs.h>
#include <sunwindow/win_cursor.h>
#include <sunwindow/cms.h>
#include <sys/mman.h>
#ifdef SUNDISPLAY
extern int Win_security_p;
#endif /* SUNDISPLAY */
#endif /* NOPIXRECT */
#endif /* XWINDOW */
#ifdef OS5
#include <stropts.h>
#endif /* OS5 */
#if defined(FREEBSD) || defined(MACOSX)
/* for memset */
#include <string.h>
#endif
#include "lispemul.h"
#include "lispmap.h"
#include "adr68k.h"
#include "lsptypes.h"
#include "lspglob.h"
#include "emlglob.h"
#include "cell.h"
#include "stack.h"
#include "llstk.h"
#include "ifpage.h"
#include "debug.h"
#include "devconf.h"
#include "display.h"
#include "bitblt.h"
#include "uraid.h"
#ifdef DOS
#define vfork() printf("No forking around here.\n")
#endif /* DOS */
#if defined(DOS) || defined(XWINDOW)
#include "devif.h"
extern DspInterface currentdsp;
#endif /* DOS || XWINDOW */
#ifdef DOS
extern MouseInterface currentmouse;
extern KbdInterface currentkbd;
#endif /* DOS */
#ifdef COLOR
extern int MonoOrColor;
extern int Dispcolorsize;
extern DLword *ColorDisplayRegion68k;
#endif /* COLOR */
/***********************************************************************/
/*
File name : uraid.c
Written by : Takeshi Shimizu(Take)
Date: 6-May-1988
This File Supports the following commands:
**URAID command summary**
<<Displaying a Stack>>
c Checks all user stack contents
f number Displays frame extension for the number(decimal)
k type Changes the type of stack link following.(a|c)
l [type] Back trace for specified type stack.(k|m|r|g|p|u)
<CR> Display next frame.
<<Displaying the Memory contents>>
a litatom Displays the top-level value of the litatom
d litatom Displays the definition cell for the litatom
M Displays TOS,CSP,PVAR,IVAR,PC
m func1 func2 MOVED func1 to func2
t Xaddress Displays the type of this object
p litatom Displays the property list of the litatom
w Displays the current function-name and PC
x Xaddress [xnum] Hex-Dump xnum word(16-bits) starting at Xaddress
@ litatom val Sets TOPVAL of litatom to Decimal-val
< Xaddress val Sets the word(16-bits) at the address to val
<<Return or Exit>>
e Exit to UNIX / DOS
h Context switch to HARDRESET
q Returns from URAID with NO-change
<<Misc>>
s Invoke Shell
v filename Save the virtual memory on the filename(Not Bootable)
( [num] Sets Print level
! Prints the error message passed from the emulator
? Display this summary
*/
/************************************************************************/
#ifndef NOPIXRECT
extern int black, white;
extern struct pixrect *ColorDisplayPixrect, *DisplayRegionPixrect;
#endif /* NOPIXRECT */
extern int DisplayRasterWidth;
extern unsigned int LispReadFds, LispWindowFd, LispKbdFd;
#ifndef NOPIXRECT
extern struct pixrect *CursorBitMap, *InvisibleCursorBitMap;
#endif /* NOPIXRECT */
extern struct cursor CurrentCursor, InvisibleCursor;
extern struct screen LispScreen;
extern int displaywidth, displayheight;
extern DLword *DisplayRegion68k;
extern int FrameBufferFd, ether_fd, RS232C_Fd;
extern u_int EtherReadFds;
LispPTR RadiAtomIndex;
LispPTR RaidPackageIndex;
char *HideDisp68k;
#ifdef COLOR
char *HideColorDisp68k;
extern int Inited_Color;
#endif /* COLOR */
#ifdef DOS
char *URaid_summary1 =
"<<Displaying the Stack>>\n\
c\t\t\tChecks all user stack contents\n\
f number\t\tDisplays stack frame for that frame number (decimal)\n\
k type\t\t\tChanges the type of stack link following. (a|c)\n\
l [type]\t\tBack Trace for specified type stack. (k|m|r|g|p|u|<null>)\n\
<CR>\t\t\tDisplay next frame.\n";
char *URaid_summary2 =
"<<Displaying memory contents>>\n\
a litatom\t\tDisplays the top-level value of the litatom\n\
B Xaddress\t\tPrint the contents of the arrayblock at that address.\n\
d litatom\t\tDisplays the definition cell for the litatom\n\
M\t\t\tDisplays TOS,CSP,PVAR,IVAR,PC\n\
m func1 func2\t\tMOVD func1 to func2\n\
O Xaddress\t\tDisplays the object with that address\n\
t Xaddress\t\tDisplays the type of this object\n\
p litatom\t\tDisplays the property list of the litatom\n\
w\t\t\tDisplays the current function-name and PC\n\
x Xaddress [xnum]\tHex-Dump xnum (16-bit) words starting at Xaddress\n\
@ litatom val\t\tSets TOPVAL of litatom to Decimal-val\n\
< Xaddress Xval\t\tSets the (16-bit) word at the address to Xval\n";
char *URaid_summary3 =
"<<Return or Exit>>\n\
e\t\t\tExit to DOS\n\
h\t\t\tDo a HARDRESET\n\
q\t\t\tReturns from URAID with NO change\n\
<<Misc>>\ns\t\t\tInvoke Shell\n\
v filename\t\tSave the virtual memory on the filename(Not Bootable)\n\
( [num]\t\t\tSets Print level\n\
!\t\t\tPrints the error message passed from the emulator\n\
?\t\t\tDisplay this summary";
#else
char *URaid_summary =
"---URAID command summary---\n\
<<Displaying the Stack>>\n\
c\t\t\tChecks all user stack contents\n\
f number\t\tDisplays stack frame for that frame number (decimal)\n\
k type\t\t\tChanges the type of stack link following. (a|c)\n\
l [type]\t\tBack Trace for specified type stack. (k|m|r|g|p|u|<null>)\n\
<CR>\t\t\tDisplay next frame.\n<<Displaying memory contents>>\n\
a litatom\t\tDisplays the top-level value of the litatom\n\
B Xaddress\t\tPrint the contents of the arrayblock at that address.\n\
d litatom\t\tDisplays the definition cell for the litatom\n\
M\t\t\tDisplays TOS,CSP,PVAR,IVAR,PC\n\
m func1 func2\t\tMOVD func1 to func2\n\
O Xaddress\t\tDisplays the object with that address\n\
t Xaddress\t\tDisplays the type of this object\n\
p litatom\t\tDisplays the property list of the litatom\n\
w\t\t\tDisplays the current function-name and PC\n\
x Xaddress [xnum]\tHex-Dump xnum (16-bit) words starting at Xaddress\n\
@ litatom val\t\tSets TOPVAL of litatom to Decimal-val\n\
< Xaddress Xval\t\tSets the (16-bit) word at the address to Xval\n\
<<Return or Exit>>\n\
e\t\t\tExit to UNIX\n\
h\t\t\tDo a HARDRESET\n\
q\t\t\tReturns from URAID with NO change\n\
<<Misc>>\ns\t\t\tInvoke Shell\n\
v filename\t\tSave the virtual memory on the filename(Not Bootable)\n\
( [num]\t\t\tSets Print level\n\
!\t\t\tPrints the error message passed from the emulator\n\
?\t\t\tDisplay this summary";
#endif /* DOS */
#define ADD_RANGEP(address) \
if ((address < 0) || (POINTERMASK < address)) { \
printf("Address out of range.\n"); \
return (T); \
}
extern int get_package_atom();
#define URMAXCOMM 512
#define URMAXFXNUM 2000
#define URSCAN_ALINK 0
#define URSCAN_CLINK 1
/*** URaid G vals ***/
int URaid_scanlink = URSCAN_ALINK;
int URaid_currentFX = URMAXFXNUM + 1;
FX *URaid_FXarray[URMAXFXNUM];
int URaid_ArrMAXIndex;
char URaid_inputstring[URMAXCOMM];
char URaid_comm;
char URaid_arg1[URMAXCOMM / 2];
char URaid_arg2[URMAXCOMM / 2];
int URaid_argnum;
char *URaid_errmess;
extern int PrintMaxLevel; /* for print level */
/***********************************************************************/
/*
func name : parse_atomstring(string)
Written by : Takeshi Shimizu
Date: 6-May-1988
Pass the atomstring(e.g. "XCL:EVAL")
Then Returns atomindex .
If fail to find, return -1
If there is no package prefix,it will be treated as IL:
*/
/***********************************************************************/
LispPTR make_atom();
LispPTR parse_atomstring(char *string)
{
char *start, *packageptr, *nameptr;
int flag = 0;
int packagelen = 0;
int namelen = 0;
int cnt;
LispPTR aindex;
for (cnt = 0, start = string; *string != '\0'; string++, cnt++) {
if (*string == ':') {
packagelen = cnt;
packageptr = start;
nameptr = string + 1;
cnt = 0;
*string = 0;
}
}
if (packagelen == 0) { /* treat as IL: */
nameptr = start;
namelen = cnt;
} else
namelen = cnt - 1;
if ((packagelen == 0) || (strncmp(packageptr, "IL", packagelen) == 0)) { /* default IL: */
aindex = make_atom(nameptr, 0, namelen, T);
if (aindex == 0xffffffff) {
printf("trying IL:\n");
aindex = get_package_atom(nameptr, namelen, "INTERLISP", 9, 0);
}
} else
aindex = get_package_atom(nameptr, namelen, packageptr, packagelen, 0);
if (aindex == 0xffffffff) return (0xffffffff);
printf("INDEX : %d\n", aindex & 0xffff);
return (aindex & 0xffff);
}
/***********************************************************************/
/*
func name : uraid_commclear()
Written by : Takeshi Shimizu
Date: 6-May-1988
Clear Command buffer
*/
/***********************************************************************/
void uraid_commclear() {
memset(URaid_inputstring, 0, URMAXCOMM);
memset(URaid_arg1, 0, URMAXCOMM / 2);
memset(URaid_arg2, 0, URMAXCOMM / 2);
URaid_comm = 0;
URaid_argnum = 0;
}
void copy_region(short *src, short *dst, int width, int h)
{
register int w;
for (; (h--);) {
for (w = width; (w--);) { GETWORD(dst++) = GETWORD(src++); }
}
}
/***********************************************************************/
/*
func name : uraid_commands()
Written by : Takeshi Shimizu
Date: 6-May-1988
Execute URaid commands
To continue, return T
To exit, return NIL
*/
/***********************************************************************/
LispPTR uraid_commands() {
int num, address, val, tmp;
LispPTR index;
DefCell *defcell68k;
#ifndef DOS
#if defined(SYSVONLY) || defined(WAITINT)
int status;
#else
union wait status;
#endif /* SYSVONLY */
#endif /* DOS */
if (URaid_argnum == -1) {
/* disp next FX */
if (URaid_currentFX > URaid_ArrMAXIndex) {
printf("There is no more stack.\n");
return (T);
} else {
sf(URaid_FXarray[URaid_currentFX++]);
return (T);
}
}
switch (URaid_comm) {
/*** Displaying STACK stuff */
#ifdef DOS
case '1': printf("%s\n", URaid_summary1); break;
case '2': printf("%s\n", URaid_summary2); break;
case '3': printf("%s\n", URaid_summary3); break;
#endif /* DOS */
case 'c': stack_check(0); break;
case 'C': all_stack_dump(0, 0, T); break;
case 'f': /**if((URaid_arg1[0] < '0') || (URaid_arg1[0] > '9')){
printf("Illegal argument, not a number\n");
return(T);
}**/
if (URaid_argnum == 1) /* f comm only */
{
printf("DUMP-STACK: f decimal-FXnumber\n");
return (T);
}
if (sscanf(URaid_arg1, "%d", &num) <= 0) { /* com read fails */
printf("Illegal argument, not decimal number\n");
return (T);
}
if ((num > URaid_ArrMAXIndex) || (num < 0)) {
printf("Frame number doesn't exist.\n");
return (T);
}
sf(URaid_FXarray[num]);
URaid_currentFX = num + 1;
break;
case 'k':
if ((URaid_arg1[0] == 'A') || (URaid_arg1[0] == 'a'))
URaid_scanlink = URSCAN_ALINK;
else if ((URaid_arg1[0] == 'C') || (URaid_arg1[0] == 'c'))
URaid_scanlink = URSCAN_CLINK;
else
printf("Link type should be A or C\n");
break;
case 'l':
if (URaid_argnum == 1) {
bt(); /* default case CURRENTFX */
return (T);
}
switch (URaid_arg1[0]) {
case 'k':
printf("IFP->KBDFXP :\n");
bt1(Addr68k_from_StkOffset(InterfacePage->kbdfxp));
break;
case 'm':
printf("IFP->MISCFXP :\n");
bt1(Addr68k_from_StkOffset(InterfacePage->miscfxp));
break;
case 'r':
printf("IFP->RESETFXP :\n");
bt1(Addr68k_from_StkOffset(InterfacePage->resetfxp));
break;
case 'g':
printf("IFP->GCFXP :\n");
bt1(Addr68k_from_StkOffset(InterfacePage->gcfxp));
break;
case 'p':
printf("IFP->FAULTFXP :\n");
bt1(Addr68k_from_StkOffset(InterfacePage->faultfxp));
break;
case 'u': bt(); break;
default: printf("2nd argument should be k,m,r,g,p,u or null.\n"); break;
} /* switch end */
break;
/* Displaying the memory contents stuff */
case 'a': /* GETTOPVAL */
if (URaid_argnum != 2) {
printf("GETTOPVAL: a litatom\n");
return (T);
}
if ((index = parse_atomstring(URaid_arg1)) == 0xffffffff) {
printf("No such atom.\n");
return (T);
} else {
printf("Atom: %s index %d\n", URaid_arg1, index);
}
print(*((LispPTR *)GetVALCELL68k(index)));
break;
case 'd': /* DEFCELL */
if (URaid_argnum != 2) {
printf("GETD: d litatom\n");
return (T);
}
if ((index = parse_atomstring(URaid_arg1)) == 0xffffffff) {
printf("No such atom.\n");
return (T);
} else {
printf("Atom: %s index %d\n", URaid_arg1, index);
}
defcell68k = (DefCell *)GetDEFCELL68k(index);
if (defcell68k->ccodep) {
printf("{CCODEP}0x%x\n", defcell68k->defpointer);
return (T);
} else {
print(defcell68k->defpointer);
return (T);
}
break;
case 'M': /* Machine States */
printf("TOS : 0x%x\n", TopOfStack);
printf("CSTKP : 0x%x\n", LADDR_from_68k(CurrentStackPTR));
printf("PVAR : 0x%x\n", LADDR_from_68k(PVar));
printf("IVAR : 0x%x\n", LADDR_from_68k(IVar));
printPC();
putchar('\n');
break;
case 'm': /* MOVD */
if (URaid_argnum != 3) {
printf("MOVD: m <from funcname> <to funcname>\n");
return (T);
}
{
DefCell *fromfunc, *tofunc;
LispPTR fromindex, toindex;
if ((fromindex = parse_atomstring(URaid_arg1)) == 0xffffffff) {
printf("No such function (from)\n");
return (T);
}
if ((toindex = parse_atomstring(URaid_arg2)) == 0xffffffff) {
printf("No such function (to)\n");
return (T);
}
fromfunc = (DefCell *)GetDEFCELL68k(fromindex);
tofunc = (DefCell *)GetDEFCELL68k(toindex);
tofunc->defpointer = fromfunc->defpointer;
print(toindex);
printf(" is smashed with ");
print(fromindex);
putchar('\n');
}
break;
case 'O': { /* print instance from Laddr. Not documented */
int objaddr;
if (URaid_argnum == 1) {
printf("PRINT-INSTANCE: O HEX-LispAddress\n");
return (T);
}
if (sscanf(URaid_arg1, "%x", &objaddr) <= 0) {
printf("Arg not HEX number\n");
return (T);
}
print(objaddr);
} break;
case 't': /* Object TYPE */
if (URaid_argnum != 2) {
printf("PRINTTYPENAME: t Xaddress\n");
return (T);
}
/**HEXNUMP(URaid_arg1,"Not Address");**/
if (sscanf(URaid_arg1, "%x", &address) <= 0) {
printf("Arg not HEX number\n");
return (T);
}
ADD_RANGEP(address);
switch (address >> 16) {
case ATOM_HI:
printf("{ATOM}");
printf("0x%x\n", address);
break;
case STK_HI:
printf("{STK}");
printf("0x%x\n", address);
break;
case PLIS_HI:
printf("{PLIST}");
printf("0x%x\n", address);
break;
case FPTOVP_HI:
printf("{FPTOVP}");
printf("0x%x\n", address);
break;
case PNP_HI:
printf("{PNP}");
printf("0x%x\n", address);
break;
case DEFS_HI:
printf("{DEF}");
printf("0x%x\n", address);
break;
case VALS_HI:
printf("{VAL}");
printf("0x%x\n", address);
break;
case DISPLAY_HI:
case DISPLAY_HI + 1:
printf("{DISPLAY}");
printf("0x%x\n", address);
break;
default:
num = GetTypeNumber(address);
putchar('{');
print_atomname((DLword *)GetDTD(num));
putchar('}');
break;
} /* switch end */
break;
#define GetPROPCELL68k(index) ((LispPTR *)Plistspace + (index))
case 'p': /* property list */
if (URaid_argnum != 2) {
printf("GETPROPLIST : p litatom\n");
return (T);
}
if ((index = parse_atomstring(URaid_arg1)) == 0xffffffff) {
printf("No such atom\n");
return (T);
}
print(*(GetPROPCELL68k(index)) & POINTERMASK);
break;
case 'w': /* Disp CurrentFunc name & PC */ doko(); break;
#define XDUMPW 8
case 'x': /* HEX dump "x Xaddress Xnum" */
/* Obsolete
HEXNUMP(URaid_arg1,"Not Address");
HEXNUMP(URaid_arg2,"Not number");
***/
if (URaid_argnum == 1) { /* for help */
printf("HEX-DUMP: x Xaddress [Xnum]\n");
return (T);
}
if (sscanf(URaid_arg1, "%x", &address) <= 0) { /* arg1 not HEX */
printf("Arg(Xaddress) not Xaddress\n");
return (T);
}
switch (sscanf(URaid_arg2, "%x", &num)) {
case -1: /* Use defaultval for word-num */ num = XDUMPW; break;
case 0: /* Illegal number */
printf("Arg(Xnum) not Xnum\n");
return (T);
/* break; */
default: break;
}
if (num < 0) {
printf("Dump words num should be positive\n");
return (T);
}
/* Address range check */
ADD_RANGEP(address);
ADD_RANGEP(address + num);
{
int i;
DLword *ptr, *endptr;
ptr = (DLword *)Addr68k_from_LADDR(address);
endptr = ptr + num;
while (ptr < endptr) {
printf("0x%x : ", LADDR_from_68k(ptr));
for (i = 0; ((ptr < endptr) && (i < XDUMPW)); ptr++, i++) { printf("%4x ", *ptr); }
putchar('\n');
}
}
break;
case '@': /* SETTOPVAL */
if (URaid_argnum != 3) {
printf("SETTOPVAL: @ litatom Decimal-val\n");
return (T);
}
if ((index = parse_atomstring(URaid_arg1)) == 0xffffffff) {
printf("No such atom\n");
return (T);
}
if (strncmp(URaid_arg2, "NIL", 3) == 0) {
val = NIL;
} else if (*URaid_arg2 == 'T')
val = ATOM_T;
else {
if (sscanf(URaid_arg2, "%d", &val) == -1) {
printf(" Bad value\n");
return (T);
} else {
if ((val < -65536) || (65535 < val)) {
printf("Bad Val range\n");
return (T);
}
if (val >= 0)
val |= S_POSITIVE;
else {
val = val & 0xffff;
val |= S_NEGATIVE;
}
}
}
printf("Old value is ");
print(*((LispPTR *)GetVALCELL68k(index)));
putchar('\n');
*((LispPTR *)GetVALCELL68k(index)) = (LispPTR)val;
print(val);
break;
case '<':
if (URaid_argnum != 3) {
printf("Mem modify: < Xaddre Xval\n");
return (T);
}
/* Assignment */
/* OBSOLETE
HEXNUMP(URaid_arg1,"Not Address");
HEXNUMP(URaid_arg2,"Not Proper Value");
***/
if (sscanf(URaid_arg1, "%x", &address) <= 0) {
printf("Arg(Xaddress) not Xaddress\n");
return (T);
}
if (sscanf(URaid_arg2, "%x", &val) <= 0) {
printf("Arg(Xval) not Xaddress\n");
return (T);
}
ADD_RANGEP(address);
if (val < 0 || val > 0xffff) {
printf("Xval invalid (16 bit range exceeded).\n");
return (T);
}
{
DLword *ptr;
ptr = (DLword *)Addr68k_from_LADDR(address);
*ptr = val;
printf("0x%x : 0x%x\n", address, *ptr);
}
break;
/****MISC ****/
case 'q': /* return with do Nothing */
printf("Return to Lisp?[confirm](Y or N)<");
{
int c;
c = getchar();
if ((c == 'Y') || (c == 'y')) {
/*TopOfStack = NIL;*/
return (NIL);
}
}
fflush(stdin);
URaid_currentFX = URMAXFXNUM + 1;
return (T);
/* break; */
case 'h': /* HARDRESET */
printf("HARDRESET?[confirm](Y or N)<");
{
int c;
c = getchar();
if ((c == 'Y') || (c == 'y')) {
/*PC+= 3; for currentfx->pc ajust:MOve to subr */
contextsw(ResetFXP, 2, 0);
/*PC -= 3; in subr.c it increments by 3 */
fflush(stdin);
return (NIL); /* return to dispatch */
}
}
fflush(stdin);
break;
case 'e': /* exit to UNIX */
#ifdef DOS
printf("Exit to DOS?[confirm](Y or N)<");
#else /* DOS */
printf("Exit to UNIX?[confirm](Y or N)<");
#endif /* DOS */
{
int c;
c = getchar();
if ((c == 'Y') || (c == 'y')) exit(0);
}
fflush(stdin);
URaid_currentFX = URMAXFXNUM + 1;
break;
case 's': /* SHELL */
switch (vfork()) {
case -1: (void)fprintf(stderr, "uraid: Fork failed.\n"); exit(1);
case 0: (void)execl("/bin/sh", "sh", "-i", 0); exit(1);
default: break;
}
#ifndef DOS
(void)wait(&status);
/* system("/bin/sh -i"); */
#endif /* DOS */
return (T);
/* break; */
case 'v':
if (URaid_argnum != 2) {
printf("VMEMSAVE: v filename (it's NOT bootable)\n");
return (T);
}
#ifndef DISPLAYBUFFER
copy_region(HideDisp68k, DisplayRegion68k, DisplayRasterWidth, displayheight);
#endif /* DISPLAYBUFFER */
if (vmem_save(URaid_arg1) != NIL) {
#ifndef DISPLAYBUFFER
clear_display();
#endif /* DISPLAYBUFFER */
printf("VMEMSAVE fails\n");
} else {
clear_display();
printf("VMEMSAVE finished, but it's not bootable\n");
}
break;
case '(':
if (URaid_argnum == 1)
num = 2;
else if ((URaid_arg1[0] < '0') || (URaid_arg1[0] > '9')) {
printf("Illegal argument, not number\n");
return (T);
} else
sscanf(URaid_arg1, "%d", &num);
PrintMaxLevel = num;
printf("PrintLevel is set to %d.", num);
break;
case '?':
#ifdef DOS
printf(
" 1: <<Displaying the Stack>>\n 2: <<Displaying memory contents>>\n 3: <<Return or "
"Exit>>\n");
#else
printf("%s\n", URaid_summary);
#endif /* DOS */
break;
case '!': printf("Error message is: %s\n", URaid_errmess); break;
default: printf("Unsupported command.\n"); break;
} /* switch end */
return (T);
}
/************************************************************************/
/* */
/* device_before_raid() */
/* */
/* Written by : Takeshi Shimizu */
/* Date: 6-May-1988 */
/* */
/* */
/* Do whatever cleanup is necessary before leaving Lisp */
/* for URAID or for SUSPEND-LISP: Cache the display buffer, */
/* close the frame buffer, and any buffering pixrects. */
/* */
/************************************************************************/
#ifdef DISPLAYBUFFER
extern struct pixrect *ColorDisplayPixrect, *DisplayRegionPixrect;
#endif
#ifdef SUNDISPLAY
#define SV_ACQUIRE "/bin/sunview1/sv_acquire"
#define SV_RELEASE "/bin/sunview1/sv_release"
#endif /* SUNDISPLAY */
int device_before_raid() {
int keytrans;
int size;
int munmapstat;
struct pixrect *fb;
/* extern char *alloc_hideDISP(); */
#ifdef SUNDISPLAY
union wait status;
#endif /* SUNDISPLAY */
int_timer_off();
#if (defined(XWINDOW) && defined(SYSVSIGNALS) && defined(SIGIO))
sigrelse(SIGIO); /* So X events still get recognized. */
#endif /* XWINDOW + SYSVSIGNALS + SIGIO */
#ifdef SUNDISPLAY
win_setcursor(LispWindowFd, &InvisibleCursor);
#ifdef KBINT
int_io_close(LispWindowFd);
#endif
#endif /* SUNDISPLAY */
#ifdef NOETHER
#else
#ifdef ETHERINT
if (ether_fd > 0) /* check ether is used or not */
int_io_close(ether_fd);
#endif
#endif /* NOETHER */
#ifdef RS232INT
int_io_close(RS232C_Fd);
#endif
#ifdef SUNDISPLAY
mess_reset(); /* turn off console-msg handling */
#ifdef FX_AR_124
/* For AR 124. Type4 driver bug?? by m.matsuda */
{
long i;
for (i = 0; i < 900000; i++)
;
}
#endif /* FX_AR_124 */
if ((LispKbdFd = open(LispScreen.scr_kbdname, O_RDWR)) == -1) {
fprintf(stderr, "can't open %s\n", LispScreen.scr_kbdname);
return (-1);
}
keytrans = TR_EVENT; /* keyboard encodes key */
if (ioctl(LispKbdFd, KIOCTRANS, &keytrans) == -1) {
fprintf(stderr, "Error at ioctl errno =%d\n", errno);
return (-1);
}
close(LispKbdFd);
close(LispWindowFd);
#ifdef TRUECOLOR
truecolor_before_raid();
#endif /* TRUECOLOR */
#ifndef DISPLAYBUFFER
size = ((displaywidth * displayheight / 8 + (getpagesize() - 1)) & -getpagesize());
if ((HideDisp68k = malloc(size)) == 0) {
printf("can't malloc hide space\n");
return (-1);
}
copy_region(DisplayRegion68k, HideDisp68k, DisplayRasterWidth, displayheight);
#endif /* DISPLAYBUFFER */
#ifdef COLOR
save_colormap();
#ifndef DISPLAYBUFFER
if (Inited_Color) {
#else
if (MonoOrColor == COLOR_SCREEN) {
#endif /* DISPLAYBUFFER */
/* save color image */
size =
((displaywidth * displayheight + (getpagesize() - 1)) & -getpagesize()); /* 8 bit depth */
if ((HideColorDisp68k = malloc(size)) == 0) {
printf("can't malloc hide space\n");
return (-1);
}
copy_region(ColorDisplayRegion68k, HideColorDisp68k, DisplayRasterWidth * 8, displayheight);
} /* end if(MonoOrColor) */
#endif /* COLOR */
clear_display();
#ifdef DISPLAYBUFFER
pr_close(ColorDisplayPixrect);
close(FrameBufferFd);
#endif
if (Win_security_p) {
switch (vfork()) {
case -1: /* Error */ (void)fprintf(stderr, "display_before_exit: Fork failed.\n"); exit(1);
case 0: /* Child */
(void)execl(SV_RELEASE, "sv_release", 0);
/* should not return */
(void)fprintf(stderr, "display_before_exit: exec for sv_release failed\n");
exit(1);
default: /* Parent */
/* do nothing */
break;
}
(void)wait(&status); /* child dies after changing 16 */
if (status.w_retcode != 0) {
(void)fprintf(stderr, "device_before_raid: failed to set ownership of win devices\n");
exit(1);
}
}
#endif /* SUNDISPLAY */
#if defined(XWINDOW) || defined(DOS)
(currentdsp->cleardisplay)(currentdsp);
(currentdsp->device.before_raid)(currentdsp);
#ifdef DOS
(currentmouse->device.before_raid)(currentmouse);
(currentkbd->device.before_raid)(currentkbd);
#endif /* DOS */
#endif /* XWINDOW || DOS */
return (0);
}
/**
char *alloc_hideDISP(int size)
{
char *retaddr;
switch(*STORAGEFULLSTATE_word & 0xffff)
{
case SFS_NOTSWITCHABLE :
if((retaddr =malloc(size)) ==0){
fprintf(stderr,"can't alloc hide space\n");
}
break;
case 0 :
case SFS_SWITCHABLE :
retaddr =
(char*)Addr68k_from_LADDR((*ArraySpace2_word) & POINTERMASK);
printf("Hidespace inside Lisp(2)\n");
break;
case SFS_ARRAYSWITCHED :
retaddr=(char*)Addr68k_from_LADDR(*Next_Array_word & 0xffff);
;
printf("Hidespace inside Lisp(3)\n");
break;
case SFS_FULLYSWITCHED :
if((UNSIGNED)Addr68k_from_LADDR(*Next_MDSpage_word & 0xffff)
- (UNSIGNED)Addr68k_from_LADDR(*Next_Array_word & 0xffff)
>size) {
retaddr= (char*)Addr68k_from_LADDR(*Next_Array_word & 0xffff);
printf("Hidespace inside Lisp(4)\n");
}
else if((retaddr=malloc(size)) ==0){
fprintf(stderr,"can't alloc hide disp\n");
}
printf("Hidespace new\n");
break;
default : printf("Illegal data in STORAGEFULLSTATE\n");
retaddr=0;
break;
}
return(retaddr);
}
****/
/***********************************************************************/
/*
func name : device_after_raid()
Written by : Takeshi Shimizu
Date: 6-May-1988
This should be called when returning LISP.
*/
/***********************************************************************/
/*
* Seems like a bad return type or bad code, returning 0, -1, or NIL
* NBriggs May 2017
*/
#define KB_ALLUP 0xffff
static int re_init_display(int, int);
int device_after_raid() {
extern DLword *EmMouseX68K, *EmMouseY68K, *EmKbdAd068K, *EmRealUtilin68K;
extern DLword *EmKbdAd168K, *EmKbdAd268K, *EmKbdAd368K, *EmKbdAd468K, *EmKbdAd568K;
LispReadFds = 0;
if (re_init_display(DISPLAY_OFFSET, 65536 * 16 * 2) == -1) return (-1);
set_cursor();
init_keyboard(1);
#ifdef TRUECOLOR
truecolor_after_raid();
#endif /* TRUECOLOR */
#ifdef NOETHER
#else
init_ether();
#ifdef USE_DLPI
if (ether_fd > 0)
if (ioctl(ether_fd, I_SETSIG, S_INPUT) != 0) {
perror("after-uraid: I_SETSIG for ether failed:\n");
close(ether_fd);
ether_fd = -1;
return (-1);
}
#endif /* USE_DLPI */
#endif /* NOETHER */
#ifdef XWINDOW
#ifdef I_SETSIG
if (ioctl(ConnectionNumber(currentdsp->display_id), I_SETSIG, S_INPUT) < 0)
perror("SETSIG on X fd failed");
#endif /* I_SETSIG */
#endif /* XWINDOW */
int_init();
#ifdef SUNDISPLAY
LispReadFds |= (1 << LispWindowFd);
#endif /* SUNDISPLAY */
#ifdef NOETHER
#else
LispReadFds |= EtherReadFds;
#endif /* NOETHER */
#ifdef XWINDOW
(currentdsp->device.after_raid)(currentdsp);
LispReadFds |= (1 << ConnectionNumber(currentdsp->display_id));
flush_display_buffer();
#elif DOS
(currentdsp->device.after_raid)(currentdsp);
(currentmouse->device.after_raid)(currentmouse, currentdsp);
(currentkbd->device.after_raid)(currentkbd);
flush_display_buffer();
#endif /* XWINDOW | DOS */
int_timer_on();
*EmKbdAd068K = *EmRealUtilin68K = *EmKbdAd168K = *EmKbdAd268K = *EmKbdAd368K = *EmKbdAd468K =
*EmKbdAd568K = KB_ALLUP;
return (0);
} /* device_after_raid */
/***********************************************************************/
/*
func name :re_init_display(lisp_display_addr, display_max)
int lisp_display_addr, display_max;
Written by : Takeshi Shimizu
Date: 6-May-1988
This should be called when returning LISP.
Only called by device_after_raid
*/
/***********************************************************************/
#ifndef COLOR
static int re_init_display(int lisp_display_addr, int display_max)
{
int mmapstat, size;
struct pixrect *ColorFb;
extern struct pixrect *ColorDisplayPixrect, *DisplayRegionPixrect;
extern int DisplayType;
#ifdef SUNDISPLAY
union wait status;
if (Win_security_p) {
switch (vfork()) {
case -1: /* Error */ (void)fprintf(stderr, "re_init_display: Fork failed.\n"); exit(1);
case 0: /* Child */
(void)execl(SV_ACQUIRE, "sv_acquire", "0", "256", "250", 0);
/* should not return */
(void)fprintf(stderr, "re_init_display: exec for sv_acquire failed\n");
exit(1);
default: /* Parent */
/* do nothing */
break;
}
(void)wait(&status); /* child dies after changing 6 */
if (status.w_retcode != 0) {
(void)fprintf(stderr, "re_init_display: failed to set ownership of win devices\n");
exit(1);
}
}
mess_init();
if ((LispWindowFd = win_screennew(&LispScreen)) == -1) {
fprintf(stderr, "init_display: can't create LispWindow\n");
return (-1);
} else {
#ifdef KBINT
int_io_open(LispWindowFd);
fcntl(LispWindowFd, F_SETFL, fcntl(LispWindowFd, F_GETFL, 0) | FNDELAY);
#ifdef FX_AR_124
/* For AR 124. Type4 driver bug?? by m.matsuda */
{
long i;
for (i = 0; i < 900000; i++)
;
}
#endif /* FX_AR_124 */
#endif
}
#ifndef DISPLAYBUFFER
/* for CGFOUR dev */
if (DisplayType == SUN4COLOR) {
ColorFb = pr_open("/dev/fb");
pr_set_plane_group(ColorFb, PIXPG_OVERLAY_ENABLE);
pr_rop(ColorFb, 0, 0, ColorFb->pr_width, ColorFb->pr_height, PIX_SET, 0, 0, 0);
pr_set_plane_group(ColorFb, PIXPG_OVERLAY);
}
#else /* DISPLAYBUFFER is T */
/* ColorDisplayPixrect = pr_open("/dev/fb");
pr_putcolormap(ColorDisplayPixrect, 1, 1, &black, &black, &black);
pr_putcolormap(ColorDisplayPixrect, 0, 1, &white, &white, &white);
pr_putcolormap(ColorDisplayPixrect, 255, 1, &black, &black, &black);
pr_putcolormap(ColorDisplayPixrect,
(1<<ColorDisplayPixrect->pr_depth)-1, 1,
&black, &black, &black);
***/
#endif /* DISPLAYBUFFER */
init_cursor();
#ifndef DISPLAYBUFFER
size = ((displaywidth * displayheight / 8 + (getpagesize() - 1)) & -getpagesize());
mmapstat = (int)mmap(DisplayRegion68k, size, PROT_READ | PROT_WRITE,
#ifdef OS4
MAP_FIXED |
#endif /* OS4 */
MAP_SHARED,
FrameBufferFd, 0);
if (mmapstat == -1) {
fprintf(stderr, "re_init_display: ERROR at mmap system call\n");
fprintf(stderr, "errno = %d\n\n", errno);
return (0);
}
copy_region(HideDisp68k, DisplayRegion68k, DisplayRasterWidth, displayheight);
free(HideDisp68k);
#endif /* DISPLAYBUFFER */
#ifdef DISPLAYBUFFER
ColorDisplayPixrect = pr_open("/dev/fb");
flush_display_buffer();
/* refresh_CG6; */
#endif /* DISPLAYBUFFER */
#endif /* SUNDISPLAY */
return (0);
}
#else /* COLOR */
static int re_init_display(int lisp_display_addr, int display_max)
{
int mmapstat, size;
struct pixrect *ColorFb;
/*
extern struct pixrect *color_source;
*/
struct pixrect *color_source;
extern int DisplayType;
#ifdef SUNDISPLAY
union wait status;
if (Win_security_p) {
switch (vfork()) {
case -1: /* Error */ (void)fprintf(stderr, "re_init_display: Fork failed.\n"); exit(1);
case 0: /* Child */
(void)execl(SV_ACQUIRE, "sv_acquire", "0", "256", "250", 0);
/* should not return */
(void)fprintf(stderr, "re_init_display: exec for sv_acquire failed\n");
exit(1);
default: /* Parent */
/* do nothing */
break;
}
(void)wait(&status); /* child dies after changing 6 */
if (status.w_retcode != 0) {
(void)fprintf(stderr, "re_init_display: failed to set ownership of win devices\n");
exit(1);
}
}
mess_init();
if ((LispWindowFd = win_screennew(&LispScreen)) == -1) {
fprintf(stderr, "init_display: can't create LispWindow\n");
return (-1);
} else {
#ifdef KBINT
int_io_open(LispWindowFd);
fcntl(LispWindowFd, F_SETFL, fcntl(LispWindowFd, F_GETFL, 0) | FNDELAY);
#endif
}
#ifdef DISPLAYBUFFER
if ((FrameBufferFd = open(LispScreen.scr_fbname, 2)) == -1) {
perror("init_display: can't open FrameBuffer\n");
exit(-1);
}
#endif /* DISPLAYBUFFER */
restore_colormap();
if (MonoOrColor == MONO_SCREEN) {
#ifndef DISPLAYBUFFER
/* for CGFOUR dev */
if (DisplayType == SUN4COLOR) {
ColorFb = pr_open("/dev/fb");
pr_set_plane_group(ColorFb, PIXPG_OVERLAY_ENABLE);
pr_rop(ColorFb, 0, 0, ColorFb->pr_width, ColorFb->pr_height, PIX_SET, 0, 0, 0);
pr_set_plane_group(ColorFb, PIXPG_OVERLAY);
}
#else /* DISPLAYBUFFER is T */
/* ColorDisplayPixrect = pr_open("/dev/fb");
pr_putcolormap(ColorDisplayPixrect, 1, 1, &black, &black, &black);
pr_putcolormap(ColorDisplayPixrect, 0, 1, &white, &white, &white);
pr_putcolormap(ColorDisplayPixrect, 255, 1, &black, &black, &black);
pr_putcolormap(ColorDisplayPixrect,
(1<<ColorDisplayPixrect->pr_depth)-1, 1,
&black, &black, &black);
***/
#endif /* DISPLAYBUFFER */
init_cursor();
#ifndef DISPLAYBUFFER
size = ((displaywidth * displayheight / 8 + (getpagesize() - 1)) & -getpagesize());
mmapstat = (int)mmap(DisplayRegion68k, size, PROT_READ | PROT_WRITE,
#ifdef OS4
MAP_FIXED |
#endif /* OS4 */
MAP_SHARED,
FrameBufferFd, 0);
if (Inited_Color)
mmapstat = (int)mmap(ColorDisplayRegion68k, Dispcolorsize, PROT_READ | PROT_WRITE,
#ifdef OS4
MAP_FIXED |
#endif /* OS4 */
MAP_SHARED,
FrameBufferFd, 0x40000);
if (mmapstat == -1) {
fprintf(stderr, "re_init_display: ERROR at mmap system call\n");
fprintf(stderr, "errno = %d\n\n", errno);
return (0);
}
/* restore mono image */
copy_region(HideDisp68k, DisplayRegion68k, DisplayRasterWidth, displayheight);
free(HideDisp68k);
if (Inited_Color) { /* restore color image */
copy_region(HideColorDisp68k, ColorDisplayRegion68k, DisplayRasterWidth * 8, displayheight);
free(HideColorDisp68k);
} /* end if( Inited_Color ) */
#endif /* DISPLAYBUFFER */
#ifdef DISPLAYBUFFER
ColorDisplayPixrect = pr_open("/dev/fb");
flush_display_buffer();
/* refresh_CG6; */
#endif /* DISPLAYBUFFER */
} else { /* MonoOrColor is COLOR_SCREEN */
ColorFb = pr_open("/dev/fb");
#ifdef DISPLAYBUFFER
ColorDisplayPixrect = ColorFb;
#endif /* DISPLAYBUFFER */
color_source = mem_point(displaywidth, displayheight, 8, ColorDisplayRegion68k);
pr_rop(ColorFb, 0, 0, displaywidth, displayheight, PIX_SRC, color_source, 0, 0);
#ifndef DISPLAYBUFFER
pr_set_plane_group(ColorFb, PIXPG_OVERLAY_ENABLE);
pr_rop(ColorFb, 0, 0, ColorFb->pr_width, ColorFb->pr_height, PIX_CLR, 0, 0, 0);
#endif /* DISPLAYBUFFER */
pr_set_plane_group(ColorFb, PIXPG_8BIT_COLOR);
init_cursor();
mmapstat = (int)mmap(ColorDisplayRegion68k, Dispcolorsize, PROT_READ | PROT_WRITE,
#ifdef OS4
MAP_FIXED |
#endif
MAP_SHARED,
FrameBufferFd, 0x40000);
if (mmapstat == -1) {
perror("cgfour_init_color_display: ERROR at mmap system call\n");
error(
"cgfour_init_color_display: ERROR at mmap system call\n You may be able to continue by "
"typing 'q'");
/* printf("MMAP FAIL:BMBASE=0x%x\nNATIVE:= 0x%x\nLISPBASEN:= 0x%x\n",
color_bitmapbase,ColorDisplayRegion68k,Lisp_world);
*/
return (NIL);
} /* end if(mmapstat) */
#ifndef DISPLAYBUFFER
/* restore mono image */
copy_region(HideDisp68k, DisplayRegion68k, DisplayRasterWidth, displayheight);
free(HideDisp68k);
#endif /* DISPLAYBUFFER */
/* restore coloe image */
copy_region(HideColorDisp68k, ColorDisplayRegion68k, DisplayRasterWidth * 8, displayheight);
free(HideColorDisp68k);
} /* end if(MonoOrColor) */
#endif /* SUNDISPLAY */
return (0);
}
#endif /* COLOR */
Reference in New Issue View Git Blame Copy Permalink