github.com/Interlisp.maiko
1
0
Fork 0
mirror of https://github.com/Interlisp/maiko.git synced 2026-03-05 10:44:07 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #443 from Interlisp/cast-align

Browse Source 
Replace Addr68k and stack offset related macros with NativeAligned inline functions
This commit is contained in:
Nick Briggs
2022-09-29 13:01:32 -07:00
committed by GitHub
parent 5202c71a95 c2070d9892
commit f5b17b0e63
89 changed files with 1014 additions and 997 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
inc/adr68k.h
View File

@@ -9,8 +9,6 @@
* Hiroshi Hayata
*/
/************************************************************************/
/* */
/* Copyright 1989, 1990 Venue, Fuji Xerox Co., Ltd, Xerox Corp. */
@@ -20,8 +18,6 @@
/* */
/************************************************************************/
/**********************************************************************/
/*
Func name : adr68k.h
@@ -32,32 +28,62 @@
*/
/**********************************************************************/
#include <stddef.h>
#include <stdio.h>
#include "lispemul.h"
#include "lspglob.h"
static inline LispPTR LAddrFromNative(void *NAddr)
{
if ((uintptr_t)NAddr & 1) {
printf("Misaligned pointer in LAddrFromNative %p\n", NAddr);
}
return ((DLword *)NAddr) - Lisp_world;
}
/* translate 68k ptr to Lisp DLword address */
#define LADDR_from_68k(ptr68k) ((LispPTR)(((UNSIGNED)(ptr68k) - (UNSIGNED)Lisp_world) >>1))
static inline DLword *NativeAligned2FromLAddr(LispPTR LAddr)
{
return (Lisp_world + LAddr);
}
static inline LispPTR *NativeAligned4FromLAddr(LispPTR LAddr)
{
if (LAddr & 1) {
printf("Misaligned pointer in NativeAligned4FromLAddr 0x%x\n", LAddr);
}
return (LispPTR *)(Lisp_world + LAddr);
}
/* translate 68k ptr to Lisp Page number */
#define LPAGE_from_68k(ptr68k) (LADDR_from_68k(ptr68k) >> 8)
static inline LispPTR *NativeAligned4FromLPage(LispPTR LPage)
{
return (LispPTR *)(Lisp_world + (LPage << 8));
}
static inline DLword StackOffsetFromNative(void *SAddr)
{
/* Stack offsets are expressed as an offset in DLwords from the stack base */
ptrdiff_t hoffset = (DLword *)SAddr - Stackspace;
if (hoffset > 0xffff) {
printf("Stack offset is too large: 0x%tx\n", hoffset);
}
return (DLword)hoffset;
}
/* Translate Lisp_address to 68K address */
/* Lisp_addr: word offset */
#define Addr68k_from_LADDR(Lisp_addr) (Lisp_world + (Lisp_addr))
static inline DLword *NativeAligned2FromStackOffset(DLword StackOffset)
{
return Stackspace + StackOffset;
}
static inline LispPTR *NativeAligned4FromStackOffset(DLword StackOffset)
{
return (LispPTR *)(Stackspace + StackOffset);
}
/* translate LispPage to 68k address */
#define Addr68k_from_LPAGE(Lisp_page) (Addr68k_from_LADDR(((Lisp_page) << 8) ))
/* Stack Offset Macros */
#define StkOffset_from_68K(ptr68k)\
((LispPTR)(((UNSIGNED)(ptr68k) - (UNSIGNED)Stackspace) >>1))
#define Addr68k_from_StkOffset(stkoffset)\
(Stackspace + (stkoffset))
static inline LispPTR LPageFromNative(void *NAddr)
{
if ((uintptr_t)NAddr & 1) {
printf("Misaligned pointer in LPageFromNative %p\n", NAddr);
}
return (((DLword *)NAddr) - Lisp_world) >> 8;
}
#endif /* ADR68K_H */

10
inc/arith.h
View File

@@ -9,7 +9,7 @@
/* */
/************************************************************************/
#include "adr68k.h" // for Addr68k_from_LADDR, LADDR_from_68k
#include "adr68k.h" // for NativeAligned4FromLAddr, LAddrFromNative
#include "commondefs.h" // for error
#include "lispemul.h" // for SEGMASK, ERROR_EXIT
#include "lispmap.h" // for S_NEGATIVE, S_POSITIVE
@@ -55,9 +55,9 @@ static inline LispPTR GetPosSmallp(unsigned long x) {
return (S_POSITIVE | 0);
}
#define FIXP_VALUE(dest) *((int *)Addr68k_from_LADDR(dest))
#define FIXP_VALUE(dest) *((int *)NativeAligned4FromLAddr(dest))
#define FLOATP_VALUE(dest) *((float *)Addr68k_from_LADDR(dest))
#define FLOATP_VALUE(dest) *((float *)NativeAligned4FromLAddr(dest))
#define N_GETNUMBER(sour, dest, label) \
do { \
@@ -102,7 +102,7 @@ static inline LispPTR GetPosSmallp(unsigned long x) {
/* arg is FIXP, call createcell */ \
fixpp = (int *)createcell68k(TYPE_FIXP); \
*((int *)fixpp) = (int)(arg); \
(result) = (LADDR_from_68k(fixpp)); \
(result) = (LAddrFromNative(fixpp)); \
break; \
} \
} \
@@ -118,7 +118,7 @@ static inline LispPTR GetPosSmallp(unsigned long x) {
/* arg is FIXP, call createcell */ \
fixpp = (int *)createcell68k(TYPE_FIXP); \
*fixpp = arg; \
return (LADDR_from_68k(fixpp)); \
return (LAddrFromNative(fixpp)); \
} \
} \
} while (0)

28
inc/cell.h
View File

@@ -22,6 +22,7 @@
*/
/**********************************************************************/
#include "adr68k.h" /* for NativeAligned4FromLPage, NativeAligned4FromLAddr */
#include "lispemul.h" /* for LispPTR, DLword */
/* CONS CELL (LISTP) definitions moved to lispemulater.h */
@@ -101,13 +102,13 @@ struct conspage {
/* Following MACROs for Conspage */
/* lisp_ptr is LISP pointer, returns 68k ptr points struct conspage obj */
#define Get_ConsPageBase(lisp_ptr) (struct conspage *)Addr68k_from_LPAGE(POINTER_PAGEBASE(lisp_ptr))
#define Get_ConsPageBase(lisp_ptr) (struct conspage *)NativeAligned4FromLPage(POINTER_PAGEBASE(lisp_ptr))
#define GetNewCell_68k(conspage68k) \
(ConsCell *)(((DLword *)(conspage68k)) + (unsigned)((conspage68k)->next_cell))
/* page : LISP page */
#define GetCONSCount(page) (((struct conspage *)Addr68k_from_LPAGE(page))->count)
#define GetCONSCount(page) (((struct conspage *)NativeAligned4FromLPage(page))->count)
#ifndef BYTESWAP
/* For chaining together free cons cells on a page */
@@ -377,20 +378,16 @@ struct cadr_cell {
#else
/* Good for old LITATOMS and new NEW-ATOMs */
#define GetDEFCELL68k(index) \
((((index) & SEGMASK) != 0) ? (LispPTR *)(Addr68k_from_LADDR(index) + NEWATOM_DEFN_OFFSET) \
: GetDEFCELLlitatom(index))
((((index) & SEGMASK) != 0) ? GetDEFCELLnew(index) : GetDEFCELLlitatom(index))
#define GetVALCELL68k(index) \
((((index) & SEGMASK) != 0) ? (LispPTR *)(Addr68k_from_LADDR(index) + NEWATOM_VALUE_OFFSET) \
: GetVALCELLlitatom(index))
((((index) & SEGMASK) != 0) ? GetVALCELLnew(index) : GetVALCELLlitatom(index))
#define GetPnameCell(index) \
((((index) & SEGMASK) != 0) ? (LispPTR *)(Addr68k_from_LADDR(index) + NEWATOM_PNAME_OFFSET) \
: GetPnameCelllitatom(index))
((((index) & SEGMASK) != 0) ? GetPnameCellnew(index) : GetPnameCelllitatom(index))
#define GetPropCell(index) \
((((index) & SEGMASK) != 0) ? (LispPTR *)(Addr68k_from_LADDR(index) + NEWATOM_PLIST_OFFSET) \
: GetPropCelllitatom(index))
((((index) & SEGMASK) != 0) ? GetPropCellnew(index) : GetPropCelllitatom(index))
/* Good only for old-style LITATOMS */
#ifdef BIGVM
@@ -406,10 +403,13 @@ struct cadr_cell {
#endif
/* Good only for new-style NEW-ATOMs */
#define GetDEFCELLnew(index) (LispPTR *)(Addr68k_from_LADDR(index) + NEWATOM_DEFN_OFFSET)
#define GetVALCELLnew(index) (LispPTR *)(Addr68k_from_LADDR(index) + NEWATOM_VALUE_OFFSET)
#define GetPnameCellnew(index) (LispPTR *)(Addr68k_from_LADDR(index) + NEWATOM_PNAME_OFFSET)
#define GetPropCellnew(index) (LispPTR *)(Addr68k_from_LADDR(index) + NEWATOM_PLIST_OFFSET)
/* Note: the _OFFSET values are in units of DLword so need to be adjusted before doing pointer
* arithmetic since we now have native pointers to cells not DLwords
*/
#define GetDEFCELLnew(index) (NativeAligned4FromLAddr(index) + (NEWATOM_DEFN_OFFSET / DLWORDSPER_CELL))
#define GetVALCELLnew(index) (NativeAligned4FromLAddr(index) + (NEWATOM_VALUE_OFFSET / DLWORDSPER_CELL))
#define GetPnameCellnew(index) (NativeAligned4FromLAddr(index) + (NEWATOM_PNAME_OFFSET / DLWORDSPER_CELL))
#define GetPropCellnew(index) (NativeAligned4FromLAddr(index) + (NEWATOM_PLIST_OFFSET / DLWORDSPER_CELL))
#endif /* BIGATOMS */

109
inc/inlineC.h
View File

@@ -101,9 +101,9 @@
#define OPCAR \
do { \
if (Listp(TOPOFSTACK)) { \
ConsCell *DATUM68K = (ConsCell *)(Addr68k_from_LADDR(TOPOFSTACK)); \
ConsCell *DATUM68K = (ConsCell *)NativeAligned4FromLAddr(TOPOFSTACK); \
if (DATUM68K->cdr_code == CDR_INDIRECT) { \
TOPOFSTACK = ((LispPTR)((ConsCell *)Addr68k_from_LADDR(DATUM68K->car_field))->car_field); \
TOPOFSTACK = ((LispPTR)((ConsCell *)NativeAligned4FromLAddr(DATUM68K->car_field))->car_field); \
nextop1; \
} else { \
TOPOFSTACK = ((LispPTR)DATUM68K->car_field); \
@@ -122,7 +122,7 @@
#define OPCDR \
do { \
if (Listp(TOPOFSTACK)) { \
ConsCell *DATUM68K = (ConsCell *)(Addr68k_from_LADDR(TOPOFSTACK)); \
ConsCell *DATUM68K = (ConsCell *)(NativeAligned4FromLAddr(TOPOFSTACK)); \
int CDRCODEX = DATUM68K->cdr_code; \
if (CDRCODEX == CDR_NIL) { \
/* cdr-nil */ \
@@ -139,7 +139,7 @@
} else { \
/* cdr-differentpage */ \
TOPOFSTACK = \
((ConsCell *)(Addr68k_from_LADDR((TOPOFSTACK) + (CDRCODEX << 1))))->car_field; \
((ConsCell *)(NativeAligned4FromLAddr((TOPOFSTACK) + (CDRCODEX << 1))))->car_field; \
nextop1; \
} \
} else if (TOPOFSTACK == NIL_PTR) { \
@@ -152,7 +152,7 @@
#define OPCDR \
do { \
if (Listp(TOPOFSTACK)) { \
ConsCell *DATUM68K = (ConsCell *)(Addr68k_from_LADDR(TOPOFSTACK)); \
ConsCell *DATUM68K = (ConsCell *)(NativeAligned4FromLAddr(TOPOFSTACK)); \
int CDRCODEX = DATUM68K->cdr_code; \
if (CDRCODEX == CDR_NIL) { \
/* cdr-nil */ \
@@ -169,7 +169,7 @@
} else { \
/* cdr-differentpage */ \
TOPOFSTACK = \
((ConsCell *)(Addr68k_from_LADDR(POINTER_PAGEBASE(TOPOFSTACK) + (CDRCODEX << 1)))) \
((ConsCell *)(NativeAligned4FromLAddr(POINTER_PAGEBASE(TOPOFSTACK) + (CDRCODEX << 1)))) \
->car_field; \
nextop1; \
} \
@@ -239,18 +239,18 @@
#define GETBASE_N(N) \
do { \
TOPOFSTACK = \
(S_POSITIVE | GETWORD((DLword *)Addr68k_from_LADDR((POINTERMASK & TOPOFSTACK) + (N)))); \
(S_POSITIVE | GETWORD((DLword *)NativeAligned2FromLAddr((POINTERMASK & TOPOFSTACK) + (N)))); \
nextop2; \
} while (0)
#define GETBASEPTR_N(N) \
do { \
TOPOFSTACK = (POINTERMASK & *((LispPTR *)Addr68k_from_LADDR((POINTERMASK & TOPOFSTACK) + (N)))); \
TOPOFSTACK = (POINTERMASK & *((LispPTR *)NativeAligned4FromLAddr((POINTERMASK & TOPOFSTACK) + (N)))); \
nextop2; \
} while (0)
#define PUTBASEBYTE \
do { \
int byteoffset; \
LispPTR byteoffset; \
char *p_data; \
if (((SEGMASK & TOPOFSTACK) != S_POSITIVE) || ((unsigned short)TOPOFSTACK >= 256)) \
goto op_ufn; \
@@ -261,12 +261,12 @@
default: \
goto op_ufn; \
/*** if( GetTypeNumber(byteoffset) == TYPE_FIXP ) \
byteoffset = *((int *)Addr68k_from_LADDR(byteoffset)); \
byteoffset = *((int *)NativeAligned4FromLAddr(byteoffset)); \
else \
goto op_ufn; ***/ \
} \
--CSTKPTRL; \
p_data = (char *)Addr68k_from_LADDR(POINTERMASK & (POP_TOS_1)) + byteoffset; \
p_data = (char *)NativeAligned2FromLAddr(POINTERMASK & (POP_TOS_1)) + byteoffset; \
GETBYTE(p_data) = 0xFF & TOPOFSTACK; \
nextop1; \
} while (0)
@@ -278,31 +278,30 @@
case S_NEGATIVE: TOPOFSTACK |= 0xFFFF0000; break; \
default: \
if (GetTypeNumber(TOPOFSTACK) == TYPE_FIXP) \
TOPOFSTACK = *((int *)Addr68k_from_LADDR(TOPOFSTACK)); \
TOPOFSTACK = *NativeAligned4FromLAddr(TOPOFSTACK); \
else \
goto op_ufn; \
} \
TOPOFSTACK = \
(0xFF & (GETBYTE((char *)Addr68k_from_LADDR((POINTERMASK & (POP_TOS_1))) + TOPOFSTACK))) | \
S_POSITIVE; \
TOPOFSTACK = S_POSITIVE | (0xFF & \
(GETBYTE((char *)NativeAligned2FromLAddr((POINTERMASK & (POP_TOS_1))) + TOPOFSTACK))); \
nextop1; \
} while (0)
#define PUTBASEPTR_N(n) \
do { \
int base; \
LispPTR base; \
base = POINTERMASK & POP_TOS_1; \
*((LispPTR *)Addr68k_from_LADDR(base + (n))) = TOPOFSTACK; \
*((LispPTR *)NativeAligned4FromLAddr(base + (n))) = TOPOFSTACK; \
TOPOFSTACK = base; \
nextop2; \
} while (0)
#define PUTBASE_N(n) \
do { \
int base; \
LispPTR base; \
if (GetHiWord(TOPOFSTACK) != (S_POSITIVE >> 16)) goto op_ufn; \
base = POINTERMASK & POP_TOS_1; \
GETWORD((DLword *)Addr68k_from_LADDR(base + (n))) = GetLoWord(TOPOFSTACK); \
GETWORD((DLword *)NativeAligned2FromLAddr(base + (n))) = GetLoWord(TOPOFSTACK); \
TOPOFSTACK = base; \
nextop2; \
} while (0)
@@ -337,9 +336,9 @@
#elif defined(BIGVM)
#define GVAR(x) \
do { \
int tx = x; \
LispPTR tx = x; \
if (tx & SEGMASK) { \
PUSH(GetLongWord(Addr68k_from_LADDR((tx) + NEWATOM_VALUE_OFFSET))); \
PUSH(GetLongWord(NativeAligned4FromLAddr((tx) + NEWATOM_VALUE_OFFSET))); \
} else \
PUSH(GetLongWord((LispPTR *)AtomSpace + (tx * 5) + NEWATOM_VALUE_PTROFF)); \
\
@@ -348,9 +347,9 @@
#else
#define GVAR(x) \
do { \
int tx = x; \
LispPTR tx = x; \
if (tx & SEGMASK) { \
PUSH(GetLongWord(Addr68k_from_LADDR((tx) + NEWATOM_VALUE_OFFSET))); \
PUSH(GetLongWord(NativeAligned4FromLAddr((tx) + NEWATOM_VALUE_OFFSET))); \
} else \
PUSH(GetLongWord(Valspace + ((tx) << 1))); \
\
@@ -425,11 +424,11 @@
char *buff68k; /* pointer to BUFF */ \
\
if (GetTypeNumber(TOPOFSTACK) == TYPE_STREAM) { \
stream68k = (Stream *)Addr68k_from_LADDR(TOPOFSTACK); \
stream68k = (Stream *)NativeAligned4FromLAddr(TOPOFSTACK); \
if ((!stream68k->BINABLE) || (stream68k->COFFSET >= stream68k->CBUFSIZE)) goto op_ufn; \
\
/* get BUFFER instance */ \
buff68k = (char *)Addr68k_from_LADDR(stream68k->CBUFPTR); \
buff68k = (char *)NativeAligned2FromLAddr(stream68k->CBUFPTR); \
\
/* get BYTE data and set it to TOS */ \
TOPOFSTACK = (S_POSITIVE | (Get_BYTE(buff68k + (stream68k->COFFSET)++))); \
@@ -496,7 +495,7 @@
#define BIND \
do { \
int byte = Get_BYTE_PCMAC1; \
LispPTR byte = Get_BYTE_PCMAC1; \
unsigned n1; \
unsigned n2; \
LispPTR *ppvar; \
@@ -569,7 +568,7 @@
do { \
int temp, bb = b; \
temp = 0xF & bb; \
TOPOFSTACK = S_POSITIVE | (((GETWORD(Addr68k_from_LADDR(POINTERMASK & (TOPOFSTACK + (a))))) >> \
TOPOFSTACK = S_POSITIVE | (((GETWORD(NativeAligned2FromLAddr(POINTERMASK & (TOPOFSTACK + (a))))) >> \
(16 - ((0xF & (bb >> 4)) + temp + 1))) & \
n_mask_array[temp]); \
nextop3; \
@@ -577,13 +576,13 @@
#define PUTBITS_N_M(a, b) \
do { \
int base; \
LispPTR base; \
int bb = b; \
DLword *pword; \
int shift_size, field_size, fmask; \
if ((SEGMASK & TOPOFSTACK) != S_POSITIVE) { goto op_ufn; }; \
base = POINTERMASK & POP_TOS_1; \
pword = (DLword *)Addr68k_from_LADDR(base + (a)); \
pword = NativeAligned2FromLAddr(base + (a)); \
field_size = 0xF & bb; \
shift_size = 15 - (0xF & (bb >> 4)) - field_size; \
fmask = n_mask_array[field_size] << shift_size; \
@@ -671,7 +670,7 @@
#define CLARITHEQUAL \
do { \
int arg2; \
LispPTR arg2; \
SV; \
arg2 = POP_TOS_1; \
if ((TOPOFSTACK & SEGMASK) == S_POSITIVE) { \
@@ -696,7 +695,7 @@
SV; \
arrayarg = POP_TOS_1; \
if (GetTypeNumber(arrayarg) != TYPE_ONED_ARRAY) goto aref_ufn; \
arrayblk = (OneDArray *)Addr68k_from_LADDR(arrayarg); \
arrayblk = (OneDArray *)NativeAligned4FromLAddr(arrayarg); \
if ((TOPOFSTACK & SEGMASK) != S_POSITIVE) goto aref_ufn; \
index = TOPOFSTACK & 0xFFFF; \
if (index >= arrayblk->totalsize) goto aref_ufn; \
@@ -704,10 +703,10 @@
baseL = arrayblk->base; \
switch (arrayblk->typenumber) { \
case 38: /* pointer : 32 bits */ \
TOPOFSTACK = *(((int *)Addr68k_from_LADDR(baseL)) + index); \
TOPOFSTACK = *(NativeAligned4FromLAddr(baseL) + index); \
nextop1; \
case 20: /* signed : 16 bits */ \
TOPOFSTACK = (GETWORD(((DLword *)Addr68k_from_LADDR(baseL)) + index)) & 0xFFFF; \
TOPOFSTACK = (GETWORD(((DLword *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFFFF; \
if (TOPOFSTACK & 0x8000) \
TOPOFSTACK |= S_NEGATIVE; \
else \
@@ -715,47 +714,47 @@
nextop1; \
case 67: /* Character : 8 bits */ \
TOPOFSTACK = \
S_CHARACTER | ((GETBYTE(((char *)Addr68k_from_LADDR(baseL)) + index)) & 0xFF); \
S_CHARACTER | ((GETBYTE(((char *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFF); \
nextop1; \
case 22: /* signed : 32 bits */ \
TOPOFSTACK = *(((int *)Addr68k_from_LADDR(baseL)) + index); \
TOPOFSTACK = *(NativeAligned4FromLAddr(baseL) + index); \
switch (TOPOFSTACK & 0xFFFF0000) { \
case 0: TOPOFSTACK |= S_POSITIVE; break; \
case (unsigned)0xFFFF0000: TOPOFSTACK &= S_NEGATIVE; break; \
default: { \
DLword *wordp; \
wordp = createcell68k(TYPE_FIXP); \
*((int *)wordp) = TOPOFSTACK; \
TOPOFSTACK = (LispPTR)LADDR_from_68k(wordp); \
LispPTR *cellp; \
cellp = (LispPTR *)createcell68k(TYPE_FIXP); \
*cellp = TOPOFSTACK; \
TOPOFSTACK = (LispPTR)LAddrFromNative(cellp); \
} \
} \
nextop1; \
case 0: /* unsigned : 1 bit per element */ \
TOPOFSTACK = \
S_POSITIVE | (((GETBYTE(((char *)Addr68k_from_LADDR(baseL)) + (index >> 3))) >> \
S_POSITIVE | (((GETBYTE(((char *)NativeAligned2FromLAddr(baseL)) + (index >> 3))) >> \
(7 - (index & 7))) & \
1); \
nextop1; \
case 3: /* unsigned : 8 bits per element */ \
TOPOFSTACK = S_POSITIVE | ((GETBYTE(((char *)Addr68k_from_LADDR(baseL)) + index)) & 0xFF); \
TOPOFSTACK = S_POSITIVE | ((GETBYTE(((char *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFF); \
nextop1; \
case 4: /* unsigned : 16 bits per element */ \
TOPOFSTACK = \
S_POSITIVE | ((GETWORD(((DLword *)Addr68k_from_LADDR(baseL)) + index)) & 0xFFFF); \
S_POSITIVE | ((GETWORD(((DLword *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFFFF); \
nextop1; \
case 54: /* Float : 32 bits */ { \
DLword *wordp; \
wordp = createcell68k(TYPE_FLOATP); \
*((int *)wordp) = *(((int *)Addr68k_from_LADDR(baseL)) + index); \
TOPOFSTACK = (LispPTR)LADDR_from_68k(wordp); \
LispPTR *cellp; \
cellp = (LispPTR *)createcell68k(TYPE_FLOATP); \
*cellp = *(NativeAligned4FromLAddr(baseL) + index); \
TOPOFSTACK = (LispPTR)LAddrFromNative(cellp); \
} \
nextop1; \
case 68: /* Character : 16 bits */ \
TOPOFSTACK = \
S_CHARACTER | ((GETWORD(((DLword *)Addr68k_from_LADDR(baseL)) + index)) & 0xFFFF); \
S_CHARACTER | ((GETWORD(((DLword *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFFFF);\
nextop1; \
case 86: /* XPointer : 32 bits */ \
TOPOFSTACK = *(((int *)Addr68k_from_LADDR(baseL)) + index); \
TOPOFSTACK = *(NativeAligned4FromLAddr(baseL) + index); \
nextop1; \
default: /* Illegal or Unimplemented */ goto aref_ufn; \
} /* end switch typenumber */ \
@@ -792,26 +791,26 @@
#define FVAR(n) \
do { \
LispPTR *chain; \
LispPTR *chain; \
chain = (LispPTR *)(PVar + (n)); \
if (WBITSPTR(chain)->LSB) { \
PUSH(GetLongWord(Addr68k_from_LADDR(POINTERMASK &swapx(native_newframe((n) >> 1))))); \
PUSH(GetLongWord(NativeAligned4FromLAddr(POINTERMASK &swapx(native_newframe((n) >> 1))))); \
nextop1; \
} /* if(((WBITS */ \
PUSH(GetLongWord(Addr68k_from_LADDR(POINTERMASK &swapx(*chain)))); \
PUSH(GetLongWord(NativeAligned4FromLAddr(POINTERMASK &swapx(*chain)))); \
nextop1; \
} while (0)
#define FVARX(n) \
do { \
int nn = n; \
LispPTR *chain; \
int nn = n; \
LispPTR *chain; \
chain = (LispPTR *)(PVar + nn); \
if (WBITSPTR(chain)->LSB) { \
PUSH(GetLongWord(Addr68k_from_LADDR(POINTERMASK &swapx(native_newframe(nn >> 1))))); \
PUSH(GetLongWord(NativeAligned4FromLAddr(POINTERMASK &swapx(native_newframe(nn >> 1))))); \
nextop2; \
} /* if(((WBITS */ \
PUSH(GetLongWord(Addr68k_from_LADDR(POINTERMASK &swapx(*chain)))); \
PUSH(GetLongWord(NativeAligned4FromLAddr(POINTERMASK &swapx(*chain)))); \
nextop2; \
} while (0)

2
inc/inlnSPARC.h
View File

@@ -54,7 +54,7 @@ lispemul.h: typedef struct {unsigned code : 8;} BYTECODE;
{LispPTR *wordp; \
wordp = (LispPTR *) createcell68k(TYPE_FIXP); \
*((int *)wordp) = result; \
dest = (LADDR_from_68k(wordp)); } \
dest = (LAddrFromNative(wordp)); } \
else dest = (( (unsigned)result <<15) >>15) | S_POSITIVE;}

20
inc/locfile.h
View File

@@ -86,19 +86,19 @@ extern DLword *Lisp_world; /* To access LispSysout area */
char *lf_base, *lf_dp; \
short *lf_sbase; \
size_t lf_length; \
lf_arrayp = (OneDArray *)(Addr68k_from_LADDR(Lisp)); \
lf_arrayp = (OneDArray *)NativeAligned4FromLAddr(Lisp); \
lf_length = min(MaxLen, lf_arrayp->fillpointer); \
switch(lf_arrayp->typenumber) \
{ \
case THIN_CHAR_TYPENUMBER: \
lf_base = ((char *)(Addr68k_from_LADDR(lf_arrayp->base))) \
lf_base = ((char *)(NativeAligned2FromLAddr(lf_arrayp->base))) \
+ ((int)(lf_arrayp->offset)); \
strncpy(C, lf_base, lf_length); \
(C)[lf_length] = '\0'; \
break; \
\
case FAT_CHAR_TYPENUMBER: \
lf_sbase = ((short *)(Addr68k_from_LADDR(lf_arrayp->base))) \
lf_sbase = ((short *)(NativeAligned2FromLAddr(lf_arrayp->base))) \
+ ((int)(lf_arrayp->offset)); \
lf_dp = C; \
for(size_t lf_i=0;lf_i<(lf_length);lf_i++) \
@@ -116,19 +116,19 @@ extern DLword *Lisp_world; /* To access LispSysout area */
char *lf_base, *lf_dp; \
short *lf_sbase; \
size_t lf_length; \
lf_arrayp = (OneDArray *)(Addr68k_from_LADDR(Lisp)); \
lf_arrayp = (OneDArray *)(NativeAligned4FromLAddr(Lisp)); \
lf_length = min(MaxLen, lf_arrayp->fillpointer); \
switch(lf_arrayp->typenumber) \
{ \
case THIN_CHAR_TYPENUMBER: \
lf_base = ((char *)(Addr68k_from_LADDR(lf_arrayp->base))) \
lf_base = ((char *)(NativeAligned2FromLAddr(lf_arrayp->base))) \
+ ((int)(lf_arrayp->offset)); \
StrNCpyFromLispToC(C , lf_base , lf_length ); \
(C)[lf_length] = '\0'; \
break; \
\
case FAT_CHAR_TYPENUMBER: \
lf_sbase = ((short *)(Addr68k_from_LADDR(lf_arrayp->base))) \
lf_sbase = ((short *)(NativeAligned2FromLAddr(lf_arrayp->base))) \
+ ((int)(lf_arrayp->offset)); \
lf_dp = C; \
for(size_t lf_ii=0;lf_ii<(lf_length);lf_ii++,lf_sbase++) \
@@ -156,7 +156,7 @@ extern DLword *Lisp_world; /* To access LispSysout area */
#define LispStringLength(LispString, Length, FatP) \
{ \
OneDArray *lf_arrayp; \
lf_arrayp = (OneDArray *)(Addr68k_from_LADDR(LispString)); \
lf_arrayp = (OneDArray *)(NativeAligned4FromLAddr(LispString)); \
switch(lf_arrayp->typenumber) \
{ \
case THIN_CHAR_TYPENUMBER: \
@@ -186,8 +186,8 @@ extern DLword *Lisp_world; /* To access LispSysout area */
#define STRING_BASE(lstringp, cstringp) \
{ \
LispPTR *lf_naddress; \
lf_naddress = (LispPTR *)(Addr68k_from_LADDR(lstringp)); \
(cstringp) = (char *)(Addr68k_from_LADDR(((OneDArray *)lf_naddress)->base)); \
lf_naddress = (LispPTR *)(NativeAligned4FromLAddr(lstringp)); \
(cstringp) = (char *)(NativeAligned2FromLAddr(((OneDArray *)lf_naddress)->base)); \
}
#ifndef min
@@ -196,7 +196,7 @@ extern DLword *Lisp_world; /* To access LispSysout area */
#define LispNumToCInt(Lisp) \
( (((Lisp) & SEGMASK) == S_POSITIVE) ? \
((Lisp) & 0xFFFF) : (*((int *)(Addr68k_from_LADDR(Lisp)))) )
((Lisp) & 0xFFFF) : (*((int *)(NativeAligned4FromLAddr(Lisp)))) )
#define UPLOWDIFF 0x20

2
inc/mnxdefs.h
View File

@@ -501,7 +501,7 @@ typedef union mnwevenT
/* to a Medley window structure. */
/* The result of the calculation is a C pointer. */
/***************************************************/
#define Cptr(LADDR) Addr68k_from_LADDR(LADDR)
#define Cptr(LADDR) NativeAligned4FromLAddr(LADDR)
#define WIfFromMw(win) (((MedleyWindow)Cptr(win))->NativeIf)
#define ScrnFromMw(win) ((MedleyScreenRec *)Cptr(((MedleyWindow)Cptr(win))->SCREEN))
#define DspstreamFromMw(win) ((Stream *)Cptr(((MedleyWindow)Cptr(win))->DSP))

59
inc/my.h
View File

@@ -17,7 +17,7 @@
/* */
/************************************************************************/
#include "version.h" // for BIGVM
#include "adr68k.h" // for Addr68k_from_LADDR, LADDR_from_68k
#include "adr68k.h" // for NativeAligned2FromLAddr, NativeAligned4FromLAddr, LAddrFromNative
#include "arith.h" // for N_ARITH_SWITCH, N_GETNUMBER
#include "gcdata.h" // for ADDREF, DELREF
#include "lispemul.h" // for ERROR_EXIT, LispPTR, DLword, SEGMASK, state
@@ -45,10 +45,10 @@
default: \
switch (GetTypeNumber(arg)) { \
case TYPE_FLOATP: \
(dest) = *((float *)Addr68k_from_LADDR(arg)); \
(dest) = *((float *)NativeAligned4FromLAddr(arg)); \
break; \
case TYPE_FIXP: \
(dest) = (float)(*((int *)Addr68k_from_LADDR(arg)));\
(dest) = (float)(*((int *)NativeAligned4FromLAddr(arg))); \
break; \
default: ERROR_EXIT(tos); \
} \
@@ -62,7 +62,7 @@
(dest) = (arg) & 0xFFFF; \
else { \
if (GetTypeNumber(arg) != TYPE_FIXP) ERROR_EXIT(tos); \
if (((dest) = *((int *)Addr68k_from_LADDR(arg))) & 0x80000000) \
if (((dest) = *((int *)NativeAligned4FromLAddr(arg))) & 0x80000000) \
ERROR_EXIT(tos); \
} \
}
@@ -71,44 +71,45 @@ static inline LispPTR
aref_switch(unsigned type, LispPTR tos, LispPTR baseL, int index)
{
int result;
DLword *wordp;
switch (type)
{
case 38: /* pointer : 32 bits */
return(*(((LispPTR *)Addr68k_from_LADDR(baseL)) + index));
return(*(((LispPTR *)NativeAligned4FromLAddr(baseL)) + index));
case 20: /* signed : 16 bits */
result = (GETWORD(((DLword *)Addr68k_from_LADDR(baseL)) + index)) & 0xFFFF;
result = (GETWORD(((DLword *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFFFF;
if (result & 0x8000) return(result | S_NEGATIVE);
else return(result | S_POSITIVE);
case 67: /* Character : 8 bits */
return(S_CHARACTER | ((GETBYTE(((char *)Addr68k_from_LADDR(baseL)) + index)) & 0xFF));
return(S_CHARACTER | ((GETBYTE(((char *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFF));
case 22: /* signed : 32 bits */
result = *(((int *)Addr68k_from_LADDR(baseL)) + index);
result = *(((int *)NativeAligned4FromLAddr(baseL)) + index);
N_ARITH_SWITCH(result);
case 0: /* unsigned : 1 bit per element */
return(S_POSITIVE | (((GETBYTE(((char *)Addr68k_from_LADDR(baseL)) + (index >> 3))) >> (7 - (index & 7))) & 1));
return(S_POSITIVE | (((GETBYTE(((char *)NativeAligned2FromLAddr(baseL)) + (index >> 3))) >> (7 - (index & 7))) & 1));
case 3: /* unsigned : 8 bits per element */
return(S_POSITIVE | ((GETBYTE(((char *)Addr68k_from_LADDR(baseL)) + index)) & 0xFF));
return(S_POSITIVE | ((GETBYTE(((char *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFF));
case 4: /* unsigned : 16 bits per element */
return(S_POSITIVE | ((GETWORD(((DLword *)Addr68k_from_LADDR(baseL)) + index)) & 0xFFFF));
return(S_POSITIVE | ((GETWORD(((DLword *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFFFF));
case 54: /* Float : 32 bits */
wordp = createcell68k(TYPE_FLOATP);
*((LispPTR *)wordp) = *(((LispPTR *)Addr68k_from_LADDR(baseL)) + index);
return(LADDR_from_68k(wordp));
{
float *cellp = (float *)createcell68k(TYPE_FLOATP);
*cellp = *(float *)(NativeAligned4FromLAddr(baseL) + index);
return (LAddrFromNative(cellp));
}
case 68: /* Character : 16 bits */
return(S_CHARACTER | ((GETWORD(((DLword *)Addr68k_from_LADDR(baseL)) + index)) & 0xFFFF));
return(S_CHARACTER | ((GETWORD(((DLword *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFFFF));
case 86: /* XPointer : 32 bits */
return(*(((LispPTR *)Addr68k_from_LADDR(baseL)) + index));
return(*(((LispPTR *)NativeAligned4FromLAddr(baseL)) + index));
default: /* Illegal or Unimplemented */
ERROR_EXIT(tos);
@@ -119,60 +120,60 @@ aref_switch(unsigned type, LispPTR tos, LispPTR baseL, int index)
{ \
switch (type) { \
case 38: /* pointer : 32 bits */ \
GCLOOKUP(*(((int *)Addr68k_from_LADDR(base)) + index), DELREF); \
GCLOOKUP(*(((int *)NativeAligned4FromLAddr(base)) + index), DELREF); \
GCLOOKUP(data, ADDREF); \
*(((int *)Addr68k_from_LADDR(base)) + index) = data; \
*(((int *)NativeAligned4FromLAddr(base)) + index) = data; \
return(data); \
case 20: /* signed : 16 bits */ \
new = data & 0xFFFF; \
if ((((data & SEGMASK) == S_POSITIVE) && ((data & 0x8000) == 0)) ||\
(((data & SEGMASK) == S_NEGATIVE) && (data & 0x8000))) \
GETWORD(((DLword *)Addr68k_from_LADDR(base)) + index) = new; \
GETWORD(((DLword *)NativeAligned2FromLAddr(base)) + index) = new; \
else ERROR_EXIT(tos); \
return(data); \
case 67: /* Character : 8 bits */ \
if ((data & SEGMASK) != S_CHARACTER) ERROR_EXIT(tos); \
new = data & 0xFFFF; \
if (new > 0xFF) ERROR_EXIT(tos); \
GETBYTE(((char *)Addr68k_from_LADDR(base)) + index) = new; \
GETBYTE(((char *)NativeAligned2FromLAddr(base)) + index) = new; \
return(data); \
case 22: /* signed : 32 bits */ \
N_GETNUMBER(data, new, doufn); \
*(((int *)Addr68k_from_LADDR(base)) + index) = new; \
*(((int *)NativeAligned4FromLAddr(base)) + index) = new; \
return(data); \
case 0: /* unsigned : 1 bit per element */ \
N_GetPos(data, new, tos); \
if (new > 1) ERROR_EXIT(tos); \
if (new) { \
new = (1 << (7 - (index & 7))); \
GETBYTE(((char *)Addr68k_from_LADDR(base)) + (index >> 3)) |= new; \
GETBYTE(((char *)NativeAligned2FromLAddr(base)) + (index >> 3)) |= new; \
} \
else { \
new = 0xFF - (1 << (7 - (index & 7))); \
GETBYTE(((char *)Addr68k_from_LADDR(base)) + (index >> 3)) &= new; \
GETBYTE(((char *)NativeAligned2FromLAddr(base)) + (index >> 3)) &= new; \
} \
return(data); \
case 3: /* unsigned : 8 bits per element */ \
N_GetPos(data, new, tos); \
if (new > 0xFF) ERROR_EXIT(tos); \
GETBYTE(((char *)Addr68k_from_LADDR(base)) + index) = new; \
GETBYTE(((char *)NativeAligned2FromLAddr(base)) + index) = new; \
return(data); \
case 4: /* unsigned : 16 bits per element */ \
N_GetPos(data, new, tos); \
if (new > 0xFFFF) ERROR_EXIT(tos); \
GETWORD(((DLword *)Addr68k_from_LADDR(base)) + index) = new; \
GETWORD(((DLword *)NativeAligned2FromLAddr(base)) + index) = new; \
return(data); \
case 54: /* Float : 32 bits */ \
if (GetTypeNumber(data) != TYPE_FLOATP) ERROR_EXIT(tos); \
*(((int *)Addr68k_from_LADDR(base)) + index) = *((int *)Addr68k_from_LADDR(data)); \
*(((int *)NativeAligned4FromLAddr(base)) + index) = *((int *)NativeAligned4FromLAddr(data)); \
return(data); \
case 68: /* Character : 16 bits */ \
if ((data & SEGMASK) != S_CHARACTER) ERROR_EXIT(tos); \
new = data & 0xFFFF; \
GETWORD(((DLword *)Addr68k_from_LADDR(base)) + index) = new; \
GETWORD(((DLword *)NativeAligned2FromLAddr(base)) + index) = new; \
return(data); \
case 86: /* XPointer : 32 bits */ \
*(((int *)Addr68k_from_LADDR(base)) + index) = data; \
*(((int *)NativeAligned4FromLAddr(base)) + index) = data; \
return(data); \
default: /* Illegal or Unimplemented */ \
ERROR_EXIT(tos); \

20
inc/return.h
View File

@@ -37,10 +37,9 @@
#define FastRetCALL \
do { \
/* Get IVar from Returnee's IVAR offset slot(BF) */ \
IVar = Addr68k_from_LADDR(STK_OFFSET | GETWORD((DLword *)CURRENTFX -1)); \
IVar = NativeAligned2FromLAddr(STK_OFFSET | GETWORD((DLword *)CURRENTFX -1)); \
/* Get FuncObj from Returnee's FNHEAD slot in FX */ \
FuncObj = (struct fnhead *) \
Addr68k_from_LADDR(FX_FNHEADER); \
FuncObj = (struct fnhead *)NativeAligned4FromLAddr(FX_FNHEADER); \
/* Get PC from Returnee's pc slot in FX */ \
PC = (ByteCode *)FuncObj + CURRENTFX->pc ; \
} while (0)
@@ -48,10 +47,9 @@
#define FastRetCALL \
do { \
/* Get IVar from Returnee's IVAR offset slot(BF) */ \
IVar = Addr68k_from_LADDR(STK_OFFSET | GETWORD((DLword *)CURRENTFX -1)); \
IVar = NativeAligned2FromLAddr(STK_OFFSET | GETWORD((DLword *)CURRENTFX -1)); \
/* Get FuncObj from Returnee's FNHEAD slot in FX */ \
FuncObj = (struct fnhead *) \
Addr68k_from_LADDR(FX_FNHEADER); \
FuncObj = (struct fnhead *)NativeAligned4FromLAddr(FX_FNHEADER); \
/* Get PC from Returnee's pc slot in FX */ \
PC = (ByteCode *)FuncObj + CURRENTFX->pc ; \
if (!(FuncObj->byteswapped)) \
@@ -68,9 +66,9 @@
#define Midpunt(fxnum) \
{ DLword midpunt; \
midpunt = LOLOC(LADDR_from_68k(CURRENTFX)); \
midpunt = LOLOC(LAddrFromNative(CURRENTFX)); \
PVar=(DLword *) \
Addr68k_from_StkOffset( \
NativeAligned2FromStackOffset( \
(GETWORD(((DLword *)InterfacePage) + (fxnum)))) \
+ FRAMESIZE; \
GETWORD(((DLword *)InterfacePage) + (fxnum)) = midpunt ; \
@@ -80,7 +78,7 @@
#define CHECKFX \
if (((UNSIGNED)PVar -(UNSIGNED)CURRENTFX) != 20) \
{ printf("Invalid FX(0x%x) and PV(0x%x) \n", \
LADDR_from_68k(CURRENTFX),LADDR_from_68k(PVar)); \
LAddrFromNative(CURRENTFX),LAddrFromNative(PVar)); \
}
@@ -90,7 +88,7 @@
#define BEFORE_CONTEXTSW \
{ CurrentStackPTR += 2; \
CURRENTFX->nextblock=StkOffset_from_68K(CurrentStackPTR); \
CURRENTFX->nextblock=StackOffsetFromNative(CurrentStackPTR); \
GETWORD(CurrentStackPTR)=STK_FSB_WORD; \
GETWORD(CurrentStackPTR+1)= (((UNSIGNED)EndSTKP-(UNSIGNED)(CurrentStackPTR))>>1); \
if (GETWORD(CurrentStackPTR+1) == 0) error("0-long free block."); \
@@ -99,7 +97,7 @@
#define AFTER_CONTEXTSW \
{ DLword *ac_ptr68k,*ac_freeptr; \
ac_ptr68k = (DLword*)Addr68k_from_StkOffset(CURRENTFX->nextblock); \
ac_ptr68k = (DLword*)NativeAligned2FromStackOffset(CURRENTFX->nextblock); \
if(GETWORD(ac_ptr68k) != STK_FSB_WORD) error("pre_moveframe: MP9316"); \
CHECK_FX(CURRENTFX); \
ac_freeptr=ac_ptr68k; \

18
inc/stack.h
View File

@@ -9,7 +9,7 @@
/* */
/************************************************************************/
#include "version.h" /* for BIGVM, UNSIGNED */
#include "adr68k.h" /* for LADDR_from_68k */
#include "adr68k.h" /* for LAddrFromNative, NativeAligned4FromLAddr */
#include "address.h" /* for LOLOC */
#include "commondefs.h" /* for error */
#include "lispemul.h" /* for LispPTR, DLword, FRAMESIZE, DLWORDSPER_CELL */
@@ -297,7 +297,7 @@ typedef struct stackp {
#define STKWORD(stkptr) ((StackWord *)WORDPTR(stkptr))
#define FX_INVALIDP(fx68k) (((fx68k) == 0) || ((DLword *)(fx68k) == Stackspace))
#define FX_size(fx68k) (((FX *)(fx68k))->nextblock - LOLOC(LADDR_from_68k(fx68k)))
#define FX_size(fx68k) (((FX *)(fx68k))->nextblock - LOLOC(LAddrFromNative(fx68k)))
#define FSBP(ptr68k) (((STKBLK *)(ptr68k))->flagword == STK_FSB_WORD)
#define FSB_size(ptr68k) (((STKBLK *)(ptr68k))->size)
/** Following suff assumes fx is 68kptr and val is LISP_LO_OFFSET **/
@@ -307,7 +307,7 @@ typedef struct stackp {
#define SET_FASTP_NIL(fx68k) \
{ \
if (FASTP(fx68k)) { \
((FX *)(fx68k))->blink = StkOffset_from_68K(DUMMYBF(fx68k)); \
((FX *)(fx68k))->blink = StackOffsetFromNative(DUMMYBF(fx68k)); \
((FX *)(fx68k))->clink = ((FX *)(fx68k))->alink; \
SLOWP(fx68k) = T; \
} \
@@ -317,13 +317,13 @@ typedef struct stackp {
#define SETALINK(fx, val) \
{ \
if (FASTP(fx)) { \
((FX *)(fx))->blink = LADDR_from_68k(DUMMYBF(fx)); \
((FX *)(fx))->blink = LAddrFromNative(DUMMYBF(fx)); \
((FX *)(fx))->clink = ((FX *)(fx))->alink; \
} \
((FX *)(fx))->alink = (val) + FRAMESIZE + 1; \
}
#define GETBLINK(fx) (SLOWP(fx) ? ((FX *)(fx))->blink : LOLOC(LADDR_from_68k(DUMMYBF(fx))))
#define GETBLINK(fx) (SLOWP(fx) ? ((FX *)(fx))->blink : LOLOC(LAddrFromNative(DUMMYBF(fx))))
#define SETBLINK(fx, val) \
{ \
((FX *)(fx))->blink = (val); \
@@ -339,14 +339,14 @@ typedef struct stackp {
{ \
((FX *)(fx))->clink = (val) + FRAMESIZE; \
if (FASTP((fx))) { \
((FX *)(fx))->blink = LADDR_from_68k(DUMMYBF(fx)); \
((FX *)(fx))->blink = LAddrFromNative(DUMMYBF(fx)); \
SLOWP(fx) = 1; \
} \
}
#define SETACLINK(fx, val) \
{ \
if (FASTP(fx)) { ((FX *)(fx))->blink = LADDR_from_68k(DUMMYBF(fx)); } \
if (FASTP(fx)) { ((FX *)(fx))->blink = LAddrFromNative(DUMMYBF(fx)); } \
((FX *)(fx))->clink = (val) + FRAMESIZE; \
((FX *)(fx))->alink = ((FX *)(fx))->clink + 1; \
}
@@ -358,7 +358,7 @@ typedef struct stackp {
#endif /* BIGVM */
#define GETNAMETABLE(fx) \
((struct fnhead *)Addr68k_from_LADDR( \
((struct fnhead *)NativeAligned4FromLAddr( \
SWAP_FNHEAD( \
((((FX2 *)(fx))->validnametable) ? ((FX2 *)(fx))->nametable : ((FX2 *)(fx))->fnheader)) & \
POINTERMASK))
@@ -411,7 +411,7 @@ typedef struct stackp {
if (check_stack_rooms(fx68k) > 1000) { \
warn("moveframe:there is more than 100 words SPACE for FX"); \
printf("# When calling "); \
tos_on_stack = (LispPTR *)Addr68k_from_StkOffset((fx68k)->nextblock - 2); \
tos_on_stack = (LispPTR *)NativeAligned4FromStackOffset((fx68k)->nextblock - 2); \
print_atomname(*tos_on_stack); \
printf("\n"); \
stack_check(0); \

44
inc/tosfns.h
View File

@@ -198,13 +198,12 @@
fn_apply = 0; \
goto op_fn_common; \
} \
LOCFNCELL = (struct fnhead *)Addr68k_from_LADDR((defcell_word &= POINTERMASK)); \
LOCFNCELL = (struct fnhead *)NativeAligned4FromLAddr((defcell_word &= POINTERMASK)); \
BCE_CURRENTFX->pc = ((UNSIGNED)PCMAC - (UNSIGNED)FuncObj) + FN_OPCODE_SIZE; \
FN_STACK_CHECK; \
{ \
UNSIGNED newivar; \
newivar = (UNSIGNED)(IVARL = (DLword *)(CSTKPTR - (argcount) + 1)); \
BCE_CURRENTFX->nextblock = NEXTBLOCK = StkOffset_from_68K(newivar); \
IVARL = (DLword *)(CSTKPTR - (argcount) + 1); \
BCE_CURRENTFX->nextblock = NEXTBLOCK = StackOffsetFromNative(IVARL); \
} \
HARD_PUSH(TOPOFSTACK); /* save TOS */ \
if (LOCFNCELL->na >= 0) { \
@@ -218,7 +217,7 @@
} /* if end */ \
/* Set up BF */ \
HARD_PUSH(BF_MARK32 | NEXTBLOCK); \
*((LispPTR *)CSTKPTR) = (FX_MARK << 16) | (StkOffset_from_68K(PVAR)); \
*((LispPTR *)CSTKPTR) = (FX_MARK << 16) | (StackOffsetFromNative(PVAR)); \
((struct frameex2 *)CSTKPTR)->fnheader = SWAP_FNHEAD(defcell_word); \
CSTKPTRL = (LispPTR *)(((DLword *)CSTKPTR) + FRAMESIZE); \
PVARL = (DLword *)CSTKPTR; \
@@ -254,13 +253,12 @@
fn_apply = 0; \
goto op_fn_common; \
} \
LOCFNCELL = (struct fnhead *)Addr68k_from_LADDR(defcell->defpointer); \
LOCFNCELL = (struct fnhead *)NativeAligned4FromLAddr(defcell->defpointer); \
BCE_CURRENTFX->pc = ((UNSIGNED)PCMAC - (UNSIGNED)FuncObj) + FNX_OPCODE_SIZE; \
FN_STACK_CHECK; \
{ \
UNSIGNED newivar; \
newivar = (UNSIGNED)(IVARL = (DLword *)(CSTKPTR - num_args + 1)); \
BCE_CURRENTFX->nextblock = NEXTBLOCK = StkOffset_from_68K(newivar); \
IVARL = (DLword *)(CSTKPTR - num_args + 1); \
BCE_CURRENTFX->nextblock = NEXTBLOCK = StackOffsetFromNative(IVARL); \
} \
HARD_PUSH(TOPOFSTACK); /* save TOS */ \
if (LOCFNCELL->na >= 0) { \
@@ -274,7 +272,7 @@
} /* if end */ \
/* Set up BF */ \
HARD_PUSH(BF_MARK32 | NEXTBLOCK); \
*((LispPTR *)CSTKPTR) = (FX_MARK << 16) | (StkOffset_from_68K(PVAR)); \
*((LispPTR *)CSTKPTR) = (FX_MARK << 16) | (StackOffsetFromNative(PVAR)); \
((struct frameex2 *)CSTKPTR)->fnheader = SWAP_FNHEAD(defcell->defpointer); \
CSTKPTRL = (LispPTR *)(((DLword *)CSTKPTR) + FRAMESIZE); \
PVARL = (DLword *)CSTKPTR; \
@@ -355,7 +353,7 @@
defcell = fn_defcell; \
if (defcell->ccodep == 0) { \
if (GetTypeNumber(defcell->defpointer) == TYPE_COMPILED_CLOSURE) { /* setup closure */ \
closure = (CClosure *)Addr68k_from_LADDR(defcell->defpointer); \
closure = (CClosure *)NativeAligned4FromLAddr(defcell->defpointer); \
defcell = (DefCell *)closure; \
/* not a closure if closure's env is NIL */ \
if (closure->env_ptr) { closure_env = (LispPTR)(closure->env_ptr); } \
@@ -366,15 +364,14 @@
needpush = 1; \
} /*else end */ \
} \
LOCFNCELL = (struct fnhead *)Addr68k_from_LADDR(defcell->defpointer); \
LOCFNCELL = (struct fnhead *)NativeAligned4FromLAddr(defcell->defpointer); \
BCE_CURRENTFX->pc = ((UNSIGNED)PCMAC - (UNSIGNED)FuncObj) + fn_opcode_size; \
FNTPRINT(("Saving PC = 0%o (%p).\n", BCE_CURRENTFX->pc, (void *)PCMAC + fn_opcode_size)); \
FN_STACK_CHECK; \
APPLY_POP_PUSH_TEST; \
{ \
UNSIGNED newivar; \
newivar = (UNSIGNED)(IVARL = (DLword *)(CSTKPTR + (1 - fn_num_args - needpush))); \
BCE_CURRENTFX->nextblock = NEXTBLOCK = StkOffset_from_68K(newivar); \
IVARL = (DLword *)(CSTKPTR + (1 - fn_num_args - needpush)); \
BCE_CURRENTFX->nextblock = NEXTBLOCK = StackOffsetFromNative(IVARL); \
} \
HARD_PUSH(TOPOFSTACK); /* save TOS */ \
if (LOCFNCELL->na >= 0) { \
@@ -389,7 +386,7 @@
/* Set up BF */ \
HARD_PUSH(BF_MARK32 | NEXTBLOCK); \
} /* NEXTBLOCK BLOCK */ \
*((LispPTR *)CSTKPTR) = (FX_MARK << 16) | (StkOffset_from_68K(PVAR)); \
*((LispPTR *)CSTKPTR) = (FX_MARK << 16) | (StackOffsetFromNative(PVAR)); \
((struct frameex2 *)CSTKPTR)->fnheader = SWAP_FNHEAD(defcell->defpointer); \
CSTKPTRL = (LispPTR *)(((DLword *)CSTKPTR) + FRAMESIZE); \
PVARL = (DLword *)CSTKPTR; \
@@ -433,7 +430,7 @@
LispPTR closure_env = TOPOFSTACK; \
int num_args; \
LispPTR Fn_DefCell = GET_TOS_1; \
LOCFNCELL = (struct fnhead *)Addr68k_from_LADDR(Fn_DefCell); \
LOCFNCELL = (struct fnhead *)NativeAligned4FromLAddr(Fn_DefCell); \
FNTPRINT(("ENVCall.\n")); \
FNCHECKER(if (quick_stack_check()) printf("In ENVCALL.\n")); \
N_GETNUMBER(GET_TOS_2, num_args, op_ufn); \
@@ -441,9 +438,8 @@
FN_STACK_CHECK; \
CSTKPTRL -= 2; \
{ \
UNSIGNED newivar; \
newivar = (UNSIGNED)(IVARL = (DLword *)(CSTKPTR - num_args)); \
BCE_CURRENTFX->nextblock = NEXTBLOCK = StkOffset_from_68K(newivar); \
IVARL = (DLword *)(CSTKPTR - num_args); \
BCE_CURRENTFX->nextblock = NEXTBLOCK = StackOffsetFromNative(IVARL);\
} \
if (LOCFNCELL->na >= 0) { \
int RESTARGS; \
@@ -456,7 +452,7 @@
} /* if end */ \
/* Set up BF */ \
HARD_PUSH(BF_MARK32 | NEXTBLOCK); \
*((LispPTR *)CSTKPTR) = (FX_MARK << 16) | (StkOffset_from_68K(PVAR)); \
*((LispPTR *)CSTKPTR) = (FX_MARK << 16) | (StackOffsetFromNative(PVAR)); \
((struct frameex2 *)CSTKPTR)->fnheader = SWAP_FNHEAD(Fn_DefCell); \
CSTKPTRL = (LispPTR *)(((DLword *)CSTKPTR) + FRAMESIZE); \
PVARL = (DLword *)CSTKPTR; \
@@ -524,7 +520,7 @@
goto Hack_Label; \
nnewframe(CURRENTFX, scratch, TOPOFSTACK & 0xffff); \
work = POINTERMASK & ((GETBASEWORD(scratch,1) << 16) | GETBASEWORD(scratch,0)); \
lookuped = *((LispPTR *)(Addr68k_from_LADDR(work))); \
lookuped = *((LispPTR *)(NativeAligned4FromLAddr(work))); \
if (lookuped == NOBIND_PTR) \
goto op_ufn; \
TOPOFSTACK = lookuped; \
@@ -564,7 +560,7 @@
goto Hack_Label; \
nnewframe(CURRENTFX, scratch, TOPOFSTACK & 0xffff); \
work = POINTERMASK & ((GETBASEWORD(scratch,1) << 16) | GETBASEWORD(scratch,0)); \
lookuped = *((LispPTR *)(Addr68k_from_LADDR(work))); \
lookuped = *((LispPTR *)(NativeAligned4FromLAddr(work))); \
if (lookuped == NOBIND_PTR) \
goto op_ufn; \
TOPOFSTACK = lookuped; \
@@ -588,7 +584,7 @@
case TYPE_NEWATOM: \
nnewframe(CURRENTFX, scratch, TOPOFSTACK); \
work = POINTERMASK & ((GETBASEWORD(scratch,1) << 16) | GETBASEWORD(scratch,0)); \
lookuped = *((LispPTR *)(Addr68k_from_LADDR(work))); \
lookuped = *((LispPTR *)(NativeAligned4FromLAddr(work))); \
if (lookuped == NOBIND_PTR) \
goto op_ufn; \
TOPOFSTACK = lookuped; \

6
inc/tosret.h
View File

@@ -39,14 +39,14 @@
CSTKPTRL = (LispPTR *) IVAR; \
returnFX = (struct frameex2 *) \
((DLword *) \
(PVARL = (DLword *) Addr68k_from_StkOffset(alink)) \
(PVARL = (DLword *) NativeAligned2FromStackOffset(alink)) \
- FRAMESIZE); \
IVARL = (DLword *) \
Addr68k_from_StkOffset(GETWORD((DLword *)returnFX -1)); \
NativeAligned2FromStackOffset(GETWORD((DLword *)returnFX -1));\
/* Get PC from Returnee's pc slot in FX */ \
PCMACL = returnFX->pc + (ByteCode *) \
(FuncObj = (struct fnhead *) \
Addr68k_from_LADDR(SWAP_FNHEAD(returnFX->fnheader) & POINTERMASK)) + 1;\
NativeAligned4FromLAddr(SWAP_FNHEAD(returnFX->fnheader) & POINTERMASK)) + 1;\
Irq_Stk_Check = STK_END_COMPUTE(EndSTKP,FuncObj); \
FNCHECKER(if (quick_stack_check()) printf("In RETURN.\n")); \
if (((UNSIGNED)(CSTKPTR) >= Irq_Stk_Check) || (Irq_Stk_End <= 0)) \

20
src/allocmds.c
View File

@@ -26,7 +26,7 @@
/**********************************************************************/
#include "address.h" // for LOLOC
#include "adr68k.h" // for LADDR_from_68k, LPAGE_from_68k, Addr68k_fr...
#include "adr68k.h" // for LAddrFromNative, LPageFromNative, Addr68k_fr...
#include "allocmdsdefs.h" // for alloc_mdspage, initmdspage
#include "commondefs.h" // for error
#include "lispemul.h" // for DLword, LispPTR, DLWORDSPER_PAGE, MDSINCRE...
@@ -94,7 +94,7 @@ LispPTR initmdspage(LispPTR *base, DLword size, LispPTR prev)
used = 0;
while ((used += size) <= limit) {
*base = prev; /* write prev MDS address to the top of MDS page */
prev = LADDR_from_68k(base); /* exchanging pointers */
prev = LAddrFromNative(base); /* exchanging pointers */
base = (LispPTR *)((DLword *)base + size);
} /* while end */
@@ -131,10 +131,10 @@ LispPTR *alloc_mdspage(short int type) {
LispPTR *ptr; /* points Top 32 bit of the MDS page */
LispPTR next_page;
/* Next_Array=(DLword *)Addr68k_from_LADDR(((*Next_Array_word)& 0xffff ) << 8); */
/* Next_Array=(DLword *)NativeAligned2FromLAddr(((*Next_Array_word)& 0xffff ) << 8); */
if (LOLOC(*MDS_free_page_word) != NIL) {
ptr = (LispPTR *)Addr68k_from_LPAGE(LOLOC(*MDS_free_page_word));
ptr = (LispPTR *)NativeAligned4FromLPage(LOLOC(*MDS_free_page_word));
if (((next_page = LOLOC(*ptr)) != 0) && (GetTypeNumber((*ptr)) != TYPE_SMALLP))
error("alloc_mdspage: Bad Free Page Link");
@@ -145,20 +145,20 @@ LispPTR *alloc_mdspage(short int type) {
/* I guess Next_MDSpage is redundant */
checkfor_storagefull(NIL);
#ifdef BIGVM
Next_MDSpage = (DLword *)Addr68k_from_LADDR(((*Next_MDSpage_word)) << 8);
Next_MDSpage = (DLword *)NativeAligned2FromLAddr(((*Next_MDSpage_word)) << 8);
#else
Next_MDSpage = (DLword *)Addr68k_from_LADDR(((*Next_MDSpage_word) & 0xffff) << 8);
Next_MDSpage = (DLword *)NativeAligned2FromLAddr(((*Next_MDSpage_word) & 0xffff) << 8);
#endif
ptr = (LispPTR *)Next_MDSpage; /* Get Pointer to First Page */
Next_MDSpage -= DLWORDSPER_PAGE * 2; /* decrement MDS count */
#ifdef BIGVM
*Next_MDSpage_word = LPAGE_from_68k(Next_MDSpage);
*Next_MDSpage_word = LPageFromNative(Next_MDSpage);
#else
*Next_MDSpage_word = S_POSITIVE | LPAGE_from_68k(Next_MDSpage);
*Next_MDSpage_word = S_POSITIVE | LPageFromNative(Next_MDSpage);
#endif
newpage(newpage(LADDR_from_68k(ptr)) + DLWORDSPER_PAGE);
newpage(newpage(LAddrFromNative(ptr)) + DLWORDSPER_PAGE);
}
Make_MDSentry(LPAGE_from_68k(ptr), type);
Make_MDSentry(LPageFromNative(ptr), type);
return (ptr);
} /* alloc_mdspage end */

6
src/arithops.c
View File

@@ -7,7 +7,7 @@
#include "version.h"
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned4FromLAddr
#include "arith.h" // for N_IGETNUMBER, N_ARITH_SWITCH, N_GETNUMBER
#include "arithopsdefs.h" // for N_OP_difference, N_OP_greaterp, N_OP_idiffer...
#include "fpdefs.h" // for N_OP_fdifference, N_OP_fgreaterp, N_OP_fplus2
@@ -331,7 +331,7 @@ LispPTR N_OP_boxiplus(LispPTR a, LispPTR tos) {
if (GetTypeNumber(a) == TYPE_FIXP) {
N_GETNUMBER(tos, arg2, bad);
*((int *)Addr68k_from_LADDR(a)) += arg2;
*((int *)NativeAligned4FromLAddr(a)) += arg2;
return (a);
}
bad:
@@ -354,7 +354,7 @@ LispPTR N_OP_boxidiff(LispPTR a, LispPTR tos) {
if (GetTypeNumber(a) == TYPE_FIXP) {
N_GETNUMBER(tos, arg2, bad);
*((int *)Addr68k_from_LADDR(a)) -= arg2;
*((int *)NativeAligned4FromLAddr(a)) -= arg2;
return (a);
}
bad:

10
src/arrayops.c
View File

@@ -6,7 +6,7 @@
/************************************************************************/
#include "version.h"
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned4FromLAddr
#include "arrayopsdefs.h" // for N_OP_misc3, N_OP_misc4, N_OP_aref1, N_OP_aset1, N_OP_aref2, N_OP_aset2
#include "emlglob.h"
#include "lispemul.h" // for state, LispPTR, ERROR_EXIT
@@ -86,7 +86,7 @@ LispPTR N_OP_aref1(LispPTR arrayarg, LispPTR inx) {
/* verify array */
if (GetTypeNumber(arrayarg) != TYPE_ONED_ARRAY) ERROR_EXIT(inx);
arrayblk = (OneDArray *)Addr68k_from_LADDR(arrayarg);
arrayblk = (OneDArray *)NativeAligned4FromLAddr(arrayarg);
/* test and setup index */
N_GetPos(inx, index, inx);
@@ -118,7 +118,7 @@ LispPTR N_OP_aset1(LispPTR data, LispPTR arrayarg, int inx) {
/* verify array */
if (GetTypeNumber(arrayarg) != TYPE_ONED_ARRAY) ERROR_EXIT(inx);
arrayblk = (OneDArray *)Addr68k_from_LADDR(arrayarg);
arrayblk = (OneDArray *)NativeAligned4FromLAddr(arrayarg);
/* test and setup index */
N_GetPos(inx, index, inx);
@@ -152,7 +152,7 @@ LispPTR N_OP_aref2(LispPTR arrayarg, LispPTR inx0, LispPTR inx1) {
/* verify array */
if (GetTypeNumber(arrayarg) != TYPE_TWOD_ARRAY) ERROR_EXIT(inx1);
arrayblk = (LispArray *)Addr68k_from_LADDR(arrayarg);
arrayblk = (LispArray *)NativeAligned4FromLAddr(arrayarg);
baseL = arrayblk->base;
/* test and setup index */
@@ -178,7 +178,7 @@ LispPTR N_OP_aset2(LispPTR data, LispPTR arrayarg, LispPTR inx0, LispPTR inx1) {
/* verify array */
if (GetTypeNumber(arrayarg) != TYPE_TWOD_ARRAY) ERROR_EXIT(inx1);
arrayblk = (LispArray *)Addr68k_from_LADDR(arrayarg);
arrayblk = (LispArray *)NativeAligned4FromLAddr(arrayarg);
base = arrayblk->base;
/* test and setup index */

102
src/bbtsub.c
View File

@@ -343,11 +343,11 @@ void bitbltsub(LispPTR *argv) {
init_kbd_startup;
#endif
pbt = (PILOTBBT *)Addr68k_from_LADDR(args[0]);
srcebm = (BITMAP *)Addr68k_from_LADDR(args[1]);
pbt = (PILOTBBT *)NativeAligned4FromLAddr(args[0]);
srcebm = (BITMAP *)NativeAligned4FromLAddr(args[1]);
sx = (args[2] & 0xFFFF);
sty = (args[3] & 0xFFFF);
destbm = (BITMAP *)Addr68k_from_LADDR(args[4]);
destbm = (BITMAP *)NativeAligned4FromLAddr(args[4]);
dx = (args[5] & 0xFFFF);
dty = (args[6] & 0xFFFF);
sourcetype = (args[8] == NIL_PTR ? INPUT_atom : args[8]);
@@ -366,7 +366,7 @@ void bitbltsub(LispPTR *argv) {
wxoffset = (args[11] == NIL_PTR ? 0 : args[11] & 0xFFFF);
wyoffset = (args[12] == NIL_PTR ? 0 : args[12] & 0xFFFF);
sx = ((wxoffset) ? (dx - wxoffset) : dx) % BITSPERWORD;
dstbase = (DLword *)Addr68k_from_LADDR(ADDBASE(destbm->bmbase, destbm->bmrasterwidth * dty));
dstbase = (DLword *)NativeAligned2FromLAddr(ADDBASE(destbm->bmbase, destbm->bmrasterwidth * dty));
gray = 1;
if (texture == NIL_PTR) { /* White Shade */
grayword[0] = 0;
@@ -399,8 +399,8 @@ void bitbltsub(LispPTR *argv) {
goto do_it_now;
}
} else { /* A bitmap that is 16 bits wide. */
texture68k = (BITMAP *)Addr68k_from_LADDR(texture);
srcbase = (DLword *)Addr68k_from_LADDR(texture68k->bmbase);
texture68k = (BITMAP *)NativeAligned4FromLAddr(texture);
srcbase = (DLword *)NativeAligned2FromLAddr(texture68k->bmbase);
num_gray = min(texture68k->bmheight, 16);
curr_gray_line = (dty + wyoffset) % num_gray;
srcbase += curr_gray_line;
@@ -429,15 +429,15 @@ void bitbltsub(LispPTR *argv) {
backwardflg = T;
if (backwardflg) {
srcbase = (DLword *)Addr68k_from_LADDR(
srcbase = (DLword *)NativeAligned2FromLAddr(
ADDBASE(srcebm->bmbase, srcebm->bmrasterwidth * (sty + h - 1)));
dstbase = (DLword *)Addr68k_from_LADDR(
dstbase = (DLword *)NativeAligned2FromLAddr(
ADDBASE(destbm->bmbase, destbm->bmrasterwidth * (dty + h - 1)));
srcbpl = 0 - srcbpl;
dstbpl = 0 - dstbpl;
} else {
srcbase = (DLword *)Addr68k_from_LADDR(ADDBASE(srcebm->bmbase, srcebm->bmrasterwidth * sty));
dstbase = (DLword *)Addr68k_from_LADDR(ADDBASE(destbm->bmbase, destbm->bmrasterwidth * dty));
srcbase = (DLword *)NativeAligned2FromLAddr(ADDBASE(srcebm->bmbase, srcebm->bmrasterwidth * sty));
dstbase = (DLword *)NativeAligned2FromLAddr(ADDBASE(destbm->bmbase, destbm->bmrasterwidth * dty));
}
#ifdef REALCURSOR
displayflg = n_new_cursorin(srcbase, sx, sty, w, h);
@@ -641,8 +641,8 @@ LispPTR bitblt_bitmap(LispPTR *args) {
#endif
/* Get arguments and check the possibilities of PUNT */
SourceBitmap = (BITMAP *)Addr68k_from_LADDR(args[0]);
DestBitmap = (BITMAP *)Addr68k_from_LADDR(args[3]);
SourceBitmap = (BITMAP *)NativeAligned4FromLAddr(args[0]);
DestBitmap = (BITMAP *)NativeAligned4FromLAddr(args[3]);
/* It does not handle COLOR ..... maybe later */
destbits = DestBitmap->bmbitperpixel;
sourcebits = SourceBitmap->bmbitperpixel;
@@ -774,17 +774,17 @@ LispPTR bitblt_bitmap(LispPTR *args) {
backwardflg = T;
if (backwardflg) {
srcbase = (DLword *)Addr68k_from_LADDR(
srcbase = (DLword *)NativeAligned2FromLAddr(
ADDBASE(SourceBitmap->bmbase, SourceBitmap->bmrasterwidth * (sty + height - 1)));
dstbase = (DLword *)Addr68k_from_LADDR(
dstbase = (DLword *)NativeAligned2FromLAddr(
ADDBASE(DestBitmap->bmbase, DestBitmap->bmrasterwidth * (dty + height - 1)));
srcbpl = 0 - srcbpl;
dstbpl = 0 - dstbpl;
} else {
srcbase = (DLword *)Addr68k_from_LADDR(
srcbase = (DLword *)NativeAligned2FromLAddr(
ADDBASE(SourceBitmap->bmbase, SourceBitmap->bmrasterwidth * sty));
dstbase =
(DLword *)Addr68k_from_LADDR(ADDBASE(DestBitmap->bmbase, DestBitmap->bmrasterwidth * dty));
(DLword *)NativeAligned2FromLAddr(ADDBASE(DestBitmap->bmbase, DestBitmap->bmrasterwidth * dty));
}
displayflg = n_new_cursorin(srcbase, slx, sty, width, height);
@@ -923,7 +923,7 @@ LispPTR bitshade_bitmap(LispPTR *args) {
}
}
DestBitmap = (BITMAP *)Addr68k_from_LADDR(args[1]);
DestBitmap = (BITMAP *)NativeAligned4FromLAddr(args[1]);
if ((destbits = DestBitmap->bmbitperpixel) != 1) { PUNT_TO_BLTSHADEBITMAP; }
N_GETNUMBER(args[2], dleft, bad_arg);
@@ -990,7 +990,7 @@ LispPTR bitshade_bitmap(LispPTR *args) {
slx = left % BITSPERWORD;
dstbase = (DLword *)Addr68k_from_LADDR(ADDBASE(DestBitmap->bmbase, (rasterwidth * dty)));
dstbase = (DLword *)NativeAligned2FromLAddr(ADDBASE(DestBitmap->bmbase, (rasterwidth * dty)));
if (GetTypeNumber(texture) == TYPE_LITATOM) {
if (texture == NIL_PTR) { /* White Shade */
@@ -1029,8 +1029,8 @@ LispPTR bitshade_bitmap(LispPTR *args) {
} else /**** Need to handle texture = listp case, too ***/
/* Listp case alway punt to LISP */
{ /* A bitmap that is 16 bits wide. */
texture68k = (BITMAP *)Addr68k_from_LADDR(texture);
srcbase = (DLword *)Addr68k_from_LADDR(texture68k->bmbase);
texture68k = (BITMAP *)NativeAligned4FromLAddr(texture);
srcbase = (DLword *)NativeAligned2FromLAddr(texture68k->bmbase);
num_gray = min(texture68k->bmheight, 16);
curr_gray_line = (dty) % num_gray;
srcbase += curr_gray_line;
@@ -1157,12 +1157,12 @@ void bltchar(LispPTR *args)
int num_gray = 0, curr_gray_line = 0;
#endif
pbt = (PILOTBBT *)Addr68k_from_LADDR(((BLTC *)args)->pilotbbt);
dspdata = (DISPLAYDATA *)Addr68k_from_LADDR(((BLTC *)args)->displaydata);
pbt = (PILOTBBT *)NativeAligned4FromLAddr(((BLTC *)args)->pilotbbt);
dspdata = (DISPLAYDATA *)NativeAligned4FromLAddr(((BLTC *)args)->displaydata);
srcbase = (DLword *)Addr68k_from_LADDR(VAG2(pbt->pbtsourcehi, pbt->pbtsourcelo));
srcbase = (DLword *)NativeAligned2FromLAddr(VAG2(pbt->pbtsourcehi, pbt->pbtsourcelo));
dstbase = (DLword *)Addr68k_from_LADDR(VAG2(pbt->pbtdesthi, pbt->pbtdestlo));
dstbase = (DLword *)NativeAligned2FromLAddr(VAG2(pbt->pbtdesthi, pbt->pbtdestlo));
srcbpl = abs(pbt->pbtsourcebpl);
dstbpl = abs(pbt->pbtdestbpl);
@@ -1170,7 +1170,7 @@ void bltchar(LispPTR *args)
w = ((BLTC *)args)->right - ((BLTC *)args)->left;
if ((h <= 0) || (w <= 0)) return;
base = GETWORD(Addr68k_from_LADDR(dspdata->ddoffsetscache + ((BLTC *)args)->char8code));
base = GETWORD(NativeAligned2FromLAddr(dspdata->ddoffsetscache + ((BLTC *)args)->char8code));
sx = base + ((BLTC *)args)->left - ((BLTC *)args)->curx;
dx = ((BLTC *)args)->left;
@@ -1332,7 +1332,7 @@ void newbltchar(LispPTR *args) {
int num_gray = 0, curr_gray_line = 0;
#endif
displaydata68k = (DISPLAYDATA *)Addr68k_from_LADDR(((BLTARG *)args)->displaydata);
displaydata68k = (DISPLAYDATA *)NativeAligned4FromLAddr(((BLTARG *)args)->displaydata);
if ((displaydata68k->ddcharset & 0xFFFF) != ((BLTARG *)args)->charset) {
/*if(changecharset_display(displaydata68k, ((BLTARG *)args)->charset) ==-1)*/
@@ -1348,7 +1348,7 @@ void newbltchar(LispPTR *args) {
right =
curx +
GETWORD((DLword *)Addr68k_from_LADDR(displaydata68k->ddcharimagewidths + ((BLTARG *)args)->char8code));
GETWORD((DLword *)NativeAligned2FromLAddr(displaydata68k->ddcharimagewidths + ((BLTARG *)args)->char8code));
if ((right > rmargin) && (curx > lmargin)) PUNT_TO_BLTCHAR;
if (((BLTARG *)args)->displaystream != *TOPWDS68k) PUNT_TO_BLTCHAR;
@@ -1356,7 +1356,7 @@ void newbltchar(LispPTR *args) {
{
int newpos;
newpos = curx +
GETWORD((DLword *)Addr68k_from_LADDR(displaydata68k->ddwidthscache + ((BLTARG *)args)->char8code));
GETWORD((DLword *)NativeAligned2FromLAddr(displaydata68k->ddwidthscache + ((BLTARG *)args)->char8code));
if ((0 <= newpos) && (newpos < 65536))
(displaydata68k->ddxposition) = (LispPTR)(S_POSITIVE | newpos);
@@ -1376,21 +1376,21 @@ void newbltchar(LispPTR *args) {
else
left = displaydata68k->ddclippingleft;
pbt = (PILOTBBT *)Addr68k_from_LADDR(displaydata68k->ddpilotbbt);
pbt = (PILOTBBT *)NativeAligned4FromLAddr(displaydata68k->ddpilotbbt);
h = pbt->pbtheight;
w = right - left;
if ((h <= 0) || (w <= 0)) return;
srcbase = (DLword *)Addr68k_from_LADDR(VAG2(pbt->pbtsourcehi, pbt->pbtsourcelo));
srcbase = (DLword *)NativeAligned2FromLAddr(VAG2(pbt->pbtsourcehi, pbt->pbtsourcelo));
dstbase = (DLword *)Addr68k_from_LADDR(VAG2(pbt->pbtdesthi, pbt->pbtdestlo));
dstbase = (DLword *)NativeAligned2FromLAddr(VAG2(pbt->pbtdesthi, pbt->pbtdestlo));
op = pbt->pbtoperation;
src_comp = pbt->pbtsourcetype;
srcbpl = abs(pbt->pbtsourcebpl);
dstbpl = abs(pbt->pbtdestbpl);
base = GETWORD(Addr68k_from_LADDR(displaydata68k->ddoffsetscache + ((BLTARG *)args)->char8code));
base = GETWORD(NativeAligned2FromLAddr(displaydata68k->ddoffsetscache + ((BLTARG *)args)->char8code));
sx = base + left - curx;
dx = left;
@@ -1574,14 +1574,14 @@ static LispPTR sfffixy(DISPLAYDATA *displaydata68k, CHARSETINFO *csinfo68k, PILO
displaydata68k->ddcharsetascent = csinfo68k->CHARSETASCENT;
chartop = y + displaydata68k->ddcharsetascent;
bm68k = (BITMAP *)Addr68k_from_LADDR(displaydata68k->dddestination);
bm68k = (BITMAP *)NativeAligned4FromLAddr(displaydata68k->dddestination);
base = bm68k->bmbase;
top = IMAX(IMIN(displaydata68k->ddclippingtop, chartop), 0);
base = base + (bm68k->bmrasterwidth * (bm68k->bmheight - top));
pbt68k->pbtdesthi = base >> 16;
pbt68k->pbtdestlo = base;
bm68k = (BITMAP *)Addr68k_from_LADDR(csinfo68k->CHARSETBITMAP);
bm68k = (BITMAP *)NativeAligned4FromLAddr(csinfo68k->CHARSETBITMAP);
base = bm68k->bmbase;
displaydata68k->ddcharheightdelta = IMIN(IMAX(chartop - top, 0), 65535); /* always positive */
base = base + bm68k->bmrasterwidth * displaydata68k->ddcharheightdelta;
@@ -1604,12 +1604,12 @@ static LispPTR changecharset_display(DISPLAYDATA *displaydata68k, DLword charset
BITMAP *bm68k;
LispPTR *base68k;
pbt68k = (PILOTBBT *)Addr68k_from_LADDR(displaydata68k->ddpilotbbt);
fontd68k = (FONTDESC *)Addr68k_from_LADDR(displaydata68k->ddfont);
base68k = (LispPTR *)Addr68k_from_LADDR(fontd68k->FONTCHARSETVECTOR);
pbt68k = (PILOTBBT *)NativeAligned4FromLAddr(displaydata68k->ddpilotbbt);
fontd68k = (FONTDESC *)NativeAligned4FromLAddr(displaydata68k->ddfont);
base68k = (LispPTR *)NativeAligned4FromLAddr(fontd68k->FONTCHARSETVECTOR);
if ((csinfo = *(base68k + charset)) == NIL) { return (-1); /* punt case */ }
csinfo68k = (CHARSETINFO *)Addr68k_from_LADDR(csinfo);
csinfo68k = (CHARSETINFO *)NativeAligned4FromLAddr(csinfo);
/* REF CNT */
FRPLPTR(displaydata68k->ddwidthscache, csinfo68k->WIDTHS);
@@ -1617,7 +1617,7 @@ static LispPTR changecharset_display(DISPLAYDATA *displaydata68k, DLword charset
FRPLPTR(displaydata68k->ddcharimagewidths, csinfo68k->IMAGEWIDTHS);
displaydata68k->ddcharset = charset;
bm68k = (BITMAP *)Addr68k_from_LADDR(csinfo68k->CHARSETBITMAP);
bm68k = (BITMAP *)NativeAligned4FromLAddr(csinfo68k->CHARSETBITMAP);
pbt68k->pbtsourcebpl = (bm68k->bmrasterwidth) << 4;
@@ -1650,10 +1650,10 @@ void ccfuncall(unsigned int atom_index, int argnum, int bytenum)
int rest; /* use for alignments */
/* Get Next Block offset from argnum */
CURRENTFX->nextblock = (LADDR_from_68k(CurrentStackPTR) & 0x0ffff) - (argnum << 1) + 4 /* +3 */;
CURRENTFX->nextblock = (LAddrFromNative(CurrentStackPTR) & 0x0ffff) - (argnum << 1) + 4 /* +3 */;
/* Setup IVar */
IVar = Addr68k_from_LADDR((((LispPTR)(CURRENTFX->nextblock)) | STK_OFFSET));
/* Setup IVar */ /* XXX: is it really only 2-byte aligned? */
IVar = NativeAligned2FromLAddr((((LispPTR)(CURRENTFX->nextblock)) | STK_OFFSET));
/* Set PC to the Next Instruction and save into FX */
CURRENTFX->pc = ((UNSIGNED)PC - (UNSIGNED)FuncObj) + bytenum;
@@ -1663,7 +1663,7 @@ void ccfuncall(unsigned int atom_index, int argnum, int bytenum)
/* Get DEFCELL 68k address */
defcell68k = (struct definition_cell *)GetDEFCELL68k(atom_index);
tmp_fn = (struct fnhead *)Addr68k_from_LADDR(defcell68k->defpointer);
tmp_fn = (struct fnhead *)NativeAligned4FromLAddr(defcell68k->defpointer);
if ((UNSIGNED)(CurrentStackPTR + tmp_fn->stkmin + STK_SAFE) >= (UNSIGNED)EndSTKP) {
LispPTR test;
@@ -1695,7 +1695,7 @@ void ccfuncall(unsigned int atom_index, int argnum, int bytenum)
GETWORD(CurrentStackPTR) = FX_MARK;
/* Now SET new FX */
((struct frameex1 *)CurrentStackPTR)->alink = LADDR_from_68k(PVar);
((struct frameex1 *)CurrentStackPTR)->alink = LAddrFromNative(PVar);
PVar = (DLword *)CurrentStackPTR + FRAMESIZE;
#ifdef BIGVM
((struct frameex1 *)CurrentStackPTR)->fnheader = (defcell68k->defpointer);
@@ -1752,22 +1752,22 @@ void tedit_bltchar(LispPTR *args)
int num_gray = 0, curr_gray_line = 0;
#endif
displaydata68k = (DISPLAYDATA *)Addr68k_from_LADDR(((TBLTARG *)args)->displaydata);
displaydata68k = (DISPLAYDATA *)NativeAligned4FromLAddr(((TBLTARG *)args)->displaydata);
if (displaydata68k->ddcharset != ((TBLTARG *)args)->charset) {
/**if(changecharset_display(displaydata68k, ((TBLTARG *)args)->charset)== -1)**/
{ PUNT_TO_TEDIT_BLTCHAR; }
}
imagewidth = *((DLword *)Addr68k_from_LADDR(displaydata68k->ddcharimagewidths + ((TBLTARG *)args)->char8code));
imagewidth = *((DLword *)NativeAligned2FromLAddr(displaydata68k->ddcharimagewidths + ((TBLTARG *)args)->char8code));
newx = ((TBLTARG *)args)->current_x + imagewidth;
dx = ((TBLTARG *)args)->current_x;
right = IMIN(newx, ((TBLTARG *)args)->clipright);
if (dx < right) {
pbt = (PILOTBBT *)Addr68k_from_LADDR(displaydata68k->ddpilotbbt);
pbt = (PILOTBBT *)NativeAligned4FromLAddr(displaydata68k->ddpilotbbt);
h = pbt->pbtheight;
srcbase = (DLword *)Addr68k_from_LADDR(VAG2(pbt->pbtsourcehi, pbt->pbtsourcelo));
srcbase = (DLword *)NativeAligned2FromLAddr(VAG2(pbt->pbtsourcehi, pbt->pbtsourcelo));
dstbase = (DLword *)Addr68k_from_LADDR(VAG2(pbt->pbtdesthi, pbt->pbtdestlo));
dstbase = (DLword *)NativeAligned2FromLAddr(VAG2(pbt->pbtdesthi, pbt->pbtdestlo));
srcbpl = abs(pbt->pbtsourcebpl);
dstbpl = abs(pbt->pbtdestbpl);
@@ -1775,7 +1775,7 @@ void tedit_bltchar(LispPTR *args)
src_comp = pbt->pbtsourcetype;
/*dx=left; I'll optimize later*/
sx = GETBASE(Addr68k_from_LADDR(displaydata68k->ddoffsetscache), ((TBLTARG *)args)->char8code);
sx = GETBASE(NativeAligned2FromLAddr(displaydata68k->ddoffsetscache), ((TBLTARG *)args)->char8code);
w = IMIN(imagewidth, (right - dx));
#ifdef NEWBITBLT
bitblt(srcbase, dstbase, sx, dx, w, h, srcbpl, dstbpl, backwardflg, src_comp, op, gray,
@@ -1841,7 +1841,7 @@ static int old_cursorin(DLword addrhi, DLword addrlo, int x, int w, int h, int y
return (NIL);
} /* MONO case end */
else {
base68k = (DLword *)Addr68k_from_LADDR(addrhi << 16 | addrlo);
base68k = (DLword *)NativeAligned2FromLAddr(addrhi << 16 | addrlo);
if ((ColorDisplayRegion68k <= base68k) && (base68k <= COLOR_MAX_Address)) {
y = (base68k - ColorDisplayRegion68k) / displaywidth;
} else

6
src/bin.c
View File

@@ -23,7 +23,7 @@
*/
/**********************************************************************/
#include "version.h"
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned2FromLAddr, NativeAligned4FromLAddr
#include "bindefs.h" // for N_OP_bin
#include "emlglob.h"
#include "lispmap.h" // for S_POSITIVE
@@ -36,14 +36,14 @@ LispPTR N_OP_bin(LispPTR tos) {
char *buff68k; /* pointer to BUFF */
if (GetTypeNumber(tos) == TYPE_STREAM) {
stream68k = (Stream *)Addr68k_from_LADDR(tos);
stream68k = (Stream *)NativeAligned4FromLAddr(tos);
if (!stream68k->BINABLE) ERROR_EXIT(tos);
if (stream68k->COFFSET >= stream68k->CBUFSIZE) ERROR_EXIT(tos);
/* get BUFFER instance */
buff68k = (char *)Addr68k_from_LADDR(stream68k->CBUFPTR);
buff68k = (char *)NativeAligned2FromLAddr(stream68k->CBUFPTR);
/* get BYTE data and set it to TOS */
return (S_POSITIVE | (Get_BYTE(buff68k + (stream68k->COFFSET)++)));

8
src/bitblt.c
View File

@@ -86,7 +86,7 @@ LispPTR N_OP_pilotbitblt(LispPTR pilot_bt_tbl, LispPTR tos)
#endif
pbt = (PILOTBBT *)Addr68k_from_LADDR(pilot_bt_tbl);
pbt = (PILOTBBT *)NativeAligned4FromLAddr(pilot_bt_tbl);
w = pbt->pbtwidth;
h = pbt->pbtheight;
@@ -106,8 +106,8 @@ LispPTR N_OP_pilotbitblt(LispPTR pilot_bt_tbl, LispPTR tos)
cursorin(pbt->pbtsourcehi, (pbt->pbtsourcelo + (sx >> 4)), w, h, backwardflg);
#endif /* SUNDISPLAY */
srcbase = (DLword *)Addr68k_from_LADDR(VAG2(pbt->pbtsourcehi, pbt->pbtsourcelo));
dstbase = (DLword *)Addr68k_from_LADDR(VAG2(pbt->pbtdesthi, pbt->pbtdestlo));
srcbase = (DLword *)NativeAligned2FromLAddr(VAG2(pbt->pbtsourcehi, pbt->pbtsourcelo));
dstbase = (DLword *)NativeAligned2FromLAddr(VAG2(pbt->pbtdesthi, pbt->pbtdestlo));
srcbpl = pbt->pbtsourcebpl;
dstbpl = pbt->pbtdestbpl;
@@ -200,7 +200,7 @@ int cursorin(DLword addrhi, DLword addrlo, int w, int h, int backward)
else
return (NIL);
} else {
base68k = (DLword *)Addr68k_from_LADDR(addrhi << 16 | addrlo);
base68k = (DLword *)NativeAligned2FromLAddr(addrhi << 16 | addrlo);
if ((ColorDisplayRegion68k <= base68k) && (base68k <= COLOR_MAX_Address)) {
y = (base68k - ColorDisplayRegion68k) / displaywidth;
x = (UNSIGNED)(base68k - ColorDisplayRegion68k) - (y * displaywidth);

4
src/blt.c
View File

@@ -50,8 +50,8 @@ LispPTR N_OP_blt(LispPTR destptr, LispPTR sourceptr, LispPTR wordcount) {
if ((wordcount & SEGMASK) != S_POSITIVE) ERROR_EXIT(wordcount);
nw = wordcount & 0xffff;
source68k = Addr68k_from_LADDR(sourceptr) + nw;
dest68k = Addr68k_from_LADDR(destptr) + nw;
source68k = NativeAligned2FromLAddr(sourceptr) + nw;
dest68k = NativeAligned2FromLAddr(destptr) + nw;
while (nw) {
(GETWORD(--dest68k)) = GETWORD(--source68k);

54
src/car-cdr.c
View File

@@ -31,7 +31,7 @@
/**********************************************************************/
#include "address.h" // for POINTER_PAGEBASE
#include "adr68k.h" // for Addr68k_from_LADDR, Addr68k_from_LPAGE
#include "adr68k.h" // for NativeAligned4FromLAddr, NativeAligned4FromLPage
#include "car-cdrdefs.h" // for N_OP_car, N_OP_cdr, N_OP_rplaca, N_OP_rplacd
#include "cell.h" // for freecons, conspage, FREECONS, CDR_INDIRECT
#include "commondefs.h" // for error
@@ -56,10 +56,10 @@ LispPTR car(LispPTR datum)
ConsCell *datum68k;
ConsCell *temp;
datum68k = (ConsCell *)(Addr68k_from_LADDR(datum));
datum68k = (ConsCell *)(NativeAligned4FromLAddr(datum));
if (Listp(datum)) {
if (datum68k->cdr_code == CDR_INDIRECT) {
temp = (ConsCell *)Addr68k_from_LADDR(datum68k->car_field);
temp = (ConsCell *)NativeAligned4FromLAddr(datum68k->car_field);
return ((LispPTR)temp->car_field);
} else
return ((LispPTR)datum68k->car_field);
@@ -98,7 +98,7 @@ LispPTR cdr(LispPTR datum)
if (datum == NIL_PTR) return (NIL_PTR);
if (!Listp(datum)) error("cdr : ARG not list");
datum68k = (ConsCell *)(Addr68k_from_LADDR(datum));
datum68k = (ConsCell *)(NativeAligned4FromLAddr(datum));
cdr_code = datum68k->cdr_code;
if (cdr_code == CDR_NIL) return (NIL_PTR); /* cdr is nil */
@@ -112,9 +112,9 @@ LispPTR cdr(LispPTR datum)
return (cdr((LispPTR)(datum68k->car_field)));
/* cdr isn't a CONS, but is stored on this page. */
#ifdef NEWCDRCODING
temp = (ConsCell *)(Addr68k_from_LADDR(datum + (cdr_code << 1)));
temp = (ConsCell *)(NativeAligned4FromLAddr(datum + (cdr_code << 1)));
#else
temp = (ConsCell *)(Addr68k_from_LADDR(POINTER_PAGEBASE(datum) + (cdr_code << 1)));
temp = (ConsCell *)(NativeAligned4FromLAddr(POINTER_PAGEBASE(datum) + (cdr_code << 1)));
#endif /* NEWCDRCODING */
return ((LispPTR)temp->car_field);
} /* end of cdr */
@@ -153,13 +153,13 @@ LispPTR rplaca(LispPTR x, LispPTR y)
}
else {
x_68k = (ConsCell *)Addr68k_from_LADDR(x);
x_68k = (ConsCell *)NativeAligned4FromLAddr(x);
GCLOOKUP(car(x), DELREF); /* set up reference count */
GCLOOKUP(y, ADDREF);
if (x_68k->cdr_code == CDR_INDIRECT) {
temp = (ConsCell *)Addr68k_from_LADDR((LispPTR)x_68k->car_field);
temp = (ConsCell *)NativeAligned4FromLAddr((LispPTR)x_68k->car_field);
temp->car_field = y;
} else
x_68k->car_field = y;
@@ -206,7 +206,7 @@ LispPTR rplacd(LispPTR x, LispPTR y)
}
else {
x_68k = (ConsCell *)Addr68k_from_LADDR(x);
x_68k = (ConsCell *)NativeAligned4FromLAddr(x);
GCLOOKUP(cdr(x), DELREF); /* set up reference count */
GCLOOKUP(y, ADDREF);
@@ -217,14 +217,14 @@ LispPTR rplacd(LispPTR x, LispPTR y)
/* cdr-indirect */
rp_page = (LispPTR)x_68k->car_field;
temp68k = (ConsCell *)Addr68k_from_LADDR(rp_page);
temp68k = (ConsCell *)NativeAligned4FromLAddr(rp_page);
#ifdef NEWCDRCODING
cdr_cell = (rp_page) + (temp68k->cdr_code << 1);
#else
cdr_cell = POINTER_PAGEBASE(rp_page) + (temp68k->cdr_code << 1);
#endif /* NEWCDRCODING */
cdr_cell68k = (ConsCell *)Addr68k_from_LADDR(cdr_cell);
cdr_cell68k = (ConsCell *)NativeAligned4FromLAddr(cdr_cell);
*(LispPTR *)cdr_cell68k = y & POINTERMASK; /* cdr_code is set to 0 */
} else if (cdr_code <= CDR_MAXINDIRECT) {
/* cdr-differentpage */
@@ -233,7 +233,7 @@ LispPTR rplacd(LispPTR x, LispPTR y)
#else
cdr_cell = POINTER_PAGEBASE(x) + (cdr_code << 1);
#endif /* NEWCDRCODING */
cdr_cell68k = (ConsCell *)Addr68k_from_LADDR(cdr_cell);
cdr_cell68k = (ConsCell *)NativeAligned4FromLAddr(cdr_cell);
*(LispPTR *)cdr_cell68k = y & POINTERMASK; /* cdr_code is set to 0 */
} else if (y == NIL_PTR)
@@ -251,7 +251,7 @@ LispPTR rplacd(LispPTR x, LispPTR y)
else {
/* cdr-samepage & x and y are on different page */
cons68k = (struct conspage *)(Addr68k_from_LADDR(rp_page));
cons68k = (struct conspage *)(NativeAligned4FromLAddr(rp_page));
#ifdef NEWCDRCODING
if ((cons68k->count > 0) && (cdr_cell68k = find_close_cell(cons68k, x))) {
/* at least one free-cell on x's conspage */
@@ -259,7 +259,7 @@ LispPTR rplacd(LispPTR x, LispPTR y)
*(LispPTR *)cdr_cell68k = y & POINTERMASK; /* cdr_code set to 0 */
x_68k->cdr_code = (LADDR_from_68k(cdr_cell68k) - x) >> 1;
x_68k->cdr_code = (LAddrFromNative(cdr_cell68k) - x) >> 1;
}
#else
if (cons68k->count > 0) {
@@ -270,7 +270,7 @@ LispPTR rplacd(LispPTR x, LispPTR y)
*(LispPTR *)cdr_cell68k = y & POINTERMASK; /* cdr_code set to 0 */
x_68k->cdr_code = (LADDR_from_68k(cdr_cell68k) - rp_page) >> 1;
x_68k->cdr_code = (LAddrFromNative(cdr_cell68k) - rp_page) >> 1;
}
#endif /* NEWCDRCODING */
else {
@@ -278,7 +278,7 @@ LispPTR rplacd(LispPTR x, LispPTR y)
#ifdef NEWCDRCODING
temp68k = (ConsCell *)find_cdrable_pair(x, y);
temp68k->car_field = x_68k->car_field;
x_68k->car_field = LADDR_from_68k(temp68k);
x_68k->car_field = LAddrFromNative(temp68k);
x_68k->cdr_code = CDR_INDIRECT;
#else
cons68k = next_conspage();
@@ -293,9 +293,9 @@ LispPTR rplacd(LispPTR x, LispPTR y)
*(LispPTR *)cdr_cell68k = y & POINTERMASK; /* cdr_code set to 0 */
temp68k->car_field = x_68k->car_field;
x_68k->car_field = LADDR_from_68k(temp68k);
x_68k->car_field = LAddrFromNative(temp68k);
temp68k->cdr_code = (LADDR_from_68k(cdr_cell68k) & 0xff) >> 1;
temp68k->cdr_code = (LAddrFromNative(cdr_cell68k) & 0xff) >> 1;
x_68k->cdr_code = CDR_INDIRECT;
#endif /* NEWCDRCODING */
@@ -322,10 +322,10 @@ LispPTR N_OP_car(LispPTR tos) {
ConsCell *datum68k;
ConsCell *temp;
datum68k = (ConsCell *)(Addr68k_from_LADDR(tos));
datum68k = (ConsCell *)(NativeAligned4FromLAddr(tos));
if (Listp(tos)) {
if (datum68k->cdr_code == CDR_INDIRECT) {
temp = (ConsCell *)Addr68k_from_LADDR(datum68k->car_field);
temp = (ConsCell *)NativeAligned4FromLAddr(datum68k->car_field);
return ((LispPTR)temp->car_field);
} else
return ((LispPTR)datum68k->car_field);
@@ -358,7 +358,7 @@ LispPTR N_OP_cdr(LispPTR tos) {
ERROR_EXIT(tos);
}
datum68k = (ConsCell *)(Addr68k_from_LADDR(tos));
datum68k = (ConsCell *)(NativeAligned4FromLAddr(tos));
cdr_code = datum68k->cdr_code;
if (cdr_code == CDR_NIL) return (NIL_PTR); /* cdr-nil */
@@ -372,9 +372,9 @@ LispPTR N_OP_cdr(LispPTR tos) {
return (cdr((LispPTR)(datum68k->car_field)));
/* cdr-differentpage */
#ifdef NEWCDRCODING
return ((LispPTR)((ConsCell *)(Addr68k_from_LADDR(tos + (cdr_code << 1))))->car_field);
return ((LispPTR)((ConsCell *)(NativeAligned4FromLAddr(tos + (cdr_code << 1))))->car_field);
#else
return ((LispPTR)((ConsCell *)(Addr68k_from_LADDR(POINTER_PAGEBASE(tos) + (cdr_code << 1))))->car_field);
return ((LispPTR)((ConsCell *)(NativeAligned4FromLAddr(POINTER_PAGEBASE(tos) + (cdr_code << 1))))->car_field);
#endif /*NEWCDRCODING */
} /* end of N_OP_cdr */
@@ -405,13 +405,13 @@ LispPTR N_OP_rplaca(LispPTR tosm1, LispPTR tos) {
}
else {
x_68k = (ConsCell *)Addr68k_from_LADDR(tosm1);
x_68k = (ConsCell *)NativeAligned4FromLAddr(tosm1);
GCLOOKUP(car(tosm1), DELREF); /* set up reference count */
GCLOOKUP(tos, ADDREF);
if (x_68k->cdr_code == CDR_INDIRECT) {
temp = (ConsCell *)Addr68k_from_LADDR((LispPTR)x_68k->car_field);
temp = (ConsCell *)NativeAligned4FromLAddr((LispPTR)x_68k->car_field);
temp->car_field = tos;
} else
x_68k->car_field = tos;
@@ -619,8 +619,8 @@ static ConsCell *find_cdrable_pair(LispPTR carpart, LispPTR cdrpart) {
struct conspage *pg;
ConsCell *cell;
for (pg = (struct conspage *)Addr68k_from_LPAGE(pgno = ListpDTD->dtd_nextpage); pgno;
pg = (struct conspage *)Addr68k_from_LPAGE(pgno = pg->next_page)) {
for (pg = (struct conspage *)NativeAligned4FromLPage(pgno = ListpDTD->dtd_nextpage); pgno;
pg = (struct conspage *)NativeAligned4FromLPage(pgno = pg->next_page)) {
if ((cell = find_cdrpair_in_page(pg, carpart, cdrpart))) return (cell);
}

20
src/chardev.c
View File

@@ -81,7 +81,7 @@ LispPTR CHAR_openfile(LispPTR *args)
/* struct stat statbuf; */
char pathname[MAXPATHLEN];
Lisp_errno = (int *)(Addr68k_from_LADDR(args[2]));
Lisp_errno = (int *)NativeAligned4FromLAddr(args[2]);
LispStringToCString(args[0], pathname, MAXPATHLEN);
flags = O_NONBLOCK;
@@ -130,7 +130,7 @@ LispPTR CHAR_closefile(LispPTR *args)
#ifndef DOS
int fd; /* file descriptor */
int rval;
Lisp_errno = (int *)(Addr68k_from_LADDR(args[1]));
Lisp_errno = (int *)NativeAligned4FromLAddr(args[1]);
fd = LispNumToCInt(args[0]);
ERRSETJMP(NIL);
TIMEOUT(rval = close(fd));
@@ -175,10 +175,10 @@ LispPTR CHAR_ioctl(LispPTR *args)
int fd, request;
void *data;
int rval;
Lisp_errno = (int *)(Addr68k_from_LADDR(args[3]));
Lisp_errno = (int *)NativeAligned4FromLAddr(args[3]);
fd = LispNumToCInt(args[0]);
request = LispNumToCInt(args[1]);
data = (Addr68k_from_LADDR(args[2]));
data = NativeAligned4FromLAddr(args[2]);
ERRSETJMP(NIL);
TIMEOUT(rval = ioctl(fd, request, data));
if (rval != 0) {
@@ -206,7 +206,7 @@ LispPTR CHAR_bin(int fd, LispPTR errn)
#ifndef DOS
ssize_t rval;
unsigned char ch[4];
Lisp_errno = (int *)(Addr68k_from_LADDR(errn));
Lisp_errno = (int *)NativeAligned4FromLAddr(errn);
ERRSETJMP(NIL);
fd = LispNumToCInt(fd);
@@ -238,7 +238,7 @@ LispPTR CHAR_bout(int fd, LispPTR ch, LispPTR errn)
#ifndef DOS
ssize_t rval;
char buf[4];
Lisp_errno = (int *)(Addr68k_from_LADDR(errn));
Lisp_errno = (int *)NativeAligned4FromLAddr(errn);
ERRSETJMP(NIL);
fd = LispNumToCInt(fd);
buf[0] = LispNumToCInt(ch);
@@ -285,10 +285,10 @@ LispPTR CHAR_bins(LispPTR *args)
ssize_t rval;
char *buffer;
int nbytes;
Lisp_errno = (int *)(Addr68k_from_LADDR(args[4]));
Lisp_errno = (int *)NativeAligned4FromLAddr(args[4]);
ERRSETJMP(NIL);
fd = LispNumToCInt(args[0]);
buffer = ((char *)(Addr68k_from_LADDR(args[1]))) + LispNumToCInt(args[2]);
buffer = ((char *)(NativeAligned2FromLAddr(args[1]))) + LispNumToCInt(args[2]);
nbytes = LispNumToCInt(args[3]);
/* Read PAGE_SIZE bytes file contents from filepointer. */
TIMEOUT(rval = read(fd, buffer, nbytes));
@@ -337,10 +337,10 @@ LispPTR CHAR_bouts(LispPTR *args)
ssize_t rval;
char *buffer;
int nbytes;
Lisp_errno = (int *)(Addr68k_from_LADDR(args[4]));
Lisp_errno = (int *)NativeAligned4FromLAddr(args[4]);
ERRSETJMP(NIL);
fd = LispNumToCInt(args[0]);
buffer = ((char *)(Addr68k_from_LADDR(args[1]))) + LispNumToCInt(args[2]);
buffer = ((char *)(NativeAligned2FromLAddr(args[1]))) + LispNumToCInt(args[2]);
nbytes = LispNumToCInt(args[3]);
/* Write PAGE_SIZE bytes file contents from filepointer. */
#ifdef BYTESWAP

14
src/chatter.c
View File

@@ -37,18 +37,18 @@ int chatter_fd;
short *sbase; \
int i; \
\
arrayp = (OneDArray *)(Addr68k_from_LADDR((UNSIGNED)Lisp)); \
arrayp = (OneDArray *)(NativeAligned4FromLAddr((UNSIGNED)Lisp)); \
Len = min(MaxLen, arrayp->totalsize); \
\
switch (arrayp->typenumber) { \
case THIN_CHAR_TYPENUMBER: \
base = ((char *)(Addr68k_from_LADDR((UNSIGNED)arrayp->base))) + ((int)(arrayp->offset)); \
base = ((char *)(NativeAligned2FromLAddr((UNSIGNED)arrayp->base))) + ((int)(arrayp->offset)); \
for (i = 0; i < Len; i++) C[i] = base[i]; \
C[Len] = '\0'; \
break; \
\
case FAT_CHAR_TYPENUMBER: \
sbase = ((short *)(Addr68k_from_LADDR((UNSIGNED)arrayp->base))) + ((int)(arrayp->offset)); \
sbase = ((short *)(NativeAligned2FromLAddr((UNSIGNED)arrayp->base))) + ((int)(arrayp->offset)); \
base = (char *)sbase; \
for (i = 0; i < Len * 2; i++) C[i] = base[i]; \
C[Len * 2] = '\0'; \
@@ -65,17 +65,17 @@ int chatter_fd;
short *sbase; \
int idx; \
\
arrayp = (OneDArray *)(Addr68k_from_LADDR((UNSIGNED)Lisp)); \
arrayp = (OneDArray *)(NativeAligned4FromLAddr((UNSIGNED)Lisp)); \
\
switch (arrayp->typenumber) { \
case THIN_CHAR_TYPENUMBER: \
base = ((char *)(Addr68k_from_LADDR((UNSIGNED)arrayp->base))) + ((int)(arrayp->offset)); \
base = ((char *)(NativeAligned2FromLAddr((UNSIGNED)arrayp->base))) + ((int)(arrayp->offset)); \
for (idx = 0; idx < Len; idx++) base[idx] = C[idx]; \
arrayp->fillpointer = Len; \
break; \
\
case FAT_CHAR_TYPENUMBER: \
sbase = ((short *)(Addr68k_from_LADDR((UNSIGNED)arrayp->base))) + ((int)(arrayp->offset)); \
sbase = ((short *)(NativeAligned2FromLAddr((UNSIGNED)arrayp->base))) + ((int)(arrayp->offset)); \
base = (char *)sbase; \
for (idx = 0; idx < Len * 2; idx++) base[idx] = C[idx]; \
arrayp->fillpointer = Len; \
@@ -89,7 +89,7 @@ int chatter_fd;
{ \
int *base; \
\
base = (int *)Addr68k_from_LADDR((UNSIGNED)Lisp); \
base = (int *)NativeAligned4FromLAddr((UNSIGNED)Lisp); \
*base = C; \
}

40
src/conspage.c
View File

@@ -16,7 +16,7 @@
#include <stddef.h> // for NULL
#include "address.h" // for POINTER_PAGE
#include "adr68k.h" // for Addr68k_from_LPAGE, LPAGE_from_68k, LADDR_...
#include "adr68k.h" // for NativeAligned4FromLPage, LPageFromNative, ...
#include "allocmdsdefs.h" // for alloc_mdspage
#include "car-cdrdefs.h" // for find_close_prior_cell
#include "cell.h" // for conspage, freecons, FREECONS, CDR_NIL, CON...
@@ -128,21 +128,21 @@ struct conspage *next_conspage(void) {
page2 = (struct conspage *)((DLword *)page1 + DLWORDSPER_PAGE);
init_conspage(page2, 0); /* No next page */
init_conspage(page1, LPAGE_from_68k(page2));
init_conspage(page1, LPageFromNative(page2));
priorpg = NULL;
prior = 0;
for (pg = (struct conspage *)Addr68k_from_LPAGE(next = ListpDTD->dtd_nextpage);
for (pg = (struct conspage *)NativeAligned4FromLPage(next = ListpDTD->dtd_nextpage);
next && (next != CONSPAGE_LAST);
pg = (struct conspage *)Addr68k_from_LPAGE(next = pg->next_page)) {
pg = (struct conspage *)NativeAligned4FromLPage(next = pg->next_page)) {
priorpg = pg;
prior = next;
}
if (prior)
priorpg->next_page = LPAGE_from_68k(page1);
priorpg->next_page = LPageFromNative(page1);
else
ListpDTD->dtd_nextpage = LPAGE_from_68k(page1);
ListpDTD->dtd_nextpage = LPageFromNative(page1);
if (page2->next_page) error("page2 has a next page??");
if (page2 == priorpg) error("loop in conspage next_pages");
@@ -160,12 +160,12 @@ struct conspage *next_conspage(void) {
* when it was previously commented as "Doesn't exist next page"
*/
init_conspage(page2, ListpDTD->dtd_nextpage);
init_conspage(page1, LPAGE_from_68k(page2));
init_conspage(page1, LPageFromNative(page2));
ListpDTD->dtd_nextpage = LPAGE_from_68k(page1);
ListpDTD->dtd_nextpage = LPageFromNative(page1);
goto ex; /* replaced break */
} else {
page1 = (struct conspage *)Addr68k_from_LPAGE(next); /*Jan-21*/
page1 = (struct conspage *)NativeAligned4FromLPage(next); /*Jan-21*/
}
if (page1->count > 1) break;
@@ -252,8 +252,8 @@ static ConsCell *find_cdrcodable_pair(LispPTR cdrval) {
struct conspage *pg;
unsigned pgno = ListpDTD->dtd_nextpage;
for (pg = (struct conspage *)Addr68k_from_LPAGE(pgno); pgno;
pg = (struct conspage *)Addr68k_from_LPAGE(pgno = pg->next_page))
for (pg = (struct conspage *)NativeAligned4FromLPage(pgno); pgno;
pg = (struct conspage *)NativeAligned4FromLPage(pgno = pg->next_page))
if ((cell = find_pair_in_page(pg, cdrval))) return (cell);
pg = next_conspage();
@@ -266,8 +266,8 @@ static ConsCell *find_free_cons_cell(void) {
struct conspage *pg;
unsigned pgno = ListpDTD->dtd_nextpage;
for (pg = (struct conspage *)Addr68k_from_LPAGE(pgno); pgno;
pg = (struct conspage *)Addr68k_from_LPAGE(pgno))
for (pg = (struct conspage *)NativeAligned4FromLPage(pgno); pgno;
pg = (struct conspage *)NativeAligned4FromLPage(pgno))
if (pg->count) {
pg->count--;
cell = (ConsCell *)(((DLword *)pg) + (pg->next_cell));
@@ -312,7 +312,7 @@ LispPTR N_OP_cons(int cons_car, int cons_cdr) {
if ((ListpDTD->dtd_nextpage != 0) &&
(GetCONSCount(ListpDTD->dtd_nextpage) > 0)) { /* next page has 1 or more free cells */
new_page = ListpDTD->dtd_nextpage;
new_conspage = (struct conspage *)Addr68k_from_LPAGE(new_page);
new_conspage = (struct conspage *)NativeAligned4FromLPage(new_page);
if (new_conspage->next_cell == 0) error("count ne 0, but nothing on free chain.");
new_cell = GetNewCell_68k(new_conspage); /* get new cell */
@@ -346,7 +346,7 @@ LispPTR N_OP_cons(int cons_car, int cons_cdr) {
else /* cons_cdr != NIL */
{
new_page = POINTER_PAGE(cons_cdr); /* Y's page num */
new_conspage = (struct conspage *)Addr68k_from_LPAGE(new_page);
new_conspage = (struct conspage *)NativeAligned4FromLPage(new_page);
#ifdef NEWCDRCODING
if (Listp(cons_cdr) && (new_conspage->count > 0) &&
(new_cell = find_close_prior_cell(new_conspage, cons_cdr)))
@@ -360,7 +360,7 @@ LispPTR N_OP_cons(int cons_car, int cons_cdr) {
new_cell = GetNewCell_68k(new_conspage);
#ifdef DEBUG
if (new_cell->car_field != NIL) {
printf("CELL 0x%x has non-NIL car = 0x%x \n", LADDR_from_68k(new_cell),
printf("CELL 0x%x has non-NIL car = 0x%x \n", LAddrFromNative(new_cell),
new_cell->car_field);
error("QUIT from N_OP_cons");
}
@@ -390,7 +390,7 @@ LispPTR N_OP_cons(int cons_car, int cons_cdr) {
temp_cell = GetNewCell_68k(new_conspage);
#ifdef DEBUG
if (temp_cell->car_field != NIL) {
printf("CDR indirect CELL 0x%x has non-NIL car 0x%x \n", LADDR_from_68k(new_cell),
printf("CDR indirect CELL 0x%x has non-NIL car 0x%x \n", LAddrFromNative(new_cell),
temp_cell->car_field);
error("QUIT from N_OP_cons");
}
@@ -400,7 +400,7 @@ LispPTR N_OP_cons(int cons_car, int cons_cdr) {
new_cell = GetNewCell_68k(new_conspage);
#ifdef DEBUG
if (new_cell->car_field != NIL) {
printf("CDR ind-2 CELL 0x%x has non-NIL car = 0x%x \n", LADDR_from_68k(new_cell),
printf("CDR ind-2 CELL 0x%x has non-NIL car = 0x%x \n", LAddrFromNative(new_cell),
new_cell->car_field);
error("QUIT from N_OP_cons");
}
@@ -416,7 +416,7 @@ LispPTR N_OP_cons(int cons_car, int cons_cdr) {
#ifndef NEWCDRCODING
/* culc. cdr code */
new_cell->cdr_code = (((LispPTR)LADDR_from_68k(temp_cell)) & 0xff) >> 1;
new_cell->cdr_code = (((LispPTR)LAddrFromNative(temp_cell)) & 0xff) >> 1;
#endif /* NEWCDRCODING */
ListpDTD->dtd_oldcnt++; /* added feb-12 take */
@@ -425,7 +425,7 @@ LispPTR N_OP_cons(int cons_car, int cons_cdr) {
} /* else (cons_cdr==NIL end) */
new_page = LADDR_from_68k(new_cell);
new_page = LAddrFromNative(new_cell);
GCLOOKUP(new_page, DELREF);
#ifdef NEWCDRCODING
if (254 < ((new_page & 0xff) + ((new_cell->cdr_code & 7) << 1)))

90
src/dbgtool.c
View File

@@ -104,9 +104,9 @@ LispPTR get_ivar_name(struct frameex1 *fx_addr68k, DLword offset, int *localivar
struct fnhead *fnobj;
int i;
#ifdef BIGVM
fnobj = (struct fnhead *)Addr68k_from_LADDR((fx_addr68k)->fnheader);
fnobj = (struct fnhead *)NativeAligned4FromLAddr((fx_addr68k)->fnheader);
#else
fnobj = (struct fnhead *)Addr68k_from_LADDR(((int)(fx_addr68k)->hi2fnheader << 16) |
fnobj = (struct fnhead *)NativeAligned4FromLAddr(((int)(fx_addr68k)->hi2fnheader << 16) |
(fx_addr68k)->lofnheader);
#endif /* BIGVM */
if (fnobj->ntsize > 0) {
@@ -183,9 +183,9 @@ LispPTR get_pvar_name(struct frameex1 *fx_addr68k, DLword offset) {
int i;
#ifdef BIGVM
fnobj = (struct fnhead *)Addr68k_from_LADDR((fx_addr68k)->fnheader);
fnobj = (struct fnhead *)NativeAligned4FromLAddr((fx_addr68k)->fnheader);
#else
fnobj = (struct fnhead *)Addr68k_from_LADDR(((int)(fx_addr68k)->hi2fnheader << 16) |
fnobj = (struct fnhead *)NativeAligned4FromLAddr(((int)(fx_addr68k)->hi2fnheader << 16) |
(fx_addr68k)->lofnheader);
#endif /* BIGVM */
@@ -253,9 +253,9 @@ LispPTR get_fn_fvar_name(struct fnhead *fnobj, DLword offset) {
LispPTR get_fvar_name(struct frameex1 *fx_addr68k, DLword offset) {
#ifdef BIGVM
return (get_fn_fvar_name((struct fnhead *)Addr68k_from_LADDR((fx_addr68k)->fnheader), offset));
return (get_fn_fvar_name((struct fnhead *)NativeAligned4FromLAddr((fx_addr68k)->fnheader), offset));
#else
return (get_fn_fvar_name((struct fnhead *)Addr68k_from_LADDR(
return (get_fn_fvar_name((struct fnhead *)NativeAligned4FromLAddr(
((int)(fx_addr68k)->hi2fnheader << 16) | (fx_addr68k)->lofnheader),
offset));
#endif /* BIGVM */
@@ -292,25 +292,25 @@ int sf(struct frameex1 *fx_addr68k) {
if ((UNSIGNED)fx_addr68k == 0) return (-1);
if ((fx_addr68k)->flags != STK_FX) {
printf("Invalid FX 0x%x, flags = 0x%x.\n", LADDR_from_68k(fx_addr68k), (fx_addr68k)->flags);
printf("Invalid FX 0x%x, flags = 0x%x.\n", LAddrFromNative(fx_addr68k), (fx_addr68k)->flags);
return (-1);
}
if (((fx_addr68k)->alink & 1) == 0) { /* FAST */
bf = (Bframe *)(((DLword *)fx_addr68k) - 2);
} else { /* SLOW */
bf = (Bframe *)Addr68k_from_LADDR(((fx_addr68k)->blink + STK_OFFSET));
bf = (Bframe *)NativeAligned4FromLAddr(((fx_addr68k)->blink + STK_OFFSET));
}
/* Print IVARs */
printf("IVAR -------\n");
BT_morep;
ptr = Addr68k_from_LADDR(STK_OFFSET + bf->ivar);
ptr = NativeAligned2FromLAddr(STK_OFFSET + bf->ivar);
i = 0;
while (ptr != (DLword *)bf) {
ptrlo = ptr + 1;
printf(" %6x : 0x%4x 0x%4x ", LADDR_from_68k(ptr), GETWORD(ptr), GETWORD(ptrlo));
printf(" %6x : 0x%4x 0x%4x ", LAddrFromNative(ptr), GETWORD(ptr), GETWORD(ptrlo));
ivarindex = get_ivar_name(fx_addr68k, i++, &localivar);
if (localivar == 1) printf("*local* ");
print_atomname(ivarindex);
@@ -322,7 +322,7 @@ int sf(struct frameex1 *fx_addr68k) {
}
putchar('\n');
BT_morep;
printf("## STACK BF at 0x%x ##\n", (LispPTR)LADDR_from_68k(bf));
printf("## STACK BF at 0x%x ##\n", (LispPTR)LAddrFromNative(bf));
BT_morep;
/* print BF */
@@ -339,7 +339,7 @@ int sf(struct frameex1 *fx_addr68k) {
BT_morep;
printf(">> Bf's ivar says 0x%x vs. IVar says 0x%x\n", bf->ivar + STK_OFFSET,
LADDR_from_68k(IVar));
LAddrFromNative(IVar));
BT_morep;
atomindex = get_framename(fx_addr68k);
@@ -349,7 +349,7 @@ int sf(struct frameex1 *fx_addr68k) {
BT_morep;
/***** printout FX ****/
printf("## STACK FX at 0x%x ##\n", LADDR_from_68k(fx_addr68k));
printf("## STACK FX at 0x%x ##\n", LAddrFromNative(fx_addr68k));
BT_morep;
if ((fx_addr68k)->flags != 6) {
@@ -403,9 +403,9 @@ int sf(struct frameex1 *fx_addr68k) {
/* added by NMitani 26 Aug 87 */
#ifdef BIGVM
fnobj = (struct fnhead *)Addr68k_from_LADDR(fx_addr68k->fnheader);
fnobj = (struct fnhead *)NativeAligned4FromLAddr(fx_addr68k->fnheader);
#else
fnobj = (struct fnhead *)Addr68k_from_LADDR(((int)fx_addr68k->hi2fnheader << 16) |
fnobj = (struct fnhead *)NativeAligned4FromLAddr(((int)fx_addr68k->hi2fnheader << 16) |
fx_addr68k->lofnheader);
#endif /* BIGVM */
max_npvar = npvar = fnobj->nlocals; /* npvar is number of Pvars */
@@ -426,7 +426,7 @@ int sf(struct frameex1 *fx_addr68k) {
while (npvar-- > 0) {
ptrhi = ptr;
ptrlo = ptr + 1;
printf(" %6x : 0x%4x 0x%4x ", LADDR_from_68k(ptr), GETWORD(ptrhi), GETWORD(ptrlo));
printf(" %6x : 0x%4x 0x%4x ", LAddrFromNative(ptr), GETWORD(ptrhi), GETWORD(ptrlo));
if ((pvarindex = get_pvar_name(fx_addr68k, i++)) == LOCAL_PVAR)
printf("*local* [pvar%d] ", (i - 1));
else
@@ -446,7 +446,7 @@ int sf(struct frameex1 *fx_addr68k) {
while (nfvar && nfvar-- >= max_npvar) {
ptrhi = ptr;
ptrlo = ptr + 1;
printf(" %6x : 0x%4x 0x%4x ", LADDR_from_68k(ptr), GETWORD(ptrhi), GETWORD(ptrlo));
printf(" %6x : 0x%4x 0x%4x ", LAddrFromNative(ptr), GETWORD(ptrhi), GETWORD(ptrlo));
if (0xFFFF == GETWORD(ptrhi)) {
printf("[not looked up] ");
print_atomname(get_fvar_name(fx_addr68k, i));
@@ -456,16 +456,14 @@ int sf(struct frameex1 *fx_addr68k) {
printf("[fvar ");
print_atomname(get_fvar_name(fx_addr68k, i));
printf(" on stack] ");
print(*(
LispPTR *)(Addr68k_from_LADDR(((int)(0x0F & GETWORD(ptrlo)) << 16) | GETWORD(ptrhi))));
print(*(LispPTR *)NativeAligned4FromLAddr(((int)(0x0F & GETWORD(ptrlo)) << 16) | GETWORD(ptrhi)));
putchar('\n');
BT_morep;
} else {
printf("[fvar ");
print_atomname(get_fvar_name(fx_addr68k, i));
printf(" top value ] ");
print(*(
LispPTR *)(Addr68k_from_LADDR(((int)(0xFFF & GETWORD(ptrlo)) << 16) | GETWORD(ptrhi))));
print(*(LispPTR *)NativeAligned4FromLAddr(((int)(0xFFF & GETWORD(ptrlo)) << 16) | GETWORD(ptrhi)));
putchar('\n');
BT_morep;
}
@@ -473,14 +471,14 @@ int sf(struct frameex1 *fx_addr68k) {
i++;
}
if (fx_addr68k->alink == 11) /* for contextsw */
next68k = (DLword *)Addr68k_from_LADDR((fx_addr68k->nextblock + STK_OFFSET));
next68k = (DLword *)NativeAligned2FromLAddr((fx_addr68k->nextblock + STK_OFFSET));
else
next68k = CurrentStackPTR;
while (ptr < next68k) {
ptrhi = ptr;
ptrlo = ptr + 1;
printf(" %6x : 0x%4x 0x%4x ", LADDR_from_68k(ptr), GETWORD(ptrhi), GETWORD(ptrlo));
printf(" %6x : 0x%4x 0x%4x ", LAddrFromNative(ptr), GETWORD(ptrhi), GETWORD(ptrlo));
print(*(LispPTR *)ptr);
ptr += 2;
putchar('\n');
@@ -491,14 +489,14 @@ int sf(struct frameex1 *fx_addr68k) {
return (-1);
}
next68k = (DLword *)Addr68k_from_LADDR((fx_addr68k->nextblock + STK_OFFSET));
next68k = (DLword *)NativeAligned2FromLAddr((fx_addr68k->nextblock + STK_OFFSET));
ptr = (DLword *)(fx_addr68k + 1);
i = 0;
while (npvar-- > 0) {
ptrhi = ptr;
ptrlo = ptr + 1;
printf(" %6x : 0x%4x 0x%4x ", LADDR_from_68k(ptr), GETWORD(ptrhi), GETWORD(ptrlo));
printf(" %6x : 0x%4x 0x%4x ", LAddrFromNative(ptr), GETWORD(ptrhi), GETWORD(ptrlo));
if ((pvarindex = get_pvar_name(fx_addr68k, i++)) == LOCAL_PVAR)
printf("*local* [pvar%d] ", (i - 1));
else
@@ -519,7 +517,7 @@ int sf(struct frameex1 *fx_addr68k) {
while (nfvar && nfvar-- >= max_npvar) {
ptrhi = ptr;
ptrlo = ptr + 1;
printf(" %6x : 0x%4x 0x%4x ", LADDR_from_68k(ptr), GETWORD(ptrhi), GETWORD(ptrlo));
printf(" %6x : 0x%4x 0x%4x ", LAddrFromNative(ptr), GETWORD(ptrhi), GETWORD(ptrlo));
if (0xFFFF == GETWORD(ptrhi)) {
printf("[not looked up] ");
print_atomname(get_fvar_name(fx_addr68k, i));
@@ -529,16 +527,14 @@ int sf(struct frameex1 *fx_addr68k) {
printf("[fvar ");
print_atomname(get_fvar_name(fx_addr68k, i));
printf(" on stack] ");
print(
*(LispPTR *)(Addr68k_from_LADDR(((int)(0x0F & GETWORD(ptrlo)) << 16) | GETWORD(ptrhi))));
print(*(LispPTR *)NativeAligned4FromLAddr(((int)(0x0F & GETWORD(ptrlo)) << 16) | GETWORD(ptrhi)));
putchar('\n');
BT_morep;
} else {
printf("[fvar ");
print_atomname(get_fvar_name(fx_addr68k, i));
printf(" top value ] ");
print(
*(LispPTR *)(Addr68k_from_LADDR(((int)(0x0F & GETWORD(ptrlo)) << 16) | GETWORD(ptrhi))));
print(*(LispPTR *)NativeAligned4FromLAddr(((int)(0x0F & GETWORD(ptrlo)) << 16) | GETWORD(ptrhi)));
putchar('\n');
BT_morep;
}
@@ -549,7 +545,7 @@ int sf(struct frameex1 *fx_addr68k) {
while (next68k > ptr) {
ptrhi = ptr;
ptrlo = ptr + 1;
printf(" %6x : 0x%4x 0x%4x ", LADDR_from_68k(ptr), GETWORD(ptrhi), GETWORD(ptrlo));
printf(" %6x : 0x%4x 0x%4x ", LAddrFromNative(ptr), GETWORD(ptrhi), GETWORD(ptrlo));
putchar('\n');
BT_morep;
ptr += 2;
@@ -579,11 +575,11 @@ void bt1(FX *startFX) {
URaid_FXarray[fnum] = fx;
printf("%3d : ", fnum++);
#ifdef BIGVM
fnobj = (struct fnhead *)Addr68k_from_LADDR(fx->fnheader);
fnobj = (struct fnhead *)NativeAligned4FromLAddr(fx->fnheader);
#else
fnobj = (struct fnhead *)Addr68k_from_LADDR(((int)fx->hi2fnheader << 16) | fx->lofnheader);
fnobj = (struct fnhead *)NativeAligned4FromLAddr(((int)fx->hi2fnheader << 16) | fx->lofnheader);
#endif /* BIGVM */
printf(" 0x%x : ", LADDR_from_68k(fx));
printf(" 0x%x : ", LAddrFromNative(fx));
print(fnobj->framename);
putchar('\n');
BT_morep;
@@ -608,13 +604,13 @@ void bt1(FX *startFX) {
fx = get_nextFX(fx);
#ifdef BIGVM
fnobj = (struct fnhead *)Addr68k_from_LADDR(fx->fnheader);
fnobj = (struct fnhead *)NativeAligned4FromLAddr(fx->fnheader);
#else
fnobj = (struct fnhead *)Addr68k_from_LADDR(((int)fx->hi2fnheader << 16) | fx->lofnheader);
fnobj = (struct fnhead *)NativeAligned4FromLAddr(((int)fx->hi2fnheader << 16) | fx->lofnheader);
#endif /* BIGVM */
URaid_FXarray[fnum] = fx;
printf("%3d : ", fnum++);
printf(" 0x%x : ", LADDR_from_68k(fx));
printf(" 0x%x : ", LAddrFromNative(fx));
print(fnobj->framename);
putchar('\n');
BT_morep;
@@ -686,7 +682,7 @@ void btvv(void) {
/* NMitani */
/************************************************************************/
void sff(LispPTR laddr) { sf((FX *)Addr68k_from_LADDR(laddr)); }
void sff(LispPTR laddr) { sf((FX *)NativeAligned4FromLAddr(laddr)); }
#ifdef BIGATOMS
/*****************************************************************/
@@ -705,7 +701,7 @@ void nt(LispPTR index)
DefCell *defcell68k;
defcell68k = (DefCell *)GetDEFCELL68k(index);
fnobj = (struct fnhead *)Addr68k_from_LADDR(defcell68k->defpointer);
fnobj = (struct fnhead *)NativeAligned4FromLAddr(defcell68k->defpointer);
/* check if it's the same index ??*/
if (index != (fnobj->framename)) {
@@ -718,7 +714,7 @@ void nt(LispPTR index)
}
printf("***DUMP Func Header << ");
printf("start at 0x%x lisp address(%p 68k)\n", LADDR_from_68k(fnobj), (void *)fnobj);
printf("start at 0x%x lisp address(%p 68k)\n", LAddrFromNative(fnobj), (void *)fnobj);
print(index);
putchar('\n');
@@ -730,7 +726,7 @@ void ntheader(struct fnhead *fnobj) {
int localntsize;
LispPTR fnobj_lisp;
fnobj_lisp = LADDR_from_68k((DLword *)fnobj);
fnobj_lisp = LAddrFromNative((DLword *)fnobj);
printf("0x%08x: 0x%08x stkmin\n", fnobj_lisp, fnobj->stkmin);
printf("0x%08x: 0x%08x na\n", fnobj_lisp + 1, fnobj->na);
printf("0x%08x: 0x%08x pv\n", fnobj_lisp + 2, fnobj->pv);
@@ -755,14 +751,14 @@ void nts(struct frameex1 *fxp) {
#ifdef BIGVM
if (fxp->validnametable)
nt = (struct fnhead *)(Addr68k_from_LADDR(fxp->nametable));
nt = (struct fnhead *)NativeAligned4FromLAddr(fxp->nametable);
else
nt = (struct fnhead *)(Addr68k_from_LADDR(fxp->fnheader));
nt = (struct fnhead *)NativeAligned4FromLAddr(fxp->fnheader);
#else
if (fxp->validnametable)
nt = (struct fnhead *)(Addr68k_from_LADDR(((fxp->hi2nametable) << 16 | fxp->lonametable)));
nt = (struct fnhead *)NativeAligned4FromLAddr(((fxp->hi2nametable) << 16 | fxp->lonametable));
else
nt = (struct fnhead *)(Addr68k_from_LADDR(((fxp->hi2fnheader) << 16 | fxp->lofnheader)));
nt = (struct fnhead *)NativeAligned4FromLAddr(((fxp->hi2fnheader) << 16 | fxp->lofnheader));
#endif /* BIGVM */
ntheader(nt);
}
@@ -781,8 +777,8 @@ void nt1(LispPTR *start, int size, char *str) {
endp = start + size;
while (start < endp) {
entry2p = start + size;
printf("0x%06x: 0x%08x", LADDR_from_68k((DLword *)start), *start);
printf(" 0x%06x: 0x%08x", LADDR_from_68k((DLword *)entry2p), *entry2p);
printf("0x%06x: 0x%08x", LAddrFromNative((DLword *)start), *start);
printf(" 0x%06x: 0x%08x", LAddrFromNative((DLword *)entry2p), *entry2p);
if (*start != 0) {
if ((*entry2p >> 30) == VARTYPE_FVAR)
printf(" FVAR");

8
src/dir.c
View File

@@ -25,7 +25,7 @@
#include <string.h> // for strcpy, strcmp, strlen, strrchr, strcat
#include <sys/stat.h> // for stat, S_ISDIR, st_atime, st_mtime
#include <sys/time.h> // for timespec_t
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned4FromLAddr
#include "arith.h" // for GetSmallp
#include "dirdefs.h" // for COM_finish_finfo, COM_gen_files, COM_next...
#include "dskdefs.h" // for separate_version, separate_host, true_name
@@ -1978,7 +1978,7 @@ LispPTR COM_gen_files(LispPTR *args)
ERRSETJMP(GetSmallp(-1));
Lisp_errno = (int *)(Addr68k_from_LADDR(args[3]));
Lisp_errno = (int *)(NativeAligned4FromLAddr(args[3]));
LispStringLength(args[0], count, dskp);
/*
@@ -2099,7 +2099,7 @@ LispPTR COM_gen_files(LispPTR *args)
}
if ((fid = get_finfo_id()) < 0) return (GetSmallp(-1));
*(int *)(Addr68k_from_LADDR(args[2])) = fid;
*(int *)(NativeAligned4FromLAddr(args[2])) = fid;
FinfoArray[fid].head = fp;
FinfoArray[fid].next = fp;
return (GetSmallp(count));
@@ -2138,7 +2138,7 @@ LispPTR COM_next_file(LispPTR *args)
ERRSETJMP(-1);
Lisp_errno = &Dummy_errno;
gfsp = (UFSGFS *)(Addr68k_from_LADDR(args[0]));
gfsp = (UFSGFS *)(NativeAligned4FromLAddr(args[0]));
finfoid = (int)gfsp->finfoid;

6
src/draw.c
View File

@@ -19,7 +19,7 @@
#include <stddef.h> // for ptrdiff_t
#include <stdlib.h> // for abs
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned2FromLAddr
#include "display.h" // for DISPLAYBUFFER, DisplayRegion68k, in_display...
#include "drawdefs.h" // for N_OP_drawline
#include "emlglob.h"
@@ -135,7 +135,7 @@ int N_OP_drawline(LispPTR ptr, int curbit, int xsize, int width, int ysize, int
ERROR_EXIT(numy);
curbit = 0x8000 >> (curbit & 0xFFFF);
dataptr = Addr68k_from_LADDR(ptr);
dataptr = NativeAligned2FromLAddr(ptr);
numy &= 0xFFFF;
numx &= 0xFFFF;
ysize &= 0xFFFF;
@@ -264,7 +264,7 @@ int N_OP_drawline(LispPTR ptr, int curbit, int xsize, int width, int ysize, int
{
DLword *start_addr;
start_addr = (DLword *)Addr68k_from_LADDR(ptr);
start_addr = (DLword *)NativeAligned2FromLAddr(ptr);
if (in_display_segment(start_addr) && in_display_segment(dataptr)) {
int start_x, start_y, end_x, end_y, w, h;

52
src/dsk.c
View File

@@ -19,7 +19,7 @@
#include <sys/types.h> // for ino_t, time_t, off_t
#include <unistd.h> // for unlink, close, link, lseek, access, chdir
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned4FromLAddr
#include "arith.h" // for GetSmallp
#ifdef BYTESWAP
#include "byteswapdefs.h" // for word_swap_page
@@ -223,7 +223,7 @@ LispPTR COM_openfile(LispPTR *args)
char rawname[MAXNAMLEN];
#endif /* DOS */
ERRSETJMP(NIL);
Lisp_errno = (int *)(Addr68k_from_LADDR(args[5]));
Lisp_errno = (int *)NativeAligned4FromLAddr(args[5]);
LispStringLength(args[0], slen, fatp);
/*
@@ -499,10 +499,10 @@ LispPTR COM_openfile(LispPTR *args)
return (NIL);
}
bufp = (int *)(Addr68k_from_LADDR(args[3]));
bufp = (int *)NativeAligned4FromLAddr(args[3]);
*bufp = ToLispTime(sbuf.st_mtime);
bufp = (int *)(Addr68k_from_LADDR(args[4]));
bufp = (int *)NativeAligned4FromLAddr(args[4]);
if (!dskp && (!S_ISREG(sbuf.st_mode)) && (!S_ISDIR(sbuf.st_mode))) {
/*
* Not a regular file or directory file. Put on a marker.
@@ -561,7 +561,7 @@ LispPTR COM_closefile(LispPTR *args)
char rawname[MAXNAMLEN];
ERRSETJMP(NIL);
Lisp_errno = (int *)(Addr68k_from_LADDR(args[3]));
Lisp_errno = (int *)NativeAligned4FromLAddr(args[3]);
LispStringLength(args[0], rval, dskp);
@@ -690,7 +690,7 @@ LispPTR COM_closefile(LispPTR *args)
ino_t ino;
ERRSETJMP(NIL);
Lisp_errno = (int *)(Addr68k_from_LADDR(args[3]));
Lisp_errno = (int *)NativeAligned4FromLAddr(args[3]);
LispStringLength(args[0], rval, fatp);
/*
@@ -858,7 +858,7 @@ LispPTR DSK_getfilename(LispPTR *args)
#endif /* DOS */
ERRSETJMP(NIL);
Lisp_errno = (int *)(Addr68k_from_LADDR(args[3]));
Lisp_errno = (int *)NativeAligned4FromLAddr(args[3]);
LispStringLength(args[0], len, fatp);
/*
@@ -1139,7 +1139,7 @@ LispPTR DSK_deletefile(LispPTR *args)
#endif /* DOS */
ERRSETJMP(NIL);
Lisp_errno = (int *)(Addr68k_from_LADDR(args[1]));
Lisp_errno = (int *)NativeAligned4FromLAddr(args[1]);
LispStringLength(args[0], rval, fatp);
/*
@@ -1288,7 +1288,7 @@ LispPTR DSK_renamefile(LispPTR *args)
#endif /* DOS */
ERRSETJMP(NIL);
Lisp_errno = (int *)(Addr68k_from_LADDR(args[2]));
Lisp_errno = (int *)NativeAligned4FromLAddr(args[2]);
LispStringLength(args[0], rval, fatp);
/*
@@ -1511,7 +1511,7 @@ LispPTR DSK_directorynamep(LispPTR *args)
#endif /* DOS */
ERRSETJMP(NIL);
Lisp_errno = (int *)(Addr68k_from_LADDR(args[2]));
Lisp_errno = (int *)NativeAligned4FromLAddr(args[2]);
LispStringLength(args[0], len, fatp);
/*
@@ -1603,7 +1603,7 @@ LispPTR COM_getfileinfo(LispPTR *args)
#endif /* DOS */
ERRSETJMP(NIL);
Lisp_errno = (int *)(Addr68k_from_LADDR(args[3]));
Lisp_errno = (int *)NativeAligned4FromLAddr(args[3]);
LispStringLength(args[0], rval, dskp);
/*
@@ -1672,22 +1672,22 @@ LispPTR COM_getfileinfo(LispPTR *args)
switch (args[1]) {
case LENGTH:
bufp = (unsigned *)(Addr68k_from_LADDR(args[2]));
bufp = (unsigned *)NativeAligned4FromLAddr(args[2]);
*bufp = (unsigned)sbuf.st_size;
return (ATOM_T);
case WDATE:
bufp = (unsigned *)(Addr68k_from_LADDR(args[2]));
bufp = (unsigned *)NativeAligned4FromLAddr(args[2]);
*bufp = (unsigned)ToLispTime(sbuf.st_mtime);
return (ATOM_T);
case RDATE:
bufp = (unsigned *)(Addr68k_from_LADDR(args[2]));
bufp = (unsigned *)NativeAligned4FromLAddr(args[2]);
*bufp = (unsigned)ToLispTime(sbuf.st_atime);
return (ATOM_T);
case PROTECTION:
bufp = (unsigned *)(Addr68k_from_LADDR(args[2]));
bufp = (unsigned *)NativeAligned4FromLAddr(args[2]);
*bufp = sbuf.st_mode;
return (ATOM_T);
@@ -1723,19 +1723,19 @@ LispPTR COM_getfileinfo(LispPTR *args)
* (AUTHOR . string))
*/
laddr = cdr(car(args[2]));
bufp = (unsigned *)(Addr68k_from_LADDR(laddr));
bufp = (unsigned *)NativeAligned4FromLAddr(laddr);
*bufp = sbuf.st_size;
laddr = cdr(car(cdr(args[2])));
bufp = (unsigned *)(Addr68k_from_LADDR(laddr));
bufp = (unsigned *)NativeAligned4FromLAddr(laddr);
*bufp = ToLispTime(sbuf.st_mtime);
laddr = cdr(car(cdr(cdr(args[2]))));
bufp = (unsigned *)(Addr68k_from_LADDR(laddr));
bufp = (unsigned *)NativeAligned4FromLAddr(laddr);
*bufp = ToLispTime(sbuf.st_atime);
laddr = cdr(car(cdr(cdr(cdr(args[2])))));
bufp = (unsigned *)(Addr68k_from_LADDR(laddr));
bufp = (unsigned *)NativeAligned4FromLAddr(laddr);
*bufp = sbuf.st_mode;
#ifndef DOS
TIMEOUT0(pwd = getpwuid(sbuf.st_uid));
@@ -1798,7 +1798,7 @@ LispPTR COM_setfileinfo(LispPTR *args)
#endif /* DOS */
ERRSETJMP(NIL);
Lisp_errno = (int *)(Addr68k_from_LADDR(args[3]));
Lisp_errno = (int *)NativeAligned4FromLAddr(args[3]);
LispStringLength(args[0], rval, dskp);
/*
@@ -1924,11 +1924,11 @@ LispPTR COM_readpage(LispPTR *args)
struct stat sbuf;
ERRSETJMP(NIL);
Lisp_errno = (int *)(Addr68k_from_LADDR(args[3]));
Lisp_errno = (int *)NativeAligned4FromLAddr(args[3]);
fd = LispNumToCInt(args[0]);
npage = LispNumToCInt(args[1]);
bufp = (char *)(Addr68k_from_LADDR(args[2]));
bufp = (char *)NativeAligned2FromLAddr(args[2]);
TIMEOUT(rval = fstat(fd, &sbuf));
if (rval != 0) {
@@ -2009,11 +2009,11 @@ LispPTR COM_writepage(LispPTR *args)
off_t offval;
ERRSETJMP(NIL);
Lisp_errno = (int *)(Addr68k_from_LADDR(args[4]));
Lisp_errno = (int *)NativeAligned4FromLAddr(args[4]);
fd = LispNumToCInt(args[0]);
npage = LispNumToCInt(args[1]);
bufp = (char *)(Addr68k_from_LADDR(args[2]));
bufp = (char *)NativeAligned2FromLAddr(args[2]);
count = LispNumToCInt(args[3]);
sklp2:
@@ -2078,7 +2078,7 @@ LispPTR COM_truncatefile(LispPTR *args)
struct stat sbuf;
ERRSETJMP(NIL);
Lisp_errno = (int *)(Addr68k_from_LADDR(args[2]));
Lisp_errno = (int *)NativeAligned4FromLAddr(args[2]);
fd = LispNumToCInt(args[0]);
length = LispNumToCInt(args[1]);
@@ -2263,7 +2263,7 @@ LispPTR COM_getfreeblock(LispPTR *args)
if (rval > MAXPATHLEN + 5) FileNameTooLong(NIL);
LispStringToCString(args[0], lfname, MAXPATHLEN);
buf = (int *)(Addr68k_from_LADDR(args[1]));
buf = (int *)NativeAligned4FromLAddr(args[1]);
#ifdef DOS
separate_host(lfname, host, drive);
#else

42
src/ejlisp.c
View File

@@ -43,20 +43,20 @@
short *sbase; \
int i, j; \
\
arrayp = (OneDArray *)(Addr68k_from_LADDR((unsigned int)Lisp)); \
arrayp = (OneDArray *)(NativeAligned4FromLAddr((unsigned int)Lisp)); \
Len = min(MaxLen, arrayp->totalsize); \
\
switch (arrayp->typenumber) { \
case THIN_CHAR_TYPENUMBER: \
base = \
((char *)(Addr68k_from_LADDR((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
((char *)(NativeAligned2FromLAddr((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
for (i = 0; i < Len; i++) { C[i] = base[i]; } \
C[Len] = '\0'; \
break; \
\
case FAT_CHAR_TYPENUMBER: \
sbase = \
((short *)(Addr68k_from_LADDR((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
((short *)(NativeAligned2FromLAddr((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
base = (char *)sbase; \
for (i = 0; i < Len * 2; i++) C[i] = base[i]; \
C[Len * 2] = '\0'; \
@@ -73,19 +73,19 @@
short *sbase; \
int idx; \
\
arrayp = (OneDArray *)(Addr68k_from_LADDR((unsigned int)Lisp)); \
arrayp = (OneDArray *)(NativeAligned4FromLAddr((unsigned int)Lisp)); \
\
switch (arrayp->typenumber) { \
case THIN_CHAR_TYPENUMBER: \
base = \
((char *)(Addr68k_from_LADDR((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
((char *)(NativeAligned2FromLAddr((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
for (idx = 0; idx < Len; idx++) base[idx] = C[idx]; \
arrayp->fillpointer = Len; \
break; \
\
case FAT_CHAR_TYPENUMBER: \
sbase = \
((short *)(Addr68k_from_LADDR((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
((short *)(NativeAligned2FromLAddr((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
base = (char *)sbase; \
for (idx = 0; idx < Len * 2; idx++) base[idx] = C[idx]; \
arrayp->fillpointer = Len; \
@@ -99,7 +99,7 @@
{ \
int *base; \
\
base = (int *)Addr68k_from_LADDR((unsigned int)Lisp); \
base = (int *)NativeAligned4FromLAddr((unsigned int)Lisp); \
*base = C; \
}
@@ -249,9 +249,9 @@ ejlisp(int args[])
result = ejlisp_get_kouho(c_number1, c_char3, &c_number2);
if (result != 0) break;
a_ptr = (FirstArray *)(Addr68k_from_LADDR((unsigned int)args[2]));
a_ptr = (FirstArray *)(NativeAligned4FromLAddr((unsigned int)args[2]));
base1 =
((unsigned int *)(Addr68k_from_LADDR((unsigned int)a_ptr->base))) + (int)(a_ptr->offset);
((unsigned int *)(NativeAligned4FromLAddr((unsigned int)a_ptr->base))) + (int)(a_ptr->offset);
for (i = 0; i < ejlisp_kouho_max; i++, base1++, base2++) {
ZeroFix(c_char3[i]);
@@ -363,17 +363,17 @@ ejlisp(int args[])
result = ejlisp_get_userdic(c_char3, c_number5, c_number6);
if (result != 0) break;
a_ptr = (FirstArray *)(Addr68k_from_LADDR((unsigned int)args[1]));
a_ptr = (FirstArray *)(NativeAligned4FromLAddr((unsigned int)args[1]));
base1 =
((unsigned int *)(Addr68k_from_LADDR((unsigned int)a_ptr->base))) + (int)(a_ptr->offset);
((unsigned int *)(NativeAligned4FromLAddr((unsigned int)a_ptr->base))) + (int)(a_ptr->offset);
a_ptr = (FirstArray *)(Addr68k_from_LADDR((unsigned int)args[2]));
a_ptr = (FirstArray *)(NativeAligned4FromLAddr((unsigned int)args[2]));
base2 =
((unsigned int *)(Addr68k_from_LADDR((unsigned int)a_ptr->base))) + (int)(a_ptr->offset);
((unsigned int *)(NativeAligned4FromLAddr((unsigned int)a_ptr->base))) + (int)(a_ptr->offset);
a_ptr = (FirstArray *)(Addr68k_from_LADDR((unsigned int)args[3]));
a_ptr = (FirstArray *)(NativeAligned4FromLAddr((unsigned int)args[3]));
base3 =
((unsigned int *)(Addr68k_from_LADDR((unsigned int)a_ptr->base))) + (int)(a_ptr->offset);
((unsigned int *)(NativeAligned4FromLAddr((unsigned int)a_ptr->base))) + (int)(a_ptr->offset);
for (i = 0; i < ejlisp_jdp_num; i++, base1++, base2++, base3++) {
ZeroFix(c_char3[i]);
@@ -390,17 +390,17 @@ ejlisp(int args[])
result = ejlisp_get_userdic_name(c_char3, c_number5, c_number6);
if (result != 0) break;
a_ptr = (FirstArray *)(Addr68k_from_LADDR((unsigned int)args[1]));
a_ptr = (FirstArray *)(NativeAligned4FromLAddr((unsigned int)args[1]));
base1 =
((unsigned int *)(Addr68k_from_LADDR((unsigned int)a_ptr->base))) + (int)(a_ptr->offset);
((unsigned int *)(NativeAligned4FromLAddr((unsigned int)a_ptr->base))) + (int)(a_ptr->offset);
a_ptr = (FirstArray *)(Addr68k_from_LADDR((unsigned int)args[2]));
a_ptr = (FirstArray *)(NativeAligned4FromLAddr((unsigned int)args[2]));
base2 =
((unsigned int *)(Addr68k_from_LADDR((unsigned int)a_ptr->base))) + (int)(a_ptr->offset);
((unsigned int *)(NativeAligned4FromLAddr((unsigned int)a_ptr->base))) + (int)(a_ptr->offset);
a_ptr = (FirstArray *)(Addr68k_from_LADDR((unsigned int)args[3]));
a_ptr = (FirstArray *)(NativeAligned4FromLAddr((unsigned int)args[3]));
base3 =
((unsigned int *)(Addr68k_from_LADDR((unsigned int)a_ptr->base))) + (int)(a_ptr->offset);
((unsigned int *)(NativeAligned4FromLAddr((unsigned int)a_ptr->base))) + (int)(a_ptr->offset);
for (i = 0; c_char3[i][0] != NULL; i++, base1++, base2++, base3++) {
ZeroFix(c_char3[i]);

14
src/ether.c
View File

@@ -381,7 +381,7 @@ LispPTR ether_get(LispPTR args[])
sigprocmask(SIG_BLOCK, &signals, NULL);
if (ether_fd > 0 && (MaxByteCount > 0)) {
ether_buf = (u_char *)Addr68k_from_LADDR(args[1]);
ether_buf = (u_char *)NativeAligned2FromLAddr(args[1]);
ether_bsize = MaxByteCount; /* do this LAST; it enables reads */
result = get_packet();
/* check_ether(); for old behavior, move comment to above line */
@@ -413,7 +413,7 @@ LispPTR ether_send(LispPTR args[])
u_char *BufferAddr; /* buffer address pointer(in native address) */
MaxByteCount = 2 * (0xFFFF & args[0]); /* words to bytes */
BufferAddr = (u_char *)Addr68k_from_LADDR(args[1]);
BufferAddr = (u_char *)NativeAligned2FromLAddr(args[1]);
if (ether_fd > 0) {
#ifdef PKTFILTER
@@ -550,7 +550,7 @@ LispPTR check_ether() {
DBPRINT(
("Found packet len %d, at pos %d in buflen %d.\n", fromlen, nitpos, nitlen));
nitpos += fromlen;
((INTSTAT *)Addr68k_from_LADDR(*INTERRUPTSTATE_word))->ETHERInterrupt = 1;
((INTSTAT *)NativeAligned4FromLAddr(*INTERRUPTSTATE_word))->ETHERInterrupt = 1;
ETHEREventCount++;
Irq_Stk_Check = Irq_Stk_End = 0;
*PENDINGINTERRUPT68k = ATOM_T;
@@ -591,7 +591,7 @@ LispPTR check_ether() {
ether_bsize = 0;
ether_in++;
IOPage->dlethernet[3] = data.len;
((INTSTAT *)Addr68k_from_LADDR(*INTERRUPTSTATE_word))->ETHERInterrupt = 1;
((INTSTAT *)NativeAligned4FromLAddr(*INTERRUPTSTATE_word))->ETHERInterrupt = 1;
ETHEREventCount++;
Irq_Stk_Check = Irq_Stk_End = 0;
*PENDINGINTERRUPT68k = ATOM_T;
@@ -786,8 +786,8 @@ void init_ether() {
struct strioctl si;
unsigned long snaplen = 0;
/* ((INTSTAT*)Addr68k_from_LADDR(*INTERRUPTSTATE_word))->ETHERInterrupt = 0;
((INTSTAT2 *)Addr68k_from_LADDR(*INTERRUPTSTATE_word))->handledmask = 0;
/* ((INTSTAT*)NativeAligned4FromLAddr(*INTERRUPTSTATE_word))->ETHERInterrupt = 0;
((INTSTAT2 *)NativeAligned4FromLAddr(*INTERRUPTSTATE_word))->handledmask = 0;
*/
if (ether_fd < 0) {
@@ -1107,7 +1107,7 @@ LispPTR check_sum(LispPTR *args)
DLword *address;
int nwords;
address = (DLword *)Addr68k_from_LADDR(*args++);
address = (DLword *)NativeAligned2FromLAddr(*args++);
nwords = *args++;
if (*args != NIL)

2
src/findkey.c
View File

@@ -45,7 +45,7 @@ LispPTR N_OP_findkey(LispPTR tos, int byte) {
#endif
if (CURRENTFX->alink & 1) { /* slow case */
find_end = (DLword *)Addr68k_from_LADDR(STK_OFFSET | (CURRENTFX->blink - 4));
find_end = (DLword *)NativeAligned2FromLAddr(STK_OFFSET | (CURRENTFX->blink - 4));
} else { /* Fast cae */
find_end = ((DLword *)CURRENTFX) - 2 - 4;
}

63
src/foreign.c
View File

@@ -18,6 +18,7 @@
#include <stdio.h>
#include <sys/param.h>
#include "byteswapdefs.h"
#include "dld.h"
#include "lispemul.h"
#include "lspglob.h"
@@ -48,20 +49,20 @@
short *sbase; \
int i; \
\
arrayp = (OneDArray *)(Addr68k_from_LADDR((unsigned int)Lisp)); \
arrayp = (OneDArray *)(NativeAligned4FromLAddr((unsigned int)Lisp)); \
Len = min(MaxLen, arrayp->fillpointer); \
\
switch (arrayp->typenumber) { \
case THIN_CHAR_TYPENUMBER: \
base = \
((char *)(Addr68k_from_LADDR((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
((char *)(NativeAligned2FromLAddr((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
for (i = 0; i < Len; i++) C[i] = base[i]; \
C[Len] = '\0'; \
break; \
\
case FAT_CHAR_TYPENUMBER: \
sbase = \
((short *)(Addr68k_from_LADDR((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
((short *)(NativeAligned2FromLAddr((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
base = (char *)sbase; \
for (i = 0; i < Len * 2; i++) C[i] = base[i]; \
C[Len * 2] = '\0'; \
@@ -122,7 +123,7 @@ LispPTR call_c_fn(LispPTR *args) {
ByteCode *pc;
/* Initialize the variables from the descriptorblock */
descriptorblock = (int *)Addr68k_from_LADDR(args[0]);
descriptorblock = (int *)NativeAligned4FromLAddr(args[0]);
fnaddr = *descriptorblock++;
resulttype = *descriptorblock++;
errorflag = descriptorblock++;
@@ -146,7 +147,7 @@ LispPTR call_c_fn(LispPTR *args) {
int *tracedesc;
printf("Start Foreign function call=====\n");
tracedesc = (int *)Addr68k_from_LADDR(args[0]);
tracedesc = (int *)NativeAligned4FromLAddr(args[0]);
printf("fnaddr: %d\n", *tracedesc++);
printf("resulttype: %d\n", *tracedesc++);
printf("errorflag: %d\n", *tracedesc++);
@@ -196,7 +197,7 @@ LispPTR call_c_fn(LispPTR *args) {
case TYPE_LITATOM:
case TYPE_NEWATOM:
if (expectedtype == TYPE_LITATOM) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -204,7 +205,7 @@ LispPTR call_c_fn(LispPTR *args) {
break;
case TYPE_LISTP:
if (expectedtype == TYPE_LISTP) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -212,7 +213,7 @@ LispPTR call_c_fn(LispPTR *args) {
break;
case TYPE_ARRAYP:
if (expectedtype == TYPE_ARRAYP) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -244,7 +245,7 @@ LispPTR call_c_fn(LispPTR *args) {
break;
case TYPE_BITMAP:
if (expectedtype == TYPE_BITMAP) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -253,7 +254,7 @@ LispPTR call_c_fn(LispPTR *args) {
case TYPE_COMPILED_CLOSURE: break;
case TYPE_ONED_ARRAY:
if (expectedtype == TYPE_ONED_ARRAY) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -261,7 +262,7 @@ LispPTR call_c_fn(LispPTR *args) {
break;
case TYPE_TWOD_ARRAY:
if (expectedtype == TYPE_TWOD_ARRAY) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -269,7 +270,7 @@ LispPTR call_c_fn(LispPTR *args) {
break;
case TYPE_GENERAL_ARRAY:
if (expectedtype == TYPE_GENERAL_ARRAY) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -277,7 +278,7 @@ LispPTR call_c_fn(LispPTR *args) {
break;
case TYPE_BIGNUM:
if (expectedtype == TYPE_BIGNUM) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -285,7 +286,7 @@ LispPTR call_c_fn(LispPTR *args) {
break;
case TYPE_RATIO:
if (expectedtype == TYPE_RATIO) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -293,7 +294,7 @@ LispPTR call_c_fn(LispPTR *args) {
break;
case TYPE_COMPLEX:
if (expectedtype == TYPE_COMPLEX) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -315,7 +316,7 @@ LispPTR call_c_fn(LispPTR *args) {
intarg[20], intarg[21], intarg[22], intarg[23], intarg[24], intarg[25],
intarg[26], intarg[27], intarg[28], intarg[29], intarg[30], intarg[31]);
caller = (FX2 *)CURRENTFX; /* Don't return values, just continue. */
fnhead = (struct fnhead *)Addr68k_from_LADDR(POINTERMASK & swapx((int)caller->fnheader));
fnhead = (struct fnhead *)NativeAligned4FromLAddr(POINTERMASK & swapx((int)caller->fnheader));
pc = (ByteCode *)fnhead + (caller->pc);
break;
case TYPE_SMALLP:
@@ -348,7 +349,7 @@ LispPTR call_c_fn(LispPTR *args) {
intarg[27], intarg[28], intarg[29], intarg[30], intarg[31]);
fword = createcell68k(TYPE_FLOATP);
*((float *)fword) = fresult;
return (LADDR_from_68k(fword));
return (LAddrFromNative(fword));
break;
default: *errorflag = -2; break;
}
@@ -402,7 +403,7 @@ LispPTR smashing_c_fn(LispPTR *args) {
ByteCode *pc;
/* Initialize the variables from the descriptorblock */
descriptorblock = (int *)Addr68k_from_LADDR(args[0]);
descriptorblock = (int *)NativeAligned4FromLAddr(args[0]);
fnaddr = *descriptorblock++;
resulttype = *descriptorblock++;
errorflag = descriptorblock++;
@@ -412,7 +413,7 @@ LispPTR smashing_c_fn(LispPTR *args) {
*errorflag = 0;
/* Initialize the valueplace */
valueplace = (int *)Addr68k_from_LADDR(args[1]);
valueplace = (int *)NativeAligned4FromLAddr(args[1]);
/* Initialize the argvector */
for (i = 0; i < Max_Arg; i++) { intarg[i] = 0; };
@@ -463,7 +464,7 @@ LispPTR smashing_c_fn(LispPTR *args) {
case TYPE_LITATOM:
case TYPE_NEWATOM:
if (expectedtype == TYPE_LITATOM) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -471,7 +472,7 @@ LispPTR smashing_c_fn(LispPTR *args) {
break;
case TYPE_LISTP:
if (expectedtype == TYPE_LISTP) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -479,7 +480,7 @@ LispPTR smashing_c_fn(LispPTR *args) {
break;
case TYPE_ARRAYP:
if (expectedtype == TYPE_ARRAYP) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -511,7 +512,7 @@ LispPTR smashing_c_fn(LispPTR *args) {
break;
case TYPE_BITMAP:
if (expectedtype == TYPE_BITMAP) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -520,7 +521,7 @@ LispPTR smashing_c_fn(LispPTR *args) {
case TYPE_COMPILED_CLOSURE: break;
case TYPE_ONED_ARRAY:
if (expectedtype == TYPE_ONED_ARRAY) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -528,7 +529,7 @@ LispPTR smashing_c_fn(LispPTR *args) {
break;
case TYPE_TWOD_ARRAY:
if (expectedtype == TYPE_TWOD_ARRAY) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -536,7 +537,7 @@ LispPTR smashing_c_fn(LispPTR *args) {
break;
case TYPE_GENERAL_ARRAY:
if (expectedtype == TYPE_GENERAL_ARRAY) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -544,7 +545,7 @@ LispPTR smashing_c_fn(LispPTR *args) {
break;
case TYPE_BIGNUM:
if (expectedtype == TYPE_BIGNUM) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -552,7 +553,7 @@ LispPTR smashing_c_fn(LispPTR *args) {
break;
case TYPE_RATIO:
if (expectedtype == TYPE_RATIO) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -560,7 +561,7 @@ LispPTR smashing_c_fn(LispPTR *args) {
break;
case TYPE_COMPLEX:
if (expectedtype == TYPE_COMPLEX) {
intarg[j] = *(int *)Addr68k_from_LADDR(args[i]);
intarg[j] = *(int *)NativeAligned4FromLAddr(args[i]);
} else {
*errorflag = i;
return (NIL);
@@ -582,7 +583,7 @@ LispPTR smashing_c_fn(LispPTR *args) {
intarg[20], intarg[21], intarg[22], intarg[23], intarg[24], intarg[25],
intarg[26], intarg[27], intarg[28], intarg[29], intarg[30], intarg[31]);
caller = (FX2 *)CURRENTFX; /* Don't return values, just continue. */
fnhead = (struct fnhead *)Addr68k_from_LADDR(POINTERMASK & swapx((int)caller->fnheader));
fnhead = (struct fnhead *)NativeAligned4FromLAddr(POINTERMASK & swapx((int)caller->fnheader));
pc = (ByteCode *)fnhead + (caller->pc);
break;
case TYPE_SMALLP:
@@ -928,7 +929,7 @@ int get_c_basebyte(LispPTR *args) {
case 4: /* float */
fword = createcell68k(TYPE_FLOATP);
*((float *)fword) = *(float *)((addr & 0xFFFFFFFE) + (offset << 2));
return (LADDR_from_68k(fword));
return (LAddrFromNative(fword));
break;
}
}

10
src/fp.c
View File

@@ -17,7 +17,7 @@
/* */
/************************************************************************/
#include "adr68k.h" // for LADDR_from_68k
#include "adr68k.h" // for LAddrFromNative
#include "emlglob.h"
#include "fpdefs.h" // for N_OP_fdifference, N_OP_fgreaterp, N_OP_fplus2
#include "lispemul.h" // for state, LispPTR, DLword, ERROR_EXIT, ATOM_T
@@ -56,7 +56,7 @@ LispPTR N_OP_fplus2(LispPTR parg1, LispPTR parg2) {
if (FPTEST(result)) ERROR_EXIT(parg2);
wordp = createcell68k(TYPE_FLOATP);
*((float *)wordp) = result;
return (LADDR_from_68k(wordp));
return (LAddrFromNative(wordp));
} /* end N_OP_fplus2() */
/************************************************************************/
@@ -79,7 +79,7 @@ LispPTR N_OP_fdifference(LispPTR parg1, LispPTR parg2) {
if (FPTEST(result)) ERROR_EXIT(parg2);
wordp = createcell68k(TYPE_FLOATP);
*((float *)wordp) = result;
return (LADDR_from_68k(wordp));
return (LAddrFromNative(wordp));
} /* end N_OP_fdifference() */
/************************************************************************/
@@ -102,7 +102,7 @@ LispPTR N_OP_ftimes2(LispPTR parg1, LispPTR parg2) {
if (FPTEST(result)) ERROR_EXIT(parg2);
wordp = createcell68k(TYPE_FLOATP);
*((float *)wordp) = result;
return (LADDR_from_68k(wordp));
return (LAddrFromNative(wordp));
} /* end N_OP_ftimes2() */
/************************************************************************/
@@ -126,7 +126,7 @@ LispPTR N_OP_fquotient(LispPTR parg1, LispPTR parg2) {
if (FPTEST(result)) ERROR_EXIT(parg2);
wordp = createcell68k(TYPE_FLOATP);
*((float *)wordp) = result;
return (LADDR_from_68k(wordp));
return (LAddrFromNative(wordp));
} /* end N_OP_fquotient() */
/************************************************************************/

22
src/fvar.c
View File

@@ -9,7 +9,7 @@
#include "version.h"
#include "adr68k.h" // for Addr68k_from_LADDR, LADDR_from_68k
#include "adr68k.h" // for NativeAligned4FromLAddr, NativeAligned2FromLAddr, LAddrFromNative
#include "byteswapdefs.h" // for swapx
#include "commondefs.h" // for error
#include "emlglob.h"
@@ -118,15 +118,15 @@ newframe:
if (newpfra2->validnametable) /* check VALIDNAMETABLE */
#ifdef BIGVM
newpfn2 = (struct fnhead *)(Addr68k_from_LADDR(newpfra2->nametable));
newpfn2 = (struct fnhead *)NativeAligned4FromLAddr(newpfra2->nametable);
else
newpfn2 = (struct fnhead *)(Addr68k_from_LADDR(newpfra2->fnheader));
newpfn2 = (struct fnhead *)NativeAligned4FromLAddr(newpfra2->fnheader);
#else
newpfn2 = (struct fnhead *)(Addr68k_from_LADDR(
((newpfra2->hi2nametable) << 16 | newpfra2->lonametable)));
newpfn2 = (struct fnhead *)NativeAligned4FromLAddr(
((newpfra2->hi2nametable) << 16 | newpfra2->lonametable));
else
newpfn2 = (struct fnhead *)(Addr68k_from_LADDR(
((newpfra2->hi2fnheader) << 16 | newpfra2->lofnheader)));
newpfn2 = (struct fnhead *)NativeAligned4FromLAddr(
((newpfra2->hi2fnheader) << 16 | newpfra2->lofnheader));
#endif /* BIGVM */
pindex = (NAMETABLE *)((DLword *)newpfn2 + FNHEADSIZE);
/* now pindex points 1st word of Nametable. */
@@ -222,7 +222,7 @@ newframe:
case 3 : goto cont4; */
}
GETBASEWORD(achain, 1) = STK_HI;
GETBASEWORD(achain, 0) = 0xFFFF & LADDR_from_68k(ppvar);
GETBASEWORD(achain, 0) = 0xFFFF & LAddrFromNative(ppvar);
/* save High word of PVAR slot address to FVAR slot */
/* achain points to target FVAR slot */
return;
@@ -306,7 +306,7 @@ LispPTR N_OP_fvarn(int n)
}
return (GetLongWord(
Addr68k_from_LADDR(POINTERMASK & (((GETBASEWORD(chain, 1)) << 16) | GETBASEWORD(chain, 0)))));
NativeAligned4FromLAddr(POINTERMASK & (((GETBASEWORD(chain, 1)) << 16) | GETBASEWORD(chain, 0)))));
}
/******************************************************************************
@@ -351,7 +351,7 @@ LispPTR N_OP_fvar_(LispPTR tos, int n) {
nfvlookup(CURRENTFX, ppvar, FuncObj);
}
pfreeval = Addr68k_from_LADDR(MaskShift((GETWORD(ppvar + 1))) | GETWORD(ppvar));
pfreeval = NativeAligned2FromLAddr(MaskShift((GETWORD(ppvar + 1))) | GETWORD(ppvar));
if (((0xFF & GETWORD(ppvar + 1)) != STK_HI)) {
GCLOOKUP(*((LispPTR *)pfreeval), DELREF);
@@ -480,7 +480,7 @@ LispPTR native_newframe(int slot)
}
/* save High word of PVAR slot address to FVAR slot */
/* achain points to target FVAR slot */
return (*((LispPTR *)achain) = STK_HI_RET(LADDR_from_68k(ppvar)));
return (*((LispPTR *)achain) = STK_HI_RET(LAddrFromNative(ppvar)));
case FVFVARHI: /* 0xC000 or 0xC0000000(NEWATOM S) */
ppvar = FRAMESIZE + (DLword *)newpfra2 + fvaroffset;
if (WBITSPTR(ppvar)->LSB) { goto endlookfor; }

26
src/gcarray.c
View File

@@ -44,7 +44,7 @@
#include <stdio.h> // for printf
#include <string.h> // for strncmp
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned2FromLAddr, NativeAligned4FromLAddr
#include "array.h" // for arrayheader
#include "car-cdrdefs.h" // for car, cdr
#include "cell.h" // for PNCell, PLCell, GetPnameCell, GetPropCell
@@ -102,7 +102,7 @@ LispPTR aref1(LispPTR array, int index) {
short typenumber;
struct arrayheader *actarray;
actarray = (struct arrayheader *)Addr68k_from_LADDR(array);
actarray = (struct arrayheader *)NativeAligned4FromLAddr(array);
if (index >= actarray->totalsize) {
printf("Invalid index in GC's AREF1: 0x%x\n", index);
printf(" Array size limit: 0x%x\n", actarray->totalsize);
@@ -119,14 +119,14 @@ LispPTR aref1(LispPTR array, int index) {
base = actarray->base;
switch (typenumber) {
case 3: /* unsigned 8bits */
retval = (GETBYTE(((char *)Addr68k_from_LADDR(base)) + index)) & 0x0ff;
retval = (GETBYTE(((char *)NativeAligned2FromLAddr(base)) + index)) & 0x0ff;
retval |= S_POSITIVE;
break;
case 4: /* unsigned 16bits */
retval = (GETWORD(((DLword *)Addr68k_from_LADDR(base)) + index)) & 0x0ffff;
retval = (GETWORD(((DLword *)NativeAligned2FromLAddr(base)) + index)) & 0x0ffff;
retval |= S_POSITIVE;
break;
case 38: retval = (*(((LispPTR *)Addr68k_from_LADDR(base)) + index)); break;
case 38: retval = (*(((LispPTR *)NativeAligned4FromLAddr(base)) + index)); break;
default: error("Not Implemented in gc's aref1 (other types)");
};
return (retval);
@@ -165,7 +165,7 @@ LispPTR find_symbol(const char *char_base, DLword offset, DLword length, LispPTR
hashval = compute_hash(char_base, offset, length);
ehashval = Entry_hash(length, hashval);
hashtbladdr = (struct hashtable *)Addr68k_from_LADDR(hashtbl);
hashtbladdr = (struct hashtable *)NativeAligned4FromLAddr(hashtbl);
/* Move our string ptr up by offset, allowing for fatness */
if (fatp)
@@ -183,7 +183,7 @@ loop_thru_hashtables:
vecs = cdr(vecs);
hash = car(hashes);
hashes = cdr(hashes);
vec68k = (struct arrayheader *)Addr68k_from_LADDR(vec);
vec68k = (struct arrayheader *)NativeAligned4FromLAddr(vec);
arraylen = vec68k->totalsize;
if (arraylen == 0) return (0xffffffff); /*kludge TAKE*/
h2 = Rehash_factor(hashval, arraylen);
@@ -191,7 +191,7 @@ loop_thru_hashtables:
#else
vec = hashtbladdr->table;
hash = hashtbladdr->hash;
vec68k = (struct arrayheader *)Addr68k_from_LADDR(vec);
vec68k = (struct arrayheader *)NativeAligned4FromLAddr(vec);
arraylen = vec68k->totalsize;
if (arraylen == 0) return (0xffffffff); /*kludge TAKE*/
h2 = Rehash_factor(hashval, arraylen);
@@ -222,7 +222,7 @@ retry:
pnptr = (PNCell *)GetPnameCell(index);
fatpnamep = ((PLCell *)GetPropCell(index))->fatpnamep;
pname_base = (char *)Addr68k_from_LADDR(pnptr->pnamebase);
pname_base = (char *)NativeAligned2FromLAddr(pnptr->pnamebase);
if ((length == GETBYTE(pname_base)) &&
(T == ((lispp) ? compare_lisp_chars((pname_base + 1 + fatpnamep), char_base, length,
fatpnamep, fatp)
@@ -277,8 +277,8 @@ LispPTR get_package_atom(const char *char_base, DLword charlen, const char *pack
}
/* if (packindex != 7) Not necessary (Take)*/
packaddr = (PACKAGE *)Addr68k_from_LADDR(aref1(*Package_from_Index_word, packindex));
/* else packaddr = (PACKAGE *)Addr68k_from_LADDR(
packaddr = (PACKAGE *)NativeAligned4FromLAddr(aref1(*Package_from_Index_word, packindex));
/* else packaddr = (PACKAGE *)NativeAligned4FromLAddr(
*Keyword_Package_word); */
/* hashtbladdr = ((externalp == T)?(packaddr->EXTERNAL_SYMBOLS):
(packaddr->INTERNAL_SYMBOLS));
@@ -300,8 +300,8 @@ LispPTR get_package_atom(const char *char_base, DLword charlen, const char *pack
LispPTR with_symbol(LispPTR char_base, LispPTR offset, LispPTR charlen, LispPTR fatp,
LispPTR hashtbl, LispPTR result) {
char *charbase68k = (char *)Addr68k_from_LADDR(char_base);
LispPTR *resultptr = (LispPTR *)Addr68k_from_LADDR(result);
char *charbase68k = (char *)NativeAligned2FromLAddr(char_base);
LispPTR *resultptr = (LispPTR *)NativeAligned4FromLAddr(result);
DLword chars = charlen & 0xFFFF; /* charlen must be a SMALLP! */
DLword offst = offset & 0xFFFF;
int symbol; /* Where the symbol goes pro tem */

12
src/gccode.c
View File

@@ -31,7 +31,7 @@
#include <stdio.h> // for sprintf
#include "address.h" // for LOLOC, HILOC
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned4FromLAddr
#include "commondefs.h" // for error
#include "gccodedefs.h" // for code_block_size, map_code_pointers, reclaimc...
#include "gcdata.h" // for REC_GCLOOKUP, DELREF, ADDREF
@@ -47,7 +47,7 @@
#define Reprobefn(bits, index) ((((bits) ^ ((bits) >> 8)) & min(63, index)) | 1)
#define Fn16bits(a, b) (((a) + (b)) & 0x0ffff)
#define Hashingbits(item) (HILOC(item) ^ (((LOLOC(item) & 0x1fff) << 3) ^ (LOLOC(item) >> 9)))
#define Getikvalue(base, index) (*(LispPTR *)Addr68k_from_LADDR((base) + ((index) << 1)))
#define Getikvalue(base, index) (*(LispPTR *)NativeAligned4FromLAddr((base) + ((index) << 1)))
#ifndef BYTESWAP
typedef struct implicit_key_hash_table {
@@ -125,7 +125,7 @@ LispPTR map_code_pointers(LispPTR codeblock, short int casep) {
unsigned int opnum;
unsigned int len;
struct fnhead *fnbase;
fnbase = (struct fnhead *)Addr68k_from_LADDR(codeblock);
fnbase = (struct fnhead *)NativeAligned4FromLAddr(codeblock);
codeptr = ((InstPtr)fnbase) + fnbase->startpc;
#ifdef RESWAPPEDCODESTREAM
@@ -177,12 +177,12 @@ LispPTR map_code_pointers(LispPTR codeblock, short int casep) {
/* JRB - These values are xpointers; their high bytes are not set and
shouldn't be looked at */
#define getikkey(value) ((*(LispPTR *)Addr68k_from_LADDR(value)) & POINTERMASK)
#define getikkey(value) ((*(LispPTR *)NativeAligned4FromLAddr(value)) & POINTERMASK)
LispPTR remimplicitkeyhash(LispPTR item, LispPTR ik_hash_table) {
Ikhashtbl *ik_htable;
LispPTR reprobe, bits, limits, index, base, value;
ik_htable = (Ikhashtbl *)Addr68k_from_LADDR(ik_hash_table);
ik_htable = (Ikhashtbl *)NativeAligned4FromLAddr(ik_hash_table);
bits = Hashingbits(item);
limits = ik_htable->last_index;
index = (bits & limits);
@@ -236,7 +236,7 @@ LispPTR reclaimcodeblock(LispPTR codebase) {
(remimplicitkeyhash(codebase, *Closure_Cache_word) != NIL)) {
return (T);
};
fnbase = (struct fnhead *)Addr68k_from_LADDR(codebase);
fnbase = (struct fnhead *)NativeAligned4FromLAddr(codebase);
REC_GCLOOKUP((POINTERMASK & fnbase->framename), DELREF);
if (fnbase->startpc != 0) map_code_pointers(codebase, DELREF);
return (NIL);

68
src/gcfinal.c
View File

@@ -44,7 +44,7 @@
#include <stdio.h> // for printf
#include "address.h" // for HILOC
#include "adr68k.h" // for Addr68k_from_LADDR, LADDR_from_68k, Addr68k...
#include "adr68k.h" // for NativeAligned4FromLAddr, LAddrFromNative
#include "array.h" // for arrayblock, ARRAYBLOCKTRAILERCELLS, MAXBUCK...
#include "commondefs.h" // for error
#include "gccodedefs.h" // for reclaimcodeblock
@@ -140,12 +140,12 @@ int integerlength(unsigned int n) {
LispPTR findptrsbuffer(LispPTR ptr) {
struct buf *bptr;
bptr = (struct buf *)Addr68k_from_LADDR(*System_Buffer_List_word);
while (LADDR_from_68k(bptr) != NIL) {
bptr = (struct buf *)NativeAligned4FromLAddr(*System_Buffer_List_word);
while (LAddrFromNative(bptr) != NIL) {
if (ptr == bptr->vmempage)
return (LADDR_from_68k(bptr));
return (LAddrFromNative(bptr));
else
bptr = (struct buf *)Addr68k_from_LADDR(bptr->sysnext);
bptr = (struct buf *)NativeAligned4FromLAddr(bptr->sysnext);
};
return (NIL);
}
@@ -167,7 +167,7 @@ LispPTR releasingvmempage(LispPTR ptr) {
if (bufferptr == NIL) return (NIL); /* Not in use, OK to reclaim it */
bptr = (struct buf *)Addr68k_from_LADDR(bufferptr);
bptr = (struct buf *)NativeAligned4FromLAddr(bufferptr);
bptr->noreference = T; /* Mark the buffer free to use ?? */
return (ATOM_T);
}
@@ -191,10 +191,10 @@ LispPTR checkarrayblock(LispPTR base, LispPTR free, LispPTR onfreelist) {
if (*Array_Block_Checking_word != NIL)
#endif
{
bbase = (struct arrayblock *)Addr68k_from_LADDR(base);
btrailer = (struct arrayblock *)Addr68k_from_LADDR(Trailer(base, bbase));
bfwd = (struct arrayblock *)Addr68k_from_LADDR(bbase->fwd);
bbwd = (struct arrayblock *)Addr68k_from_LADDR(bbase->bkwd);
bbase = (struct arrayblock *)NativeAligned4FromLAddr(base);
btrailer = (struct arrayblock *)NativeAligned4FromLAddr(Trailer(base, bbase));
bfwd = (struct arrayblock *)NativeAligned4FromLAddr(bbase->fwd);
bbwd = (struct arrayblock *)NativeAligned4FromLAddr(bbase->bkwd);
if (bbase->password != ARRAYBLOCKPASSWORD) {
printarrayblock(base);
error("ARRAYBLOCK password wrong\n");
@@ -220,13 +220,13 @@ LispPTR checkarrayblock(LispPTR base, LispPTR free, LispPTR onfreelist) {
error("ARRAYBLOCK links fouled\n");
} else {
fbl = FreeBlockChainN(bbase->arlen);
rover = tmprover = (LispPTR *)Addr68k_from_LADDR(fbl);
rover = tmprover = (LispPTR *)NativeAligned4FromLAddr(fbl);
/* GETBASEPTR */
if ((*rover & POINTERMASK) == NIL) error("Free Block's bucket empty\n");
do {
if ((*rover & POINTERMASK) == base) return (NIL);
checkarrayblock((*rover & POINTERMASK), T, NIL);
rbase = (struct arrayblock *)Addr68k_from_LADDR(*rover & POINTERMASK);
rbase = (struct arrayblock *)NativeAligned4FromLAddr(*rover & POINTERMASK);
} while (((*rover = rbase->fwd) & POINTERMASK) != (*tmprover & POINTERMASK));
return (NIL);
};
@@ -246,14 +246,14 @@ LispPTR deleteblock(LispPTR base) {
struct arrayblock *bbase, *fbbase, *bbbase;
LispPTR fwd, bkwd, fbl, freeblocklsp;
LispPTR *freeblock;
bbase = (struct arrayblock *)Addr68k_from_LADDR(base);
bbase = (struct arrayblock *)NativeAligned4FromLAddr(base);
if ((bbase->arlen >= MINARRAYBLOCKSIZE) && (bbase->fwd != NIL)) {
fwd = bbase->fwd;
fbbase = (struct arrayblock *)Addr68k_from_LADDR(fwd);
fbbase = (struct arrayblock *)NativeAligned4FromLAddr(fwd);
bkwd = bbase->bkwd;
bbbase = (struct arrayblock *)Addr68k_from_LADDR(bkwd);
bbbase = (struct arrayblock *)NativeAligned4FromLAddr(bkwd);
fbl = FreeBlockChainN(bbase->arlen);
freeblock = (LispPTR *)Addr68k_from_LADDR(fbl);
freeblock = (LispPTR *)NativeAligned4FromLAddr(fbl);
freeblocklsp = POINTERMASK & *freeblock;
if (base == fwd) {
if (base == freeblocklsp)
@@ -282,21 +282,21 @@ LispPTR linkblock(LispPTR base) {
LispPTR fbl, freeblocklsp;
LispPTR *freeblock;
if (*FreeBlockBuckets_word != NIL) {
bbase = (struct arrayblock *)Addr68k_from_LADDR(base);
bbase = (struct arrayblock *)NativeAligned4FromLAddr(base);
if (bbase->arlen < MINARRAYBLOCKSIZE)
checkarrayblock(base, T, NIL);
else {
fbl = FreeBlockChainN(bbase->arlen);
freeblock = (LispPTR *)Addr68k_from_LADDR(POINTERMASK & fbl);
freeblock = (LispPTR *)NativeAligned4FromLAddr(POINTERMASK & fbl);
freeblocklsp = POINTERMASK & (*freeblock);
if (freeblocklsp == NIL) {
bbase->fwd = base;
bbase->bkwd = base;
} else {
fbbase = (struct arrayblock *)Addr68k_from_LADDR(freeblocklsp);
fbbase = (struct arrayblock *)NativeAligned4FromLAddr(freeblocklsp);
bbase->fwd = freeblocklsp;
bbase->bkwd = fbbase->bkwd;
tmpbase = (struct arrayblock *)Addr68k_from_LADDR(fbbase->bkwd);
tmpbase = (struct arrayblock *)NativeAligned4FromLAddr(fbbase->bkwd);
tmpbase->fwd = base;
fbbase->bkwd = base;
};
@@ -319,12 +319,12 @@ LispPTR makefreearrayblock(LispPTR block, DLword length) {
LispPTR trailer;
struct arrayblock *bbase;
struct abdum *dbase;
bbase = (struct arrayblock *)Addr68k_from_LADDR(block);
bbase = (struct arrayblock *)NativeAligned4FromLAddr(block);
dbase = (struct abdum *)WORDPTR(bbase);
dbase->abflags = FREEARRAYFLAGWORD;
bbase->arlen = length;
trailer = Trailer(block, bbase);
bbase = (struct arrayblock *)Addr68k_from_LADDR(trailer);
bbase = (struct arrayblock *)NativeAligned4FromLAddr(trailer);
dbase = (struct abdum *)WORDPTR(bbase);
dbase->abflags = FREEARRAYFLAGWORD;
bbase->arlen = length;
@@ -342,8 +342,8 @@ LispPTR makefreearrayblock(LispPTR block, DLword length) {
LispPTR arrayblockmerger(LispPTR base, LispPTR nbase) {
DLword arlens, narlens, secondbite, minblocksize, shaveback;
struct arrayblock *bbase, *bnbase;
bbase = (struct arrayblock *)Addr68k_from_LADDR(base);
bnbase = (struct arrayblock *)Addr68k_from_LADDR(nbase);
bbase = (struct arrayblock *)NativeAligned4FromLAddr(base);
bnbase = (struct arrayblock *)NativeAligned4FromLAddr(nbase);
arlens = bbase->arlen;
narlens = bnbase->arlen;
secondbite = MAXARRAYBLOCKSIZE - arlens;
@@ -376,7 +376,7 @@ LispPTR mergebackward(LispPTR base) {
LispPTR pbase;
struct arrayblock *ptrailer;
ptrailer = (struct arrayblock *)Addr68k_from_LADDR(base - ARRAYBLOCKTRAILERWORDS);
ptrailer = (struct arrayblock *)NativeAligned4FromLAddr(base - ARRAYBLOCKTRAILERWORDS);
if (base == NIL)
return (NIL);
else if ((*ArrayMerging_word == NIL) ||
@@ -399,9 +399,9 @@ LispPTR mergebackward(LispPTR base) {
LispPTR mergeforward(LispPTR base) {
LispPTR nbase, nbinuse;
struct arrayblock *bbase, *bnbase;
bbase = (struct arrayblock *)Addr68k_from_LADDR(base);
bbase = (struct arrayblock *)NativeAligned4FromLAddr(base);
nbase = base + 2 * (bbase->arlen);
bnbase = (struct arrayblock *)Addr68k_from_LADDR(nbase);
bnbase = (struct arrayblock *)NativeAligned4FromLAddr(nbase);
if ((*ArrayMerging_word == NIL) ||
((base == NIL) ||
(checkarrayblock(base, T, T) ||
@@ -433,7 +433,7 @@ LispPTR reclaimarrayblock(LispPTR ptr) {
checkarrayblock(ptr - ARRAYBLOCKHEADERWORDS, NIL, NIL);
#endif /* ARRAYCHECK */
base = (struct arrayblock *)Addr68k_from_LADDR(ptr - ARRAYBLOCKHEADERWORDS);
base = (struct arrayblock *)NativeAligned4FromLAddr(ptr - ARRAYBLOCKHEADERWORDS);
#ifdef ARRAYCHECK
if (HILOC(ptr) < FIRSTARRAYSEGMENT) {
printarrayblock(ptr - ARRAYBLOCKHEADERWORDS);
@@ -465,7 +465,7 @@ LispPTR reclaimarrayblock(LispPTR ptr) {
btrailer = (ptr - 2) + 2 * (base->arlen - ARRAYBLOCKTRAILERCELLS);
tmpptr = ptr;
do {
tmpp = (LispPTR *)Addr68k_from_LADDR(tmpptr);
tmpp = (LispPTR *)NativeAligned4FromLAddr(tmpptr);
/* GCLOOKUP(0x8000,DELREF, *tmpp);*/ /* added 8-Oct-87 TT */
REC_GCLOOKUP(*tmpp, DELREF);
*tmpp = NIL;
@@ -496,8 +496,8 @@ LispPTR reclaimstackp(LispPTR ptr) /* This is the entry function */
{
STACKP *stkp;
FX *fxp;
stkp = (STACKP *)Addr68k_from_LADDR(ptr);
fxp = (FX *)Addr68k_from_StkOffset(stkp->edfxp);
stkp = (STACKP *)NativeAligned4FromLAddr(ptr);
fxp = (FX *)NativeAligned4FromStackOffset(stkp->edfxp);
decusecount68k(fxp); /* decrement the use-count for the frame it uses */
return (NIL); /* and let the normal reclaimer reclaim it */
}
@@ -516,9 +516,9 @@ void printarrayblock(LispPTR base) {
LispPTR pbase, nbase;
bbase = (struct arrayblock *)Addr68k_from_LADDR(base);
btrailer = (struct arrayblock *)Addr68k_from_LADDR(Trailer(base, bbase));
ptrailer = (struct arrayblock *)Addr68k_from_LADDR(base - ARRAYBLOCKTRAILERWORDS);
bbase = (struct arrayblock *)NativeAligned4FromLAddr(base);
btrailer = (struct arrayblock *)NativeAligned4FromLAddr(Trailer(base, bbase));
ptrailer = (struct arrayblock *)NativeAligned4FromLAddr(base - ARRAYBLOCKTRAILERWORDS);
nbase = base + 2 * bbase->arlen;
pbase = base - 2 * ptrailer->arlen;

6
src/gchtfind.c
View File

@@ -11,7 +11,7 @@
#include "version.h"
#include "address.h" // for LOLOC
#include "adr68k.h" // for LADDR_from_68k
#include "adr68k.h" // for LAddrFromNative
#include "commondefs.h" // for error
#include "gcdata.h" // for GETGC, GCENTRY, ADDREF, DELREF, gc_ovfl
#include "gchtfinddefs.h" // for enter_big_reference_count, htfind, modify_...
@@ -234,9 +234,9 @@ void enter_big_reference_count(LispPTR ptr) {
};
if (tmp == NIL) {
if (Evenp(LADDR_from_68k(oventry + 1), DLWORDSPER_PAGE)) {
if (Evenp(LAddrFromNative(oventry + 1), DLWORDSPER_PAGE)) {
if ((UNSIGNED)oventry + 1 >= (UNSIGNED)HTcoll) error("GC big reference count table overflow");
newpage(LADDR_from_68k(oventry + 1));
newpage(LAddrFromNative(oventry + 1));
}
}

14
src/gcmain3.c
View File

@@ -35,7 +35,7 @@
#include <stdio.h> // for sprintf
#include "address.h" // for VAG2
#include "adr68k.h" // for Addr68k_from_LADDR, Addr68k_from_StkOffset
#include "adr68k.h" // for NativeAligned4FromLAddr, NativeAligned2FromStackOffset
#include "commondefs.h" // for error
#include "emlglob.h"
#include "gcdata.h" // for GCENTRY, REC_GCLOOKUP, STKREF, hashentry
@@ -189,8 +189,8 @@ LispPTR gcscanstack(void) {
scanptr = VAG2(STK_HI, InterfacePage->stackbase);
scanend = VAG2(STK_HI, InterfacePage->endofstack);
scanend68K = (UNSIGNED)Addr68k_from_LADDR(scanend);
basicframe = (Bframe *)Addr68k_from_LADDR(scanptr);
scanend68K = (UNSIGNED)NativeAligned2FromLAddr(scanend);
basicframe = (Bframe *)NativeAligned4FromLAddr(scanptr);
if (0 != (3 & (UNSIGNED)basicframe)) {
char debugStr[100];
@@ -218,7 +218,7 @@ LispPTR gcscanstack(void) {
fn_head = (LispPTR)VAG2(frameex->hi2fnheader, frameex->lofnheader);
#endif /* BIGVM */
Stkref(fn_head);
fnheader = (struct fnhead *)Addr68k_from_LADDR(fn_head);
fnheader = (struct fnhead *)NativeAligned4FromLAddr(fn_head);
};
{
int pcou;
@@ -238,7 +238,7 @@ LispPTR gcscanstack(void) {
UNSIGNED next;
UNSIGNED ntend;
next = qtemp = (UNSIGNED)Addr68k_from_StkOffset(frameex->nextblock);
next = qtemp = (UNSIGNED)NativeAligned2FromStackOffset(frameex->nextblock);
/* this is offset */
ntend = 0; /* init flag */
if (frameex->validnametable) {
@@ -256,9 +256,9 @@ LispPTR gcscanstack(void) {
if (STK_HI == hi2nametable) {
Stkref(fnheader->framename);
#ifdef BIGVM
qtemp = (UNSIGNED)Addr68k_from_StkOffset(nametable & 0xFFFF);
qtemp = (UNSIGNED)NativeAligned2FromStackOffset(nametable & 0xFFFF);
#else
qtemp = (UNSIGNED)Addr68k_from_StkOffset(lonametable);
qtemp = (UNSIGNED)NativeAligned2FromStackOffset(lonametable);
#endif
ntend = (UNSIGNED)(((DLword *)qtemp) + FNHEADSIZE +
(((struct fnhead *)qtemp)->ntsize) * 2);

10
src/gcr.c
View File

@@ -53,7 +53,7 @@
#include "version.h"
#include "address.h" // for LOLOC
#include "adr68k.h" // for Addr68k_from_LADDR, LADDR_from_68k
#include "adr68k.h" // for NativeAligned4FromLAddr, LAddrFromNative
#include "commondefs.h" // for error
#include "dspsubrsdefs.h" // for flip_cursor
#include "emlglob.h"
@@ -93,7 +93,7 @@ struct interruptstate {
void gcarrangementstack(void) {
LispPTR tmpnextblock;
PushCStack;
tmpnextblock = LADDR_from_68k(CurrentStackPTR += DLWORDSPER_CELL);
tmpnextblock = LAddrFromNative(CurrentStackPTR += DLWORDSPER_CELL);
CURRENTFX->nextblock = LOLOC(tmpnextblock);
if ((UNSIGNED)EndSTKP == (UNSIGNED)CurrentStackPTR) error("creating 0-long stack block.");
GETWORD(CurrentStackPTR) = STK_FSB_WORD;
@@ -138,11 +138,11 @@ void disablegc1(int noerror) {
struct interruptstate *gcinterruptstate;
int count, i;
DLword typeword;
gcinterruptstate = (struct interruptstate *)Addr68k_from_LADDR(*INTERRUPTSTATE_word);
gcinterruptstate = (struct interruptstate *)NativeAligned4FromLAddr(*INTERRUPTSTATE_word);
count = (128) * 256; /* This is test value. 128 is *MdsTTsize(\MDSTTsize) */
for (i = 0; i < count; i++) {
typeword = GETWORD((DLword *)Addr68k_from_LADDR(LADDR_from_68k(MDStypetbl) + i));
GETWORD((DLword *)Addr68k_from_LADDR(LADDR_from_68k(MDStypetbl) + i)) = (typeword | TT_NOREF);
typeword = GETWORD((DLword *)NativeAligned2FromLAddr(LAddrFromNative(MDStypetbl) + i));
GETWORD((DLword *)NativeAligned2FromLAddr(LAddrFromNative(MDStypetbl) + i)) = (typeword | TT_NOREF);
}
*Reclaim_cnt_word = NIL;
*ReclaimMin_word = NIL;

20
src/gcrcell.c
View File

@@ -65,7 +65,7 @@
#include <stdio.h> // for printf
#include "address.h" // for POINTER_PAGE
#include "adr68k.h" // for Addr68k_from_LADDR, Addr68k_from_LPAGE
#include "adr68k.h" // for NativeAligned4FromLAddr, NativeAligned4FromLPage
#include "car-cdrdefs.h" // for car, cdr
#include "cell.h" // for conspage, freecons, FREECONS, CDR_INDIRECT
#include "commondefs.h" // for error
@@ -130,7 +130,7 @@ LispPTR gcreccell(LispPTR cell) {
index = -1;
donext = NIL;
lp:
ptr = (ConsCell *)Addr68k_from_LADDR(tmpptr & -2);
ptr = (ConsCell *)NativeAligned4FromLAddr(tmpptr & -2);
/* # ifdef CHECK
if (refcnt(tmpptr) != 1) error("reclaiming cell w/refcnt not 1");
# endif
@@ -153,7 +153,7 @@ lp:
{
tmpcell = ptr->car_field; /* Monitor */
freelistcell(tmpptr);
ptr = (ConsCell *)Addr68k_from_LADDR(tmpcell);
ptr = (ConsCell *)NativeAligned4FromLAddr(tmpcell);
tmpptr = tmpcell;
code = ptr->cdr_code;
};
@@ -222,11 +222,11 @@ normal:
carfield = car(ptrfield);
ptrfield = cdr(ptrfield);
carfield &= 0x0ffff;
REC_GCLOOKUPV((POINTERMASK & *(LispPTR *)Addr68k_from_LADDR(tmpptr + carfield)), DELREF, val);
REC_GCLOOKUPV((POINTERMASK & *(LispPTR *)NativeAligned4FromLAddr(tmpptr + carfield)), DELREF, val);
#ifndef NEWCDRCODING
if (val != NIL) {
if (ptrfield != NIL) {
ptr = (ConsCell *)Addr68k_from_LADDR(tmpptr);
ptr = (ConsCell *)NativeAligned4FromLAddr(tmpptr);
ptr->car_field = donext;
ptr->cdr_code = ((car(ptrfield) & 0x0ffff) >> 1);
donext = tmpptr;
@@ -238,7 +238,7 @@ normal:
if (val != NIL) {
if (ptrfield != NIL) {
if ((carfield = car(ptrfield) & 0x0ffff) >> 1 < 15) {
ptr = (ConsCell *)Addr68k_from_LADDR(tmpptr);
ptr = (ConsCell *)NativeAligned4FromLAddr(tmpptr);
ptr->car_field = donext;
ptr->cdr_code = ((car(ptrfield) & 0x0ffff) >> 1);
donext = tmpptr;
@@ -253,7 +253,7 @@ normal:
#endif /* NEWCDRCODING */
};
addtofreelist:
field = (LispPTR *)Addr68k_from_LADDR(tmpptr);
field = (LispPTR *)NativeAligned4FromLAddr(tmpptr);
*field = typdtd->dtd_free;
typdtd->dtd_free = tmpptr & POINTERMASK;
#ifdef DTDDEBUG
@@ -285,7 +285,7 @@ doval:
trynext:
if (donext != NIL) {
tmpptr = donext;
ptr = (ConsCell *)Addr68k_from_LADDR(tmpptr);
ptr = (ConsCell *)NativeAligned4FromLAddr(tmpptr);
donext = (LispPTR)ptr->car_field;
index = ptr->cdr_code;
goto lp;
@@ -317,8 +317,8 @@ void freelistcell(LispPTR cell) {
ConsCell *cell68k;
unsigned int offset, prior, celloffset;
cell68k = (ConsCell *)Addr68k_from_LADDR(cell);
pbase = (struct conspage *)Addr68k_from_LPAGE(POINTER_PAGE(cell));
cell68k = (ConsCell *)NativeAligned4FromLAddr(cell);
pbase = (struct conspage *)NativeAligned4FromLPage(POINTER_PAGE(cell));
celloffset = (LispPTR)cell & 0xFF;
#ifdef NEWCDRCODING
if (celloffset < 8) error("freeing CONS cell that's really freelist ptr");

12
src/gvar2.c
View File

@@ -9,7 +9,7 @@
#include "version.h"
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned4FromLAddr
#include "cell.h" // for xpointer
#include "commondefs.h" // for error
#include "dbprint.h" // for DEBUGGER
@@ -37,11 +37,11 @@
/************************************************************************/
LispPTR N_OP_gvar_(LispPTR tos, unsigned int atom_index) {
LispPTR *pslot; /* pointer to argued GVAR slot */
LispPTR *pslot; /* Native pointer to GVAR slot of atom */
#ifdef BIGATOMS
if (0 != (atom_index & SEGMASK))
pslot = (LispPTR *)Addr68k_from_LADDR(atom_index + NEWATOM_VALUE_OFFSET);
pslot = (LispPTR *)NativeAligned4FromLAddr(atom_index + NEWATOM_VALUE_OFFSET);
else
#endif /* BIGATOMS */
@@ -70,9 +70,9 @@ LispPTR N_OP_gvar_(LispPTR tos, unsigned int atom_index) {
/************************************************************************/
LispPTR N_OP_rplptr(LispPTR tos_m_1, LispPTR tos, unsigned int alpha) {
DLword *pslot; /* pointer to argued slot (68 address) */
struct xpointer *pslot;
pslot = Addr68k_from_LADDR(tos_m_1 + alpha);
FRPLPTR(((struct xpointer *)pslot)->addr, tos);
pslot = (struct xpointer *)NativeAligned4FromLAddr(tos_m_1 + alpha);
FRPLPTR(pslot->addr, tos);
return (tos_m_1);
}

26
src/hardrtn.c
View File

@@ -23,7 +23,7 @@
*/
/********************************************************************/
#include <stdio.h> // for printf
#include "adr68k.h" // for Addr68k_from_StkOffset, StkOffset_from_68K
#include "adr68k.h" // for NativeAligned2FromStackOffset, StackOffsetFromNative
#include "commondefs.h" // for error
#include "emlglob.h"
#include "hardrtndefs.h" // for incusecount68k, slowreturn
@@ -70,14 +70,14 @@ static FX *make_FXcopy(FX *fx68k) {
#else
n = fx68k->lonametable;
#endif /* BIGVM */
if ((n <= StkOffset_from_68K(fx68k)) && (n >= fx68k->nextblock))
if ((n <= StackOffsetFromNative(fx68k)) && (n >= fx68k->nextblock))
error("hardreturn:nametable check");
}
#endif
nametbl_on_stk = T;
/* Find a free stack block */
new68k = freestackblock(size, (StackWord *)CURRENTFX,
(StkOffset_from_68K(fx68k) - DLWORDSPER_CELL) % DLWORDSPER_QUAD);
(StackOffsetFromNative(fx68k) - DLWORDSPER_CELL) % DLWORDSPER_QUAD);
} /*if end */
else
new68k = freestackblock(size, (StackWord *)CURRENTFX, -1); /* No align */
@@ -89,8 +89,8 @@ static FX *make_FXcopy(FX *fx68k) {
((Bframe *)new68k)->residual = T;
new68k = new68k + DLWORDSPER_CELL; /* now NEW points to the FX */
((FX *)new68k)->nextblock = (StkOffset_from_68K(new68k) + size) - DLWORDSPER_CELL;
retbf68k = (Bframe *)Addr68k_from_StkOffset(GETBLINK(fx68k));
((FX *)new68k)->nextblock = (StackOffsetFromNative(new68k) + size) - DLWORDSPER_CELL;
retbf68k = (Bframe *)NativeAligned4FromStackOffset(GETBLINK(fx68k));
/* Set true BFptr,not the residual */
SETBLINK(new68k, GETBLINK(fx68k));
((FX *)new68k)->usecount = 0;
@@ -107,14 +107,14 @@ static FX *make_FXcopy(FX *fx68k) {
SET_FASTP_NIL(fx68k);
/* increment use count of CLINK of returnee
because we made a copy of returnee */
incusecount68k((FX *)Addr68k_from_StkOffset(GETCLINK(fx68k)));
incusecount68k((FX *)NativeAligned4FromStackOffset(GETCLINK(fx68k)));
if (GETCLINK(fx68k) != GETALINK(fx68k)) {
incusecount68k((FX *)Addr68k_from_StkOffset(GETALINK(fx68k)));
incusecount68k((FX *)NativeAligned4FromStackOffset(GETALINK(fx68k)));
}
decusecount68k(fx68k); /* if usecon==0 -> FSB */
SETACLINK(CURRENTFX, StkOffset_from_68K(new68k));
SETACLINK(CURRENTFX, StackOffsetFromNative(new68k));
CHECK_FX((FX *)new68k);
CHECK_FX(CURRENTFX);
#ifdef STACKCHECK
@@ -149,7 +149,7 @@ int slowreturn(void) {
S_CHECK(SLOWP(CURRENTFX), "CURRENTFX not SLOWP");
/* Get returnee's FX from CURRENTFX->alink , It's SLOWP case */
returnFX = (FX *)Addr68k_from_StkOffset(CURRENTFX->alink - 11);
returnFX = (FX *)NativeAligned4FromStackOffset(CURRENTFX->alink - 11);
if ((CURRENTFX->alink & 0xFFFE) != CURRENTFX->clink) { /* ALINK != CLINK */
#ifdef STACKCHECK
@@ -158,7 +158,7 @@ int slowreturn(void) {
/* return to CLINK fx */
SETALINK(CURRENTFX, CURRENTFX->clink);
decusecount68k(returnFX);
returnFX = (FX *)Addr68k_from_StkOffset(CURRENTFX->clink - FRAMESIZE);
returnFX = (FX *)NativeAligned4FromStackOffset(CURRENTFX->clink - FRAMESIZE);
}
if (returnFX->usecount != 0) { /* COPY returnee's FX */
@@ -170,8 +170,8 @@ int slowreturn(void) {
retry: /* this is retry entry after MAKE_FXCOPY etc */
next68k = Addr68k_from_StkOffset(returnFX->nextblock);
currentBF = (Bframe *)Addr68k_from_StkOffset(CURRENTFX->blink);
next68k = NativeAligned2FromStackOffset(returnFX->nextblock);
currentBF = (Bframe *)NativeAligned4FromStackOffset(CURRENTFX->blink);
if (GETWORD(next68k) == STK_FSB_WORD) {
another:
@@ -263,7 +263,7 @@ void incusecount68k(FX *fx68k) {
if ((++(fx68k->usecount)) > MAXSAFEUSECOUNT)
error("MP9324:Stack frame use count maximum exceeded");
scanptr68k = (StackWord *)Addr68k_from_StkOffset(fx68k->nextblock);
scanptr68k = (StackWord *)NativeAligned2FromStackOffset(fx68k->nextblock);
switch (STKWORD(scanptr68k)->flags) {
case STK_NOTFLG:
while (STKWORD(scanptr68k)->flags != STK_BF)

16
src/inet.c
View File

@@ -140,7 +140,7 @@ LispPTR subr_TCP_ops(int op, LispPTR nameConn, LispPTR proto, LispPTR length, Li
case TCPsend: /* args: conn, buffer, len */
sock = LispNumToCInt(nameConn);
buffer = Addr68k_from_LADDR(proto);
buffer = NativeAligned2FromLAddr(proto);
len = LispNumToCInt(length);
DBPRINT(("sock: %d, len %d.\n", sock, len));
@@ -163,7 +163,7 @@ LispPTR subr_TCP_ops(int op, LispPTR nameConn, LispPTR proto, LispPTR length, Li
case TCPrecv: /* args: conn, buffer, maxlen */
sock = LispNumToCInt(nameConn);
buffer = Addr68k_from_LADDR(proto);
buffer = NativeAligned2FromLAddr(proto);
len = LispNumToCInt(length);
result = read(sock, buffer, len);
if (result < 0) {
@@ -238,7 +238,7 @@ LispPTR subr_TCP_ops(int op, LispPTR nameConn, LispPTR proto, LispPTR length, Li
case INETpeername: /* socket#, buffer for name string */
sock = LispNumToCInt(nameConn);
buffer = Addr68k_from_LADDR(proto);
buffer = NativeAligned2FromLAddr(proto);
ures = sizeof(addr);
getpeername(sock, (struct sockaddr *)&addr, &ures);
host = gethostbyaddr((const char *)&addr, ures, AF_INET);
@@ -248,7 +248,7 @@ LispPTR subr_TCP_ops(int op, LispPTR nameConn, LispPTR proto, LispPTR length, Li
case INETgetname: /* host addr, buffer for name string */
sock = LispNumToCInt(nameConn);
buffer = Addr68k_from_LADDR(proto);
buffer = NativeAligned2FromLAddr(proto);
ures = sizeof(addr);
addr.sin_addr.s_addr = htonl(sock);
host = gethostbyaddr((const char *)&addr, ures, 0);
@@ -282,7 +282,7 @@ LispPTR subr_TCP_ops(int op, LispPTR nameConn, LispPTR proto, LispPTR length, Li
farend.sin_family = AF_INET;
farend.sin_port = htons(LispNumToCInt(length));
farend.sin_addr.s_addr = htonl(LispNumToCInt(proto));
buffer = Addr68k_from_LADDR(bufaddr);
buffer = NativeAligned2FromLAddr(bufaddr);
buflen = LispNumToCInt(maxlen);
DBPRINT(("UDP send: socket = %d, remote-port = %d.\n", sock, farend.sin_port));
@@ -305,7 +305,7 @@ LispPTR subr_TCP_ops(int op, LispPTR nameConn, LispPTR proto, LispPTR length, Li
case UDPRecvfrom: /* fd-socket# buffer len addr-cell port-cell*/
sock = LispNumToCInt(nameConn);
buffer = Addr68k_from_LADDR(proto);
buffer = NativeAligned2FromLAddr(proto);
buflen = LispNumToCInt(length);
ures = sizeof farend;
if ((result = recvfrom(sock, buffer, buflen, 0, (struct sockaddr *)&farend, &ures)) < 0) {
@@ -320,8 +320,8 @@ LispPTR subr_TCP_ops(int op, LispPTR nameConn, LispPTR proto, LispPTR length, Li
maxlen));
/* XXX NBriggs: 12 Aug 2020 -- WHAT IS GOING ON HERE? */
*((int *)Addr68k_from_LADDR(bufaddr)) = (int)farend.sin_addr.s_addr;
*((int *)Addr68k_from_LADDR(maxlen)) = (int)farend.sin_port;
*((int *)NativeAligned4FromLAddr(bufaddr)) = (int)farend.sin_addr.s_addr;
*((int *)NativeAligned4FromLAddr(maxlen)) = (int)farend.sin_port;
#ifdef BYTESWAP
word_swap_page(buffer, (result + 3) >> 2);

54
src/initsout.c
View File

@@ -25,7 +25,7 @@
#include <string.h> // for strlen, strncpy
#include <time.h> // for time_t
#include <unistd.h> // for gethostid, getuid
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned2FromLAddr, NativeAligned4FromLAddr
#ifdef BYTESWAP
#include "byteswapdefs.h" // for word_swap_page
#endif
@@ -81,13 +81,13 @@ LispPTR *fixp_value(LispPTR *ptr) {
if (val < (S_NEGATIVE | 0xFFFF)) {
LispPTR newval = N_OP_createcell(S_POSITIVE | TYPE_FIXP);
LispPTR *newcell;
newcell = (LispPTR *)Addr68k_from_LADDR(newval);
newcell = (LispPTR *)NativeAligned4FromLAddr(newval);
*newcell = val & 0xFFFF; /* it was smallp, so fill in */
*ptr = newval;
GCLOOKUP(newval, ADDREF); /* so it has a refcount */
return ((LispPTR *)newcell);
}
return ((LispPTR *)Addr68k_from_LADDR(val));
return ((LispPTR *)NativeAligned4FromLAddr(val));
}
#else
@@ -159,7 +159,7 @@ are null terminated instead */
/* \MAIKO.NEWFAULTINIT and \MAIKO.ASSIGNBUFFERS */
if ((pwd = getpwuid(getuid())) != NULL) {
InterfacePage->usernameaddr = 0155001;
s = (char *)Addr68k_from_LADDR(InterfacePage->usernameaddr);
s = (char *)NativeAligned2FromLAddr(InterfacePage->usernameaddr);
len = (int)strlen(pwd->pw_name);
/* Lisp reserves 32 words for the BCPL String */
len = (len < 32 * BYTESPER_DLWORD) ? len : 32 * BYTESPER_DLWORD - 1;
@@ -168,7 +168,7 @@ are null terminated instead */
#ifdef BYTESWAP
/* we must swap the area we have written into, starting at 0155000 */
/* rounding up to 4-byte words */
word_swap_page(Addr68k_from_LADDR(0155000), (len + 1 + 2 + 3) / 4);
word_swap_page(NativeAligned2FromLAddr(0155000), (len + 1 + 2 + 3) / 4);
#endif
}
@@ -219,15 +219,15 @@ extern int for_makeinit;
void build_lisp_map(void) {
DLword index;
Stackspace = (DLword *)Addr68k_from_LADDR(STK_OFFSET);
Plistspace = (DLword *)Addr68k_from_LADDR(PLIS_OFFSET);
DTDspace = (DLword *)Addr68k_from_LADDR(DTD_OFFSET);
MDStypetbl = (DLword *)Addr68k_from_LADDR(MDS_OFFSET);
AtomHT = (DLword *)Addr68k_from_LADDR(ATMHT_OFFSET);
Pnamespace = (DLword *)Addr68k_from_LADDR(PNP_OFFSET);
AtomSpace = (DLword *)Addr68k_from_LADDR(ATOMS_OFFSET);
Defspace = (DLword *)Addr68k_from_LADDR(DEFS_OFFSET);
Valspace = (DLword *)Addr68k_from_LADDR(VALS_OFFSET);
Stackspace = (DLword *)NativeAligned2FromLAddr(STK_OFFSET);
Plistspace = (DLword *)NativeAligned2FromLAddr(PLIS_OFFSET);
DTDspace = (DLword *)NativeAligned2FromLAddr(DTD_OFFSET);
MDStypetbl = (DLword *)NativeAligned2FromLAddr(MDS_OFFSET);
AtomHT = (DLword *)NativeAligned2FromLAddr(ATMHT_OFFSET);
Pnamespace = (DLword *)NativeAligned2FromLAddr(PNP_OFFSET);
AtomSpace = (DLword *)NativeAligned2FromLAddr(ATOMS_OFFSET);
Defspace = (DLword *)NativeAligned2FromLAddr(DEFS_OFFSET);
Valspace = (DLword *)NativeAligned2FromLAddr(VALS_OFFSET);
DBPRINT(("Stackspace = %p.\n", (void *)Stackspace));
DBPRINT(("AtomHT = %p.\n", (void *)AtomHT));
@@ -235,21 +235,21 @@ void build_lisp_map(void) {
ListpDTD = (struct dtd *)GetDTD(TYPE_LISTP);
#ifdef BIGVM
FPtoVP = (LispPTR *)Addr68k_from_LADDR(FPTOVP_OFFSET);
FPtoVP = (LispPTR *)NativeAligned4FromLAddr(FPTOVP_OFFSET);
#else
FPtoVP = (DLword *)Addr68k_from_LADDR(FPTOVP_OFFSET);
FPtoVP = (DLword *)NativeAligned2FromLAddr(FPTOVP_OFFSET);
#endif /* BIGVM */
IOPage = (IOPAGE *)Addr68k_from_LADDR(IOPAGE_OFFSET);
InterfacePage = (IFPAGE *)Addr68k_from_LADDR(IFPAGE_OFFSET);
MiscStats = (MISCSTATS *)Addr68k_from_LADDR(MISCSTATS_OFFSET);
IOPage = (IOPAGE *)NativeAligned4FromLAddr(IOPAGE_OFFSET);
InterfacePage = (IFPAGE *)NativeAligned4FromLAddr(IFPAGE_OFFSET);
MiscStats = (MISCSTATS *)NativeAligned4FromLAddr(MISCSTATS_OFFSET);
UFNTable = (DLword *)Addr68k_from_LADDR(UFNTBL_OFFSET);
DisplayRegion = (DLword *)Addr68k_from_LADDR(DISPLAY_OFFSET);
UFNTable = (DLword *)NativeAligned2FromLAddr(UFNTBL_OFFSET);
DisplayRegion = (DLword *)NativeAligned2FromLAddr(DISPLAY_OFFSET);
HTmain = (GCENTRY *)Addr68k_from_LADDR(HTMAIN_OFFSET);
HToverflow = (GCENTRY *)Addr68k_from_LADDR(HTOVERFLOW_OFFSET);
HTbigcount = (GCENTRY *)Addr68k_from_LADDR(HTBIG_OFFSET);
HTcoll = (GCENTRY *)Addr68k_from_LADDR(HTCOLL_OFFSET);
HTmain = (GCENTRY *)NativeAligned4FromLAddr(HTMAIN_OFFSET);
HToverflow = (GCENTRY *)NativeAligned4FromLAddr(HTOVERFLOW_OFFSET);
HTbigcount = (GCENTRY *)NativeAligned4FromLAddr(HTBIG_OFFSET);
HTcoll = (GCENTRY *)NativeAligned4FromLAddr(HTCOLL_OFFSET);
/**** cache values *****/
Reclaim_cnt_word = MakeAtom68k("\\RECLAIM.COUNTDOWN");
@@ -410,12 +410,12 @@ void init_for_keyhandle(void) {
MOUSECHORDTICKS68k = MakeAtom68k("\\MOUSECHORDTICKS");
LASTUSERACTION68k = MakeAtom68k("\\LASTUSERACTION");
CLastUserActionCell68k = (LispPTR *)Addr68k_from_LADDR(*LASTUSERACTION68k & 0xffffff);
CLastUserActionCell68k = (LispPTR *)NativeAligned4FromLAddr(*LASTUSERACTION68k & 0xffffff);
DOBUFFEREDTRANSITION_index = MAKEATOM("\\DOBUFFEREDTRANSITIONS");
INTERRUPTFRAME_index = MAKEATOM("\\INTERRUPTFRAME");
CTopKeyevent = (DLword *)Addr68k_from_LADDR(*KEYBOARDEVENTQUEUE68k);
CTopKeyevent = (DLword *)NativeAligned2FromLAddr(*KEYBOARDEVENTQUEUE68k);
PERIODIC_INTERRUPT68k = MakeAtom68k("\\PERIODIC.INTERRUPT");
PERIODIC_INTERRUPT_FREQUENCY68k = MakeAtom68k("\\PERIODIC.INTERRUPT.FREQUENCY");

16
src/intcall.c
View File

@@ -10,7 +10,7 @@
#include "version.h"
#include "adr68k.h" // for StkOffset_from_68K, Addr68k_from_LADDR, Add...
#include "adr68k.h" // for StackOffsetFromNative, NativeAligned4FromLAddr
#include "cell.h" // for definition_cell, GetDEFCELL68k
#include "emlglob.h"
#include "intcalldefs.h" // for cause_interruptcall
@@ -30,11 +30,11 @@ void cause_interruptcall(unsigned int atom_index)
int rest; /* use for alignments */
CURRENTFX->nopush = T;
CURRENTFX->nextblock = StkOffset_from_68K(CurrentStackPTR) + 4;
CURRENTFX->nextblock = StackOffsetFromNative(CurrentStackPTR) + 4;
PushCStack; /* save TOS */
/* Setup IVar */
IVar = Addr68k_from_StkOffset(CURRENTFX->nextblock);
IVar = NativeAligned2FromStackOffset(CURRENTFX->nextblock);
/* Set PC to the Next Instruction and save into pre-FX */
CURRENTFX->pc = ((UNSIGNED)PC - (UNSIGNED)FuncObj);
@@ -43,7 +43,7 @@ void cause_interruptcall(unsigned int atom_index)
defcell68k = (struct definition_cell *)GetDEFCELL68k(atom_index);
/* Interrupt FN should be compiled code */
tmp_fn = (struct fnhead *)Addr68k_from_LADDR(defcell68k->defpointer);
tmp_fn = (struct fnhead *)NativeAligned4FromLAddr(defcell68k->defpointer);
/* This used to be >=, but I think that was a change from earlier,
when it was originally >. I changed it back on 2/2/98 to see
@@ -79,9 +79,9 @@ void cause_interruptcall(unsigned int atom_index)
/* Now SET new FX */
/* Make it SLOWP */
((FX *)CurrentStackPTR)->alink = StkOffset_from_68K(PVar) + 1;
((FX *)CurrentStackPTR)->blink = StkOffset_from_68K(DUMMYBF(CurrentStackPTR));
((FX *)CurrentStackPTR)->clink = StkOffset_from_68K(PVar);
((FX *)CurrentStackPTR)->alink = StackOffsetFromNative(PVar) + 1;
((FX *)CurrentStackPTR)->blink = StackOffsetFromNative(DUMMYBF(CurrentStackPTR));
((FX *)CurrentStackPTR)->clink = StackOffsetFromNative(PVar);
PVar = (DLword *)CurrentStackPTR + FRAMESIZE;
#ifdef BIGVM
((FX *)CurrentStackPTR)->fnheader = (defcell68k->defpointer);
@@ -104,6 +104,6 @@ void cause_interruptcall(unsigned int atom_index)
/* Set PC points New Function's first OPCODE */
PC = (ByteCode *)FuncObj + FuncObj->startpc;
CURRENTFX->nextblock = StkOffset_from_68K(CurrentStackPTR);
CURRENTFX->nextblock = StackOffsetFromNative(CurrentStackPTR);
MAKEFREEBLOCK(CurrentStackPTR, ((UNSIGNED)EndSTKP - (UNSIGNED)CurrentStackPTR) >> 1);
} /* end */

12
src/keyevent.c
View File

@@ -272,7 +272,7 @@ void process_io_events()
if (LogFileFd >= 0 && FD_ISSET(LogFileFd, &rfds)) { /* There's info in the log file. Tell Lisp to print it. */
flush_pty(); /* move the msg(s) to the log file */
((INTSTAT *)Addr68k_from_LADDR(*INTERRUPTSTATE_word))->LogFileIO = 1;
((INTSTAT *)NativeAligned4FromLAddr(*INTERRUPTSTATE_word))->LogFileIO = 1;
*PENDINGINTERRUPT68k = ATOM_T;
Irq_Stk_End = Irq_Stk_Check = 0;
@@ -283,10 +283,10 @@ void process_io_events()
if (FD_ISSET(i, &rfds) & FD_ISSET(i, &LispIOFds)) iflags |= 1 << i;
if (iflags) { /* There's activity on a Lisp-opened FD. Tell Lisp. */
u_int *flags;
flags = (u_int *)Addr68k_from_LADDR(*IOINTERRUPTFLAGS_word);
flags = (u_int *)NativeAligned4FromLAddr(*IOINTERRUPTFLAGS_word);
*flags = iflags;
((INTSTAT *)Addr68k_from_LADDR(*INTERRUPTSTATE_word))->IOInterrupt = 1;
((INTSTAT *)NativeAligned4FromLAddr(*INTERRUPTSTATE_word))->IOInterrupt = 1;
*PENDINGINTERRUPT68k = ATOM_T;
Irq_Stk_End = Irq_Stk_Check = 0;
@@ -501,9 +501,9 @@ void copy_cursor(int newx, int newy)
srcbpl = HARD_CURSORWIDTH;
dstbpl = displaywidth;
} else {
cursor68k = (CURSOR *)Addr68k_from_LADDR(*CURRENTCURSOR68k);
bitmap68k = (BITMAP *)Addr68k_from_LADDR(cursor68k->CUIMAGE);
srcbase = (DLword *)Addr68k_from_LADDR(bitmap68k->bmbase);
cursor68k = (CURSOR *)NativeAligned4FromLAddr(*CURRENTCURSOR68k);
bitmap68k = (BITMAP *)NativeAligned4FromLAddr(cursor68k->CUIMAGE);
srcbase = (DLword *)NativeAligned2FromLAddr(bitmap68k->bmbase);
dstbase = ColorDisplayRegion68k + (newy * DLWORD_PERLINE * COLOR_BITSPER_PIXEL);
sx = 0;
dx = newx * COLOR_BITSPER_PIXEL;

16
src/kprint.c
View File

@@ -12,7 +12,7 @@
#include <stdio.h> // for printf
#include "address.h" // for LOLOC
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned2FromLAddr, NativeAligned4FromLAddr
#include "car-cdrdefs.h" // for cdr, car
#include "emlglob.h"
#include "kprintdefs.h" // for prindatum, print, print_NEWstring, print_fixp
@@ -98,7 +98,7 @@ void prindatum(LispPTR x) {
break;
case TYPE_ONED_ARRAY:
case TYPE_GENERAL_ARRAY:
newstring = (NEWSTRINGP *)Addr68k_from_LADDR(x);
newstring = (NEWSTRINGP *)NativeAligned4FromLAddr(x);
if (newstring->stringp) {
print_NEWstring(x);
break;
@@ -148,9 +148,9 @@ void print_string(LispPTR x) {
int i;
string_point = (struct stringp *)Addr68k_from_LADDR(x);
string_point = (struct stringp *)NativeAligned4FromLAddr(x);
st_length = string_point->length;
string_base = (DLbyte *)Addr68k_from_LADDR(string_point->base);
string_base = (DLbyte *)NativeAligned2FromLAddr(string_point->base);
printf("%c", DOUBLEQUOTE); /* print %" */
@@ -178,9 +178,9 @@ void print_NEWstring(LispPTR x) {
int i;
string_point = (NEWSTRINGP *)Addr68k_from_LADDR(x);
string_point = (NEWSTRINGP *)NativeAligned4FromLAddr(x);
st_length = string_point->fillpointer;
string_base = (DLbyte *)Addr68k_from_LADDR(string_point->base);
string_base = (DLbyte *)NativeAligned2FromLAddr(string_point->base);
string_base += string_point->offset;
printf("%c", DOUBLEQUOTE); /* print %" */
@@ -204,7 +204,7 @@ void print_NEWstring(LispPTR x) {
void print_fixp(LispPTR x) {
int *addr_fixp;
addr_fixp = (int *)Addr68k_from_LADDR(x);
addr_fixp = (int *)NativeAligned4FromLAddr(x);
printf("%d", *addr_fixp);
}
@@ -219,6 +219,6 @@ void print_fixp(LispPTR x) {
void print_floatp(LispPTR x) {
float *addr_floatp;
addr_floatp = (float *)Addr68k_from_LADDR(x);
addr_floatp = (float *)NativeAligned4FromLAddr(x);
printf("%f", *addr_floatp);
}

4
src/ldsout.c
View File

@@ -18,7 +18,7 @@
#include <sys/mman.h> // for mmap
#include <sys/stat.h> // for stat, fstat
#include <unistd.h> // for lseek, read, close, getpagesize
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned2FromLAddr
#ifdef BYTESWAP
#include "byteswapdefs.h" // for word_swap_page
#endif
@@ -270,7 +270,7 @@ int sysout_loader(const char *sysout_file_name, int sys_size) {
/*
* Initialize the display (note now passing 68k address!!!)
*/
init_display2(Addr68k_from_LADDR(DISPLAY_OFFSET), 65536 * 16 * 2);
init_display2(NativeAligned2FromLAddr(DISPLAY_OFFSET), 65536 * 16 * 2);
/* read sysout file to lispworld */

16
src/lisp2c.c
View File

@@ -14,7 +14,7 @@
#include <stdio.h> // for sprintf
#include <stdlib.h> // for abs
#include "adr68k.h" // for Addr68k_from_LADDR, LADDR_from_68k
#include "adr68k.h" // for NativeAligned4FromLAddr, LAddrFromNative
#include "commondefs.h" // for error
#include "emlglob.h"
#include "lisp2cdefs.h" // for CIntToLispInt, LispIntToCInt, LispStringSimpleLength
@@ -27,14 +27,14 @@
int LispStringP(LispPTR object) {
int type;
type = ((OneDArray *)Addr68k_from_LADDR(object))->typenumber;
type = ((OneDArray *)NativeAligned4FromLAddr(object))->typenumber;
return ((type == THIN_CHAR_TYPENUMBER) || (type == FAT_CHAR_TYPENUMBER));
}
int LispStringSimpleLength(LispPTR lispstring) {
OneDArray *arrayp;
arrayp = (OneDArray *)(Addr68k_from_LADDR(lispstring));
arrayp = (OneDArray *)(NativeAligned4FromLAddr(lispstring));
return (arrayp->fillpointer);
}
@@ -44,18 +44,18 @@ void LispStringToCStr(LispPTR lispstring, char *cstring) {
short *sbase;
int i, Len;
arrayp = (OneDArray *)(Addr68k_from_LADDR((UNSIGNED)lispstring));
arrayp = (OneDArray *)(NativeAligned4FromLAddr(lispstring));
Len = arrayp->fillpointer;
switch (arrayp->typenumber) {
case THIN_CHAR_TYPENUMBER:
base = ((char *)(Addr68k_from_LADDR((UNSIGNED)arrayp->base))) + ((int)(arrayp->offset));
base = ((char *)(NativeAligned2FromLAddr(arrayp->base))) + ((int)(arrayp->offset));
for (i = 0; i < Len; i++) cstring[i] = base[i];
cstring[Len] = '\0';
break;
case FAT_CHAR_TYPENUMBER:
sbase = ((short *)(Addr68k_from_LADDR((UNSIGNED)arrayp->base))) + ((int)(arrayp->offset));
sbase = ((short *)(NativeAligned2FromLAddr(arrayp->base))) + ((int)(arrayp->offset));
base = (char *)sbase;
for (i = 0; i < Len * 2; i++) cstring[i] = base[i];
cstring[Len * 2] = '\0';
@@ -71,7 +71,7 @@ int LispIntToCInt(LispPTR lispint) {
case S_NEGATIVE: return (lispint | 0xFFFF0000); break;
default:
if (GetTypeNumber(lispint) == TYPE_FIXP) {
return (*((int *)Addr68k_from_LADDR(lispint)));
return (*((int *)NativeAligned4FromLAddr(lispint)));
} else {
char msg[200];
sprintf(msg, "Arg 0x%x isn't a lisp integer.", lispint);
@@ -88,7 +88,7 @@ LispPTR CIntToLispInt(int cint) {
LispPTR *wordp;
wordp = (LispPTR *)createcell68k(TYPE_FIXP);
*((int *)wordp) = cint;
return (LADDR_from_68k(wordp));
return (LAddrFromNative(wordp));
} else if (cint >= 0) { /* its a positive smallp! */
return (S_POSITIVE | cint);
} else { /* its a negative smallp! */

2
src/llcolor.c
View File

@@ -60,7 +60,7 @@ LispPTR cgfour_init_color_display(LispPTR color_bitmapbase) /* SUBR 0210 */ /* C
printf("You can not initialize the color screen from inside color screen. \n");
}
ColorDisplayRegion68k = Addr68k_from_LADDR(color_bitmapbase);
ColorDisplayRegion68k = NativeAligned2FromLAddr(color_bitmapbase);
Dispcolorsize =
((displaywidth * displayheight + (getpagesize() - 1)) & -getpagesize()); /* 8 bit depth */

146
src/llstk.c
View File

@@ -22,7 +22,7 @@
#include <stdio.h> // for printf, putchar
#include <string.h> // for memset
#include "address.h" // for LOLOC
#include "adr68k.h" // for Addr68k_from_StkOffset, StkOffset_from_68K
#include "adr68k.h" // for NativeAligned2FromStackOffset, StackOffsetFromNative
#include "commondefs.h" // for error, warn
#include "dbgtooldefs.h" // for sff
#include "emlglob.h"
@@ -58,17 +58,17 @@ static DLword *extendstack(void) {
if (easp < LOLOC(*LastStackAddr_word)) {
if ((easp > LOLOC(*GuardStackAddr_word)) && ((*STACKOVERFLOW_word) == NIL)) {
extended_frame = 1;
((INTSTAT *)Addr68k_from_LADDR(*INTERRUPTSTATE_word))->stackoverflow = 1;
((INTSTAT *)NativeAligned4FromLAddr(*INTERRUPTSTATE_word))->stackoverflow = 1;
*STACKOVERFLOW_word = *PENDINGINTERRUPT_word = ATOM_T;
}
newpage(STK_OFFSET | (scanptr = easp + 2));
/* I don't concern about DOLOCKPAGES */
MAKEFREEBLOCK(Addr68k_from_StkOffset(scanptr), DLWORDSPER_PAGE - 2);
MAKEFREEBLOCK(NativeAligned2FromStackOffset(scanptr), DLWORDSPER_PAGE - 2);
InterfacePage->endofstack = scanptr = easp + DLWORDSPER_PAGE;
SETUPGUARDBLOCK(Addr68k_from_StkOffset(InterfacePage->endofstack), 2);
MAKEFREEBLOCK(Addr68k_from_StkOffset(easp), 2);
return ((DLword *)Addr68k_from_StkOffset(scanptr));
SETUPGUARDBLOCK(NativeAligned2FromStackOffset(InterfacePage->endofstack), 2);
MAKEFREEBLOCK(NativeAligned2FromStackOffset(easp), 2);
return ((DLword *)NativeAligned4FromStackOffset(scanptr));
} else
return (NIL);
} /* end extendstack */
@@ -94,7 +94,7 @@ static LispPTR moveframe(FX *oldfx68k) {
size = FX_size(oldfx68k) + DLWORDSPER_CELL;
S_CHECK(size > 0, "size of stack block < 0");
next68k = Addr68k_from_StkOffset(oldfx68k->nextblock);
next68k = NativeAligned2FromStackOffset(oldfx68k->nextblock);
tryfsb:
if (FSBP(next68k)) {
@@ -105,8 +105,8 @@ tryfsb:
FSB_size(next68k) += FSB_size(new68k);
new68k = (DLword *)oldfx68k;
goto out;
} else if (StkOffset_from_68K(new68k) == InterfacePage->endofstack) {
if ((StkOffset_from_68K(new68k) > LOLOC(*GuardStackAddr_word)) &&
} else if (StackOffsetFromNative(new68k) == InterfacePage->endofstack) {
if ((StackOffsetFromNative(new68k) > LOLOC(*GuardStackAddr_word)) &&
((*STACKOVERFLOW_word) == NIL))
at_eos = T; /* search FSB in earlier STACK area by freestackblock */
else if (extendstack() != NIL) {
@@ -139,8 +139,8 @@ tryfsb:
#else
n = oldfx68k->lonametable;
#endif /* BIGVM */
if ((n <= StkOffset_from_68K(oldfx68k)) && (n >= oldfx68k->nextblock)) {
WARN("moveframe:check!!", sff(LADDR_from_68k(oldfx68k)));
if ((n <= StackOffsetFromNative(oldfx68k)) && (n >= oldfx68k->nextblock)) {
WARN("moveframe:check!!", sff(LAddrFromNative(oldfx68k)));
return 0; /* ? */
}
}
@@ -148,7 +148,7 @@ tryfsb:
nametbl_on_stk = T;
/* Find a free stack block */
new68k = freestackblock(size, (StackWord *)oldfx68k,
(LADDR_from_68k(oldfx68k) - DLWORDSPER_CELL) % DLWORDSPER_QUAD);
(LAddrFromNative(oldfx68k) - DLWORDSPER_CELL) % DLWORDSPER_QUAD);
} else
new68k = freestackblock(size, (StackWord *)oldfx68k, -1); /* Not needed to align */
@@ -167,9 +167,9 @@ tryfsb:
((Bframe *)new68k)->residual = T;
new68k = new68k + DLWORDSPER_CELL; /* now NEW points to the FX */
((FX *)new68k)->nextblock = (StkOffset_from_68K(new68k) + size) - DLWORDSPER_CELL;
((FX *)new68k)->nextblock = (StackOffsetFromNative(new68k) + size) - DLWORDSPER_CELL;
/* (CHECK (fetch (BF CHECKED) of (fetch (FX BLINK) of OLDFRAME)))*/
CHECK_BF((Bframe *)Addr68k_from_StkOffset(GETBLINK(oldfx68k)));
CHECK_BF((Bframe *)NativeAligned4FromStackOffset(GETBLINK(oldfx68k)));
/* Set true BFptr,not residual */
SETBLINK(new68k, GETBLINK(oldfx68k));
@@ -194,7 +194,7 @@ out:
flip_cursorbar(10);
#endif
return (S_POSITIVE | StkOffset_from_68K(new68k));
return (S_POSITIVE | StackOffsetFromNative(new68k));
} /* moveframe end */
/******************************************************************/
@@ -242,7 +242,7 @@ int do_stackoverflow(int incallp) {
/* Return from MOVEFRAME directly */
PVar = (DLword *)Addr68k_from_StkOffset(newfx + FRAMESIZE);
PVar = (DLword *)NativeAligned4FromStackOffset(newfx + FRAMESIZE);
movedistance = ((UNSIGNED)PVar - (UNSIGNED)oldPVar) >> 1;
AFTER_CONTEXTSW;
@@ -252,10 +252,10 @@ int do_stackoverflow(int incallp) {
/* including Last Arg(kept in TOS */
#ifdef BIGVM
S_CHECK(FuncObj == (struct fnhead *)Addr68k_from_LADDR(CURRENTFX->fnheader),
S_CHECK(FuncObj == (struct fnhead *)NativeAligned4FromLAddr(CURRENTFX->fnheader),
"in call, but stack frame doesn't match FN being executed.");
#else
S_CHECK(FuncObj == (struct fnhead *)Addr68k_from_LADDR((CURRENTFX->hi2fnheader << 16) |
S_CHECK(FuncObj == (struct fnhead *)NativeAligned4FromLAddr((CURRENTFX->hi2fnheader << 16) |
CURRENTFX->lofnheader),
"in call, but stack frame doesn't match FN being executed.");
#endif /* BIGVM */
@@ -300,19 +300,19 @@ DLword *freestackblock(DLword n, StackWord *start68k, int align)
/* compute actually size you needed */
wantedsize = n + STACKAREA_SIZE + MINEXTRASTACKWORDS;
easp68k = (StackWord *)(Addr68k_from_StkOffset(InterfacePage->endofstack));
easp68k = (StackWord *)(NativeAligned2FromStackOffset(InterfacePage->endofstack));
/*** DEBUG ***/
S_CHECK(n > 2, "asking for block < 2 words long");
S_CHECK(start68k != 0, "start68k = 0");
S_CHECK(start68k >= (StackWord *)Addr68k_from_StkOffset(InterfacePage->stackbase),
S_CHECK(start68k >= (StackWord *)NativeAligned2FromStackOffset(InterfacePage->stackbase),
"start68k before stack base");
STARTOVER:
if (start68k)
scanptr68k = start68k;
else
scanptr68k = (StackWord *)Addr68k_from_StkOffset(InterfacePage->stackbase);
scanptr68k = (StackWord *)NativeAligned2FromStackOffset(InterfacePage->stackbase);
SCAN:
switch ((unsigned)(STKWORD(scanptr68k)->flags)) {
@@ -320,13 +320,13 @@ SCAN:
case STK_GUARD:
if ((UNSIGNED)scanptr68k < (UNSIGNED)easp68k) goto FREESCAN;
if (start68k) {
scanptr68k = (StackWord *)Addr68k_from_StkOffset(InterfacePage->stackbase);
scanptr68k = (StackWord *)NativeAligned2FromStackOffset(InterfacePage->stackbase);
goto SCAN;
} else
goto NEWPAGE;
break;
case STK_FX:
scanptr68k = (StackWord *)Addr68k_from_StkOffset(((FX *)scanptr68k)->nextblock);
scanptr68k = (StackWord *)NativeAligned2FromStackOffset(((FX *)scanptr68k)->nextblock);
break;
default: {
#ifdef STACKCHECK
@@ -340,12 +340,12 @@ SCAN:
#ifdef STACKCHECK
if (((Bframe *)scanptr68k)->residual) {
if (scanptr68k != orig68k) {
WARN("freestackblock:scanptr68k !=org", printf(":0x%x\n", LADDR_from_68k(scanptr68k)));
WARN("freestackblock:scanptr68k !=org", printf(":0x%x\n", LAddrFromNative(scanptr68k)));
return 0; /* ? */
}
} else {
if (((Bframe *)scanptr68k)->ivar != StkOffset_from_68K(orig68k)) {
WARN("BF doesn't point TopIVAR", printf(":0x%x\n", LADDR_from_68k(scanptr68k)));
if (((Bframe *)scanptr68k)->ivar != StackOffsetFromNative(orig68k)) {
WARN("BF doesn't point TopIVAR", printf(":0x%x\n", LAddrFromNative(scanptr68k)));
return 0; /* ? */
}
}
@@ -392,7 +392,7 @@ FREE:
} /* end switch(scanp.. */
if (freesize >= wantedsize) {
if ((align < 0) || (align == (StkOffset_from_68K(freeptr68k) % DLWORDSPER_QUAD)))
if ((align < 0) || (align == (StackOffsetFromNative(freeptr68k) % DLWORDSPER_QUAD)))
wantedsize = MINEXTRASTACKWORDS;
else
wantedsize = MINEXTRASTACKWORDS + DLWORDSPER_CELL;
@@ -418,7 +418,7 @@ FREE:
Edited by : take(March 14, 1988)
*/
/******************************************************************/
#define BF_size(ptr68k) ((StkOffset_from_68K(ptr68k)) - ((Bframe *)(ptr68k))->ivar + 2)
#define BF_size(ptr68k) ((StackOffsetFromNative(ptr68k)) - ((Bframe *)(ptr68k))->ivar + 2)
void decusecount68k(FX *frame68k) {
DLword *alink68k;
@@ -430,14 +430,14 @@ void decusecount68k(FX *frame68k) {
if (FX_INVALIDP(frame68k)) return;
CHECK_FX(frame68k);
/* I don't check if \INTERRUPTABLE is NIL */
while (StkOffset_from_68K(frame68k)) {
while (StackOffsetFromNative(frame68k)) {
if (frame68k->usecount != 0) {
frame68k->usecount--;
return;
} else {
alink68k = Addr68k_from_StkOffset(GETALINK(frame68k));
blink68k = (Bframe *)Addr68k_from_StkOffset(GETBLINK(frame68k));
clink68k = Addr68k_from_StkOffset(GETCLINK(frame68k));
alink68k = NativeAligned2FromStackOffset(GETALINK(frame68k));
blink68k = (Bframe *)NativeAligned4FromStackOffset(GETBLINK(frame68k));
clink68k = NativeAligned2FromStackOffset(GETCLINK(frame68k));
size = FX_size(frame68k);
@@ -450,11 +450,11 @@ void decusecount68k(FX *frame68k) {
if (blink68k->usecnt != 0) {
blink68k->usecnt--;
} else {
/*** ivar68k=Addr68k_from_StkOffset(blink68k->ivar);
/*** ivar68k=NativeAligned2FromStackOffset(blink68k->ivar);
GETWORD(ivar68k)=STK_FSB_WORD;
GETWORD(ivar68k+1)=ivar68k -(DLword *)blink68k +2; **/
MAKEFREEBLOCK(Addr68k_from_StkOffset(blink68k->ivar), BF_size(blink68k));
MAKEFREEBLOCK(NativeAligned2FromStackOffset(blink68k->ivar), BF_size(blink68k));
}
if (alink68k != clink68k) decusecount68k((FX *)alink68k);
@@ -543,18 +543,18 @@ void stack_check(StackWord *start68k) {
memset((char *)bigFSB, 0, sizeof(bigFSB));
#endif
if ((CURRENTFX->nextblock != StkOffset_from_68K(CurrentStackPTR)) || (!FSBP(CurrentStackPTR))) {
if ((CURRENTFX->nextblock != StackOffsetFromNative(CurrentStackPTR)) || (!FSBP(CurrentStackPTR))) {
if ((DLword *)CURRENTFX >= CurrentStackPTR) {
WARN("CURRENTFX >= CurrentStackPTR??\n",
printf("CURRENTFX=0x%x,CurrentStackPTR=0x%x\n", LADDR_from_68k(CURRENTFX),
LADDR_from_68k(CurrentStackPTR)));
printf("CURRENTFX=0x%x,CurrentStackPTR=0x%x\n", LAddrFromNative(CURRENTFX),
LAddrFromNative(CurrentStackPTR)));
}
setflg = T;
printf("set CURRENTFX->nextblock in debugger. But it will be reset after this check \n");
save_nextblock = CURRENTFX->nextblock;
savestack1 = GETWORD(CurrentStackPTR + 2);
savestack2 = GETWORD(CurrentStackPTR + 3);
CURRENTFX->nextblock = StkOffset_from_68K(CurrentStackPTR + 2);
CURRENTFX->nextblock = StackOffsetFromNative(CurrentStackPTR + 2);
GETWORD(CurrentStackPTR + 2) = STK_FSB_WORD;
GETWORD(CurrentStackPTR + 3) = (((UNSIGNED)EndSTKP - (UNSIGNED)(CurrentStackPTR + 2)) >> 1);
}
@@ -562,8 +562,8 @@ void stack_check(StackWord *start68k) {
if (start68k)
scanptr68k = start68k;
else
scanptr68k = (StackWord *)Addr68k_from_StkOffset(InterfacePage->stackbase);
endstack68k = (StackWord *)Addr68k_from_StkOffset(InterfacePage->endofstack);
scanptr68k = (StackWord *)NativeAligned2FromStackOffset(InterfacePage->stackbase);
endstack68k = (StackWord *)NativeAligned2FromStackOffset(InterfacePage->endofstack);
if (STKWORD(endstack68k)->flags != STK_GUARD) printf("?? endstack is not GUARD BLK\n");
@@ -575,7 +575,7 @@ void stack_check(StackWord *start68k) {
#ifdef FSBCHECK
if (freesize > STACKAREA_SIZE + MINEXTRASTACKWORDS) {
if (bigFSBindex < 100) {
bigFSB[bigFSBindex].offset = StkOffset_from_68K(scanptr68k);
bigFSB[bigFSBindex].offset = StackOffsetFromNative(scanptr68k);
bigFSB[bigFSBindex].size = freesize;
bigFSBindex++;
}
@@ -594,7 +594,7 @@ void stack_check(StackWord *start68k) {
case STK_FX:
CHECK_FX((FX *)scanptr68k);
scanptr68k = (StackWord *)Addr68k_from_StkOffset(((FX *)scanptr68k)->nextblock);
scanptr68k = (StackWord *)NativeAligned2FromStackOffset(((FX *)scanptr68k)->nextblock);
putchar('X');
break;
@@ -609,10 +609,10 @@ void stack_check(StackWord *start68k) {
CHECK_BF((Bframe *)scanptr68k);
if (((Bframe *)scanptr68k)->residual) {
if ((DLword *)scanptr68k != top_ivar)
printf("Residual has real IVAR:0x%x\n", LADDR_from_68k(scanptr68k));
printf("Residual has real IVAR:0x%x\n", LAddrFromNative(scanptr68k));
} else {
if (((Bframe *)scanptr68k)->ivar != StkOffset_from_68K(top_ivar))
printf("BF doesn't point TopIVAR:0x%x\n", LADDR_from_68k(scanptr68k));
if (((Bframe *)scanptr68k)->ivar != StackOffsetFromNative(top_ivar))
printf("BF doesn't point TopIVAR:0x%x\n", LAddrFromNative(scanptr68k));
}
scanptr68k = (StackWord *)((DLword *)scanptr68k + DLWORDSPER_CELL);
putchar('B');
@@ -668,18 +668,18 @@ void walk_stack(StackWord *start68k) {
DLword setflg = NIL;
DLword freesize;
if ((CURRENTFX->nextblock != StkOffset_from_68K(CurrentStackPTR)) || (!FSBP(CurrentStackPTR))) {
if ((CURRENTFX->nextblock != StackOffsetFromNative(CurrentStackPTR)) || (!FSBP(CurrentStackPTR))) {
if ((DLword *)CURRENTFX >= CurrentStackPTR) {
WARN("CURRENTFX >= CurrentStackPTR??\n",
printf("CURRENTFX=0x%x,CurrentStackPTR=0x%x\n", LADDR_from_68k(CURRENTFX),
LADDR_from_68k(CurrentStackPTR)));
printf("CURRENTFX=0x%x,CurrentStackPTR=0x%x\n", LAddrFromNative(CURRENTFX),
LAddrFromNative(CurrentStackPTR)));
}
setflg = T;
printf("set CURRENTFX->nextblock in debugger. But it will be reset after this check \n");
save_nextblock = CURRENTFX->nextblock;
savestack1 = GETWORD(CurrentStackPTR + 2);
savestack2 = GETWORD(CurrentStackPTR + 3);
CURRENTFX->nextblock = StkOffset_from_68K(CurrentStackPTR + 2);
CURRENTFX->nextblock = StackOffsetFromNative(CurrentStackPTR + 2);
GETWORD(CurrentStackPTR + 2) = STK_FSB_WORD;
GETWORD(CurrentStackPTR + 3) = (((UNSIGNED)EndSTKP - (UNSIGNED)(CurrentStackPTR + 2)) >> 1);
}
@@ -691,11 +691,11 @@ void walk_stack(StackWord *start68k) {
scanptr68k = (StackWord *)((unsigned long)start68k & -2);
printf("Starting at 0x%tx.", (DLword *)scanptr68k - Stackspace);
} else {
scanptr68k = (StackWord *)Addr68k_from_StkOffset(InterfacePage->stackbase);
scanptr68k = (StackWord *)NativeAligned2FromStackOffset(InterfacePage->stackbase);
printf("Stack base = 0x%tx.", (DLword *)scanptr68k - Stackspace);
}
endstack68k = (StackWord *)Addr68k_from_StkOffset(InterfacePage->endofstack);
endstack68k = (StackWord *)NativeAligned2FromStackOffset(InterfacePage->endofstack);
printf(" End of stack = 0x%tx.\n\n", (DLword *)endstack68k - Stackspace);
@@ -735,10 +735,10 @@ void walk_stack(StackWord *start68k) {
FX *fx = (FX *)scanptr68k;
struct fnhead *fnobj;
#ifdef BIGVM
fnobj = (struct fnhead *)Addr68k_from_LADDR(fx->fnheader);
fnobj = (struct fnhead *)NativeAligned4FromLAddr(fx->fnheader);
#else
fnobj =
(struct fnhead *)Addr68k_from_LADDR(((int)fx->hi2fnheader << 16) | fx->lofnheader);
(struct fnhead *)NativeAligned4FromLAddr(((int)fx->hi2fnheader << 16) | fx->lofnheader);
#endif /* BIGVM */
print(fnobj->framename);
printf("\talink: 0x%04x, clink: 0x%04x, next: 0x%04x\n", fx->alink, fx->clink,
@@ -755,15 +755,15 @@ void walk_stack(StackWord *start68k) {
dummybf = (Bframe *)DUMMYBF(scanptr68k);
/* Check for connection via BLINK field: */
if (StkOffset_from_68K(dummybf) != GETBLINK(scanptr68k)) {
if (StackOffsetFromNative(dummybf) != GETBLINK(scanptr68k)) {
mblink = GETBLINK(scanptr68k);
mtmp = (Bframe *)Addr68k_from_StkOffset(mblink);
mtmp = (Bframe *)NativeAligned4FromStackOffset(mblink);
if ((dummybf->residual == NIL) || (dummybf->ivar != mtmp->ivar))
printf(" [Bad residual]\n");
}
}
scanptr68k = (StackWord *)Addr68k_from_StkOffset(((FX *)scanptr68k)->nextblock);
scanptr68k = (StackWord *)NativeAligned2FromStackOffset(((FX *)scanptr68k)->nextblock);
break;
default:
@@ -782,7 +782,7 @@ void walk_stack(StackWord *start68k) {
(DLword *)scanptr68k - Stackspace, bf->usecnt, bf->residual, bf->padding,
bf->ivar);
if (((Bframe *)scanptr68k)->ivar != StkOffset_from_68K(top_ivar))
if (((Bframe *)scanptr68k)->ivar != StackOffsetFromNative(top_ivar))
printf(" [but top_ivar = 0x%04tx]\n", top_ivar - Stackspace);
}
scanptr68k = (StackWord *)((DLword *)scanptr68k + DLWORDSPER_CELL);
@@ -839,24 +839,24 @@ int quick_stack_check(void) {
memset((char *)bigFSB, 0, sizeof(bigFSB));
#endif
if ((CURRENTFX->nextblock != StkOffset_from_68K(CurrentStackPTR)) || (!FSBP(CurrentStackPTR))) {
if ((CURRENTFX->nextblock != StackOffsetFromNative(CurrentStackPTR)) || (!FSBP(CurrentStackPTR))) {
if ((DLword *)CURRENTFX >= CurrentStackPTR) {
WARN("CURRENTFX >= CurrentStackPTR??\n",
printf("CURRENTFX=0x%x,CurrentStackPTR=0x%x\n", LADDR_from_68k(CURRENTFX),
LADDR_from_68k(CurrentStackPTR)));
printf("CURRENTFX=0x%x,CurrentStackPTR=0x%x\n", LAddrFromNative(CURRENTFX),
LAddrFromNative(CurrentStackPTR)));
return(1);
}
setflg = T;
save_nextblock = CURRENTFX->nextblock;
savestack1 = GETWORD(CurrentStackPTR + 2);
savestack2 = GETWORD(CurrentStackPTR + 3);
CURRENTFX->nextblock = StkOffset_from_68K(CurrentStackPTR + 2);
CURRENTFX->nextblock = StackOffsetFromNative(CurrentStackPTR + 2);
GETWORD(CurrentStackPTR + 2) = STK_FSB_WORD;
GETWORD(CurrentStackPTR + 3) = (((UNSIGNED)EndSTKP - (UNSIGNED)(CurrentStackPTR + 2)) >> 1);
}
scanptr68k = start68k = (StackWord *)Addr68k_from_StkOffset(InterfacePage->stackbase);
endstack68k = (StackWord *)Addr68k_from_StkOffset(InterfacePage->endofstack);
scanptr68k = start68k = (StackWord *)NativeAligned2FromStackOffset(InterfacePage->stackbase);
endstack68k = (StackWord *)NativeAligned2FromStackOffset(InterfacePage->endofstack);
if (STKWORD(endstack68k)->flags != STK_GUARD) printf("?? endstack is not GUARD BLK\n");
@@ -871,7 +871,7 @@ int quick_stack_check(void) {
#ifdef FSBCHECK
if (freesize > STACKAREA_SIZE + MINEXTRASTACKWORDS) {
if (bigFSBindex < 100) {
bigFSB[bigFSBindex].offset = StkOffset_from_68K(scanptr68k);
bigFSB[bigFSBindex].offset = StackOffsetFromNative(scanptr68k);
bigFSB[bigFSBindex].size = freesize;
bigFSBindex++;
}
@@ -889,7 +889,7 @@ int quick_stack_check(void) {
break;
case STK_FX:
CHECK_FX((FX *)scanptr68k);
scanptr68k = (StackWord *)Addr68k_from_StkOffset(((FX *)scanptr68k)->nextblock);
scanptr68k = (StackWord *)NativeAligned2FromStackOffset(((FX *)scanptr68k)->nextblock);
break;
default:
top_ivar = (DLword *)scanptr68k;
@@ -904,10 +904,10 @@ int quick_stack_check(void) {
CHECK_BF((Bframe *)scanptr68k);
if (((Bframe *)scanptr68k)->residual) {
if ((DLword *)scanptr68k != top_ivar)
printf("Residual has real IVAR:0x%x\n", LADDR_from_68k(scanptr68k));
printf("Residual has real IVAR:0x%x\n", LAddrFromNative(scanptr68k));
} else {
if (((Bframe *)scanptr68k)->ivar != StkOffset_from_68K(top_ivar))
printf("BF doesn't point TopIVAR:0x%x\n", LADDR_from_68k(scanptr68k));
if (((Bframe *)scanptr68k)->ivar != StackOffsetFromNative(top_ivar))
printf("BF doesn't point TopIVAR:0x%x\n", LAddrFromNative(scanptr68k));
}
scanptr68k = (StackWord *)((DLword *)scanptr68k + DLWORDSPER_CELL);
break;
@@ -965,7 +965,7 @@ void check_FX(FX *fx68k) {
/* stack blocks have been corrupted this */
/* way. --JDS 2/3/98 */
if (fx68k->nextblock < StkOffset_from_68K(fx68k) /*+FRAMESIZE*/) {
if (fx68k->nextblock < StackOffsetFromNative(fx68k) /*+FRAMESIZE*/) {
error("FX's nextblock field < the FFX.");
}
@@ -975,10 +975,10 @@ void check_FX(FX *fx68k) {
dummybf = (Bframe *)DUMMYBF(fx68k);
/* Check for connection via BLINK field: */
if (StkOffset_from_68K(dummybf) == GETBLINK(fx68k)) return;
if (StackOffsetFromNative(dummybf) == GETBLINK(fx68k)) return;
mblink = GETBLINK(fx68k);
mtmp = (Bframe *)Addr68k_from_StkOffset(mblink);
mtmp = (Bframe *)NativeAligned4FromStackOffset(mblink);
if ((dummybf->residual != NIL) && (dummybf->ivar == mtmp->ivar))
return;
else
@@ -1008,7 +1008,7 @@ void check_BF(Bframe *bf68k) {
if (bf68k->ivar & 1)
error("IVAR is ODD in a BF");
else
for (iptr68k = (Bframe *)Addr68k_from_StkOffset(bf68k->ivar);
for (iptr68k = (Bframe *)NativeAligned4FromStackOffset(bf68k->ivar);
iptr68k <= (Bframe *)(((DLword *)bf68k) - 2); iptr68k++) /* inc 2DLword */
{
/* Make sure none of the "ivar" slots have stack-type */
@@ -1031,7 +1031,7 @@ int check_stack_rooms(FX *fx68k) {
DLword *freeptr68k;
CHECK_FX(fx68k);
freeptr68k = Addr68k_from_StkOffset(fx68k->nextblock);
freeptr68k = NativeAligned2FromStackOffset(fx68k->nextblock);
if (!FSBP(freeptr68k)) error("check_stack_rooms: nextblock doesn't point to an FSB");
return (FSB_size(freeptr68k));

40
src/loopsops.c
View File

@@ -19,7 +19,7 @@
PutValue(object, iv, val)
*/
#include "adr68k.h" // for Addr68k_from_LADDR, LADDR_from_68k
#include "adr68k.h" // for NativeAligned2FromLAddr, NativeAligned4FromLAddr, LAddrFromNative
#include "car-cdrdefs.h" // for car, cdr
#include "cell.h" // for GetVALCELL68k, definition_cell, GetDEFCELL68k
#include "commondefs.h" // for error
@@ -38,7 +38,7 @@ struct LCInstance;
static const char il_string[] = "INTERLISP";
#define GET_IL_ATOM(string) get_package_atom((string), (sizeof(string) - 1), il_string, 9, NIL)
#define AtomValPtr(index) Addr68k_from_LADDR(*(GetVALCELL68k(index)))
#define AtomValPtr(index) NativeAligned4FromLAddr(*(GetVALCELL68k(index)))
#ifdef BIGVM
#define DTD_FROM_LADDR(x) (((struct dtd *)GetDTD(GetTypeNumber((x))))->dtd_name)
@@ -179,13 +179,13 @@ LispPTR LCFetchMethodOrHelp(LispPTR object, LispPTR selector) {
INSTANCE_CLASS_OR_PUNT(object, atom_FetchMethodOrHelp_LCUFN, 2);
objptr = (struct LCInstance *)Addr68k_from_LADDR(object);
objptr = (struct LCInstance *)NativeAligned4FromLAddr(object);
ce = &(LCMethodCache[METH_CACHE_INDEX((cur_class = objptr->class), selector)]);
if (ce->class == cur_class && ce->selector == selector) return ce->method_fn;
/* not in cache, search class then supers */
{
LispPTR supers = ((struct LCClass *)Addr68k_from_LADDR(cur_class))->supers;
LispPTR supers = ((struct LCClass *)NativeAligned4FromLAddr(cur_class))->supers;
for (;;) {
int i = 0;
@@ -193,18 +193,18 @@ LispPTR LCFetchMethodOrHelp(LispPTR object, LispPTR selector) {
LispPTR *selectorptr;
struct LCClass *classptr;
classptr = (struct LCClass *)Addr68k_from_LADDR(cur_class);
classptr = (struct LCClass *)NativeAligned4FromLAddr(cur_class);
if (classptr->selectors == NIL_PTR) {
goto next_class;
} else {
selectorptr = (LispPTR *)Addr68k_from_LADDR(classptr->selectors);
selectorptr = (LispPTR *)NativeAligned4FromLAddr(classptr->selectors);
}
while ((val = selectorptr[i++]) != NIL_PTR) {
if (val == selector) {
ce->class = objptr->class;
ce->selector = selector;
return (ce->method_fn = ((LispPTR *)Addr68k_from_LADDR(classptr->methods))[i - 1]);
return (ce->method_fn = ((LispPTR *)NativeAligned4FromLAddr(classptr->methods))[i - 1]);
}
};
@@ -235,7 +235,7 @@ LispPTR LCFetchMethod(LispPTR class, LispPTR selector) {
if (!LC_TYPEP(class, atom_class)) RETCALL(atom_FetchMethod_LCUFN, 2);
{
LispPTR cur_class = class;
LispPTR supers = ((struct LCClass *)Addr68k_from_LADDR(cur_class))->supers;
LispPTR supers = ((struct LCClass *)NativeAligned4FromLAddr(cur_class))->supers;
for (;;) {
int i = 0;
@@ -243,17 +243,17 @@ LispPTR LCFetchMethod(LispPTR class, LispPTR selector) {
struct LCClass *classptr;
LispPTR *selectorptr;
classptr = (struct LCClass *)Addr68k_from_LADDR(cur_class);
classptr = (struct LCClass *)NativeAligned4FromLAddr(cur_class);
if (classptr->selectors == NIL_PTR)
goto next_class;
else
selectorptr = (LispPTR *)Addr68k_from_LADDR(classptr->selectors);
selectorptr = (LispPTR *)NativeAligned4FromLAddr(classptr->selectors);
while ((val = selectorptr[i++]) != NIL_PTR) {
if (val == selector) {
ce->class = class;
ce->selector = selector;
return (ce->method_fn = ((LispPTR *)Addr68k_from_LADDR(classptr->methods))[i - 1]);
return (ce->method_fn = ((LispPTR *)NativeAligned4FromLAddr(classptr->methods))[i - 1]);
}
};
@@ -276,7 +276,7 @@ LispPTR LCFindVarIndex(LispPTR iv, LispPTR object) {
INSTANCE_CLASS_OR_PUNT(object, atom_FindVarIndex_LCUFN, 2);
objptr = (struct LCInstance *)Addr68k_from_LADDR(object);
objptr = (struct LCInstance *)NativeAligned4FromLAddr(object);
ce = &(LCIVCache[IV_CACHE_INDEX((iNames = objptr->iNames), iv)]);
if (ce->iNames == iNames && ce->iv == iv) return ce->index;
@@ -306,9 +306,9 @@ LispPTR LCGetIVValue(LispPTR object, LispPTR iv) {
LC_INIT;
INSTANCE_OR_PUNT(object, atom_GetIVValue_LCUFN, 2);
objptr = (struct LCInstance *)Addr68k_from_LADDR(object);
objptr = (struct LCInstance *)NativeAligned4FromLAddr(object);
GET_IV_INDEX(objptr, iv, index, goto pnut);
val = ((LispPTR *)Addr68k_from_LADDR(objptr->iDescrs))[index];
val = ((LispPTR *)NativeAligned4FromLAddr(objptr->iDescrs))[index];
if (!LC_TYPEP(val, atom_annotatedValue)) return val;
pnut:
RETCALL(atom_GetIVValue_LCUFN, 2);
@@ -325,9 +325,9 @@ LispPTR LCPutIVValue(LispPTR object, LispPTR iv, LispPTR val) {
LC_INIT;
INSTANCE_OR_PUNT(object, atom_PutIVValue_LCUFN, 3);
objptr = (struct LCInstance *)Addr68k_from_LADDR(object);
objptr = (struct LCInstance *)NativeAligned4FromLAddr(object);
GET_IV_INDEX(objptr, iv, index, goto pnut);
valptr = &(((LispPTR *)Addr68k_from_LADDR(objptr->iDescrs))[index]);
valptr = &(((LispPTR *)NativeAligned4FromLAddr(objptr->iDescrs))[index]);
if (!LC_TYPEP(*valptr, atom_annotatedValue)) {
FRPLPTR((*valptr), val);
return val;
@@ -355,10 +355,10 @@ LispPTR lcfuncall(unsigned int atom_index, int argnum, int bytenum)
if (atom_index == 0xffffffff) error("Loops punt to nonexistent fn");
/* Get Next Block offset from argnum */
CURRENTFX->nextblock = (LADDR_from_68k(CurrentStackPTR) & 0x0ffff) - (argnum << 1) + 4 /* +3 */;
CURRENTFX->nextblock = (LAddrFromNative(CurrentStackPTR) & 0x0ffff) - (argnum << 1) + 4 /* +3 */;
/* Setup IVar */
IVar = Addr68k_from_LADDR((((LispPTR)(CURRENTFX->nextblock)) | STK_OFFSET));
IVar = NativeAligned2FromLAddr((((LispPTR)(CURRENTFX->nextblock)) | STK_OFFSET));
/* Set PC to the Next Instruction and save into FX */
CURRENTFX->pc = ((UNSIGNED)PC - (UNSIGNED)FuncObj) + bytenum;
@@ -368,7 +368,7 @@ LispPTR lcfuncall(unsigned int atom_index, int argnum, int bytenum)
/* Get DEFCELL 68k address */
defcell68k = (struct definition_cell *)GetDEFCELL68k(atom_index);
tmp_fn = (struct fnhead *)Addr68k_from_LADDR(defcell68k->defpointer);
tmp_fn = (struct fnhead *)NativeAligned4FromLAddr(defcell68k->defpointer);
if ((UNSIGNED)(CurrentStackPTR + tmp_fn->stkmin + STK_SAFE) >= (UNSIGNED)EndSTKP) {
LispPTR test;
@@ -400,7 +400,7 @@ LispPTR lcfuncall(unsigned int atom_index, int argnum, int bytenum)
GETWORD(CurrentStackPTR) = FX_MARK;
/* Now SET new FX */
((struct frameex1 *)CurrentStackPTR)->alink = LADDR_from_68k(PVar);
((struct frameex1 *)CurrentStackPTR)->alink = LAddrFromNative(PVar);
PVar = (DLword *)CurrentStackPTR + FRAMESIZE;
#ifdef BIGVM
((struct frameex1 *)CurrentStackPTR)->fnheader = (defcell68k->defpointer);

12
src/lowlev1.c
View File

@@ -10,7 +10,7 @@
#include "version.h"
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned2FromLAddr, NativeAligned4FromLAddr
#include "emlglob.h"
#include "lispemul.h" // for LispPTR, state, DLword, POINTERMASK, ERROR_...
#include "lispmap.h" // for S_POSITIVE
@@ -52,7 +52,7 @@ LispPTR N_OP_putbitsnfd(LispPTR base, LispPTR data, int word_offset,
if ((SEGMASK & data) != S_POSITIVE) { ERROR_EXIT(data); };
pword = Addr68k_from_LADDR(base + word_offset);
pword = NativeAligned2FromLAddr(base + word_offset);
field_size = 0xF & beta;
shift_size = 15 - (beta >> 4) - field_size;
fmask = mask_array[field_size] << shift_size;
@@ -69,7 +69,7 @@ LispPTR N_OP_putbitsnfd(LispPTR base, LispPTR data, int word_offset,
TopOfStack: base address.
alpha: word offset.
beta: High nibble -- number of the first bit of the field
Low nibble -- (number of the size of the fiel) - 1
Low nibble -- (number of the size of the field) - 1
2. Data is @[TopOfStack + alpha]
3. Shift and mask the data.
4. <<Exit>>
@@ -82,7 +82,7 @@ LispPTR N_OP_getbitsnfd(int base_addr, int word_offset, int beta) {
short first;
short size;
pword = Addr68k_from_LADDR(base_addr + word_offset);
pword = NativeAligned2FromLAddr(base_addr + word_offset);
size = 0xF & beta;
first = beta >> 4;
@@ -116,7 +116,7 @@ LispPTR N_OP_putbasen(LispPTR base, LispPTR tos, int n) {
if ((SEGMASK & tos) != S_POSITIVE) {
ERROR_EXIT(tos);
} else {
GETWORD((DLword *)Addr68k_from_LADDR(base + n)) = GetLoWord(tos);
GETWORD(NativeAligned2FromLAddr(base + n)) = GetLoWord(tos);
return (base);
}
}
@@ -139,6 +139,6 @@ LispPTR N_OP_putbasen(LispPTR base, LispPTR tos, int n) {
LispPTR N_OP_putbaseptrn(LispPTR base, LispPTR tos, int n) {
base = POINTERMASK & base;
*((LispPTR *)Addr68k_from_LADDR(base + n)) = tos & POINTERMASK;
*NativeAligned4FromLAddr(base + n) = tos & POINTERMASK;
return (base);
}

10
src/lowlev2.c
View File

@@ -10,7 +10,7 @@
#include "version.h"
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned2FromLAddr, NativeAligned4FromLAddr
#include "emlglob.h"
#include "lispemul.h" // for state, LispPTR, ERROR_EXIT, SEGMASK, POINTE...
#include "lispmap.h" // for S_POSITIVE, S_NEGATIVE
@@ -44,7 +44,7 @@ LispPTR N_OP_addbase(LispPTR base, LispPTR offset) {
switch ((GetTypeNumber(offset))) {
case TYPE_FIXP:
/* overflow or underflow isn't check */
return (base + *(int *)Addr68k_from_LADDR(offset));
return (base + *(int *)NativeAligned4FromLAddr(offset));
default: /* floatp also */ ERROR_EXIT(offset);
} /* end switch */
} /* end switch */
@@ -71,12 +71,12 @@ LispPTR N_OP_getbasebyte(LispPTR base_addr, LispPTR byteoffset) {
case S_NEGATIVE: byteoffset = byteoffset | 0xFFFF0000; break;
default:
switch ((GetTypeNumber(byteoffset))) {
case TYPE_FIXP: byteoffset = *((int *)Addr68k_from_LADDR(byteoffset)); break;
case TYPE_FIXP: byteoffset = *((int *)NativeAligned4FromLAddr(byteoffset)); break;
default: /* floatp also fall thru */ ERROR_EXIT(byteoffset);
} /* end switch */
break;
} /* end switch */
return ((0xFF & (GETBYTE((char *)Addr68k_from_LADDR((POINTERMASK & base_addr)) + byteoffset))) |
return ((0xFF & (GETBYTE((char *)NativeAligned2FromLAddr((POINTERMASK & base_addr)) + byteoffset))) |
S_POSITIVE);
}
@@ -102,6 +102,6 @@ LispPTR N_OP_putbasebyte(LispPTR base_addr, LispPTR byteoffset, LispPTR tos) {
/* ucode and ufn don't handle displacement not smallp */
ERROR_EXIT(tos);
} /* end switch */
GETBYTE(((char *)Addr68k_from_LADDR(POINTERMASK & base_addr)) + byteoffset) = 0xFF & tos;
GETBYTE(((char *)NativeAligned2FromLAddr(POINTERMASK & base_addr)) + byteoffset) = 0xFF & tos;
return (tos);
}

12
src/lpmain.c
View File

@@ -26,7 +26,7 @@
#include "lispemul.h"
#include "lspglob.h"
#include "lispmap.h"
#include "adr68k.h"
#include "adr68k.h" // for NativeAligned4FromLAddr, NativeAligned2FromLAddr
#include "arith.h"
#define CFREE(x) \
@@ -198,7 +198,7 @@ static lprec *initmilp(lprec *lp) {
int lpmain(LispPTR lispresults) {
int i, failure;
float *results = (float *)Addr68k_from_LADDR(lispresults);
float *results = (float *)NativeAligned4FromLAddr(lispresults);
/* solve it */
@@ -240,9 +240,9 @@ int lpsetup(int rows, int cols, int nonnuls, int rhs, int relns, int cend, int m
printf("Rows = %d. Cols = %d. Non-zeros = %d.\n", Rows, Columns, Non_zeros);
Medley_lp = initmilp(Medley_lp);
readlispinput(Medley_lp, Addr68k_from_LADDR(rhs), Addr68k_from_LADDR(relns),
Addr68k_from_LADDR(cend), Addr68k_from_LADDR(mat), Addr68k_from_LADDR(ints),
Addr68k_from_LADDR(lowbo), Addr68k_from_LADDR(upbo));
readlispinput(Medley_lp, NativeAligned4FromLAddr(rhs), NativeAligned2FromLAddr(relns),
NativeAligned4FromLAddr(cend), NativeAligned4FromLAddr(mat), NativeAligned2FromLAddr(ints),
NativeAligned4FromLAddr(lowbo), NativeAligned4FromLAddr(upbo));
auto_scale(Medley_lp); /* Scale values */
@@ -253,7 +253,7 @@ int lpsetup(int rows, int cols, int nonnuls, int rhs, int relns, int cend, int m
set_globals(Medley_lp); /* Set global vars for the run */
if (Isvalid(Medley_lp)) {
if (objbound) {
Medley_lp->obj_bound = Best_solution[0] = *((float *)Addr68k_from_LADDR(objbound));
Medley_lp->obj_bound = Best_solution[0] = *((float *)NativeAligned4FromLAddr(objbound));
} else if (Maximise && Medley_lp->obj_bound == Infinite)
Best_solution[0] = -Infinite;
else if (!Maximise && Medley_lp->obj_bound == -Infinite)

6
src/main.c
View File

@@ -571,7 +571,7 @@ void start_lisp() {
/*******************************/
#ifndef INIT
{
INTSTAT *intstate = ((INTSTAT *)Addr68k_from_LADDR(*INTERRUPTSTATE_word));
INTSTAT *intstate = ((INTSTAT *)NativeAligned4FromLAddr(*INTERRUPTSTATE_word));
intstate->ETHERInterrupt = 0;
intstate->LogFileIO = 0;
intstate->IOInterrupt = 0;
@@ -583,9 +583,9 @@ void start_lisp() {
TopOfStack = 0;
Error_Exit = 0;
MState->pvar = (DLword *)Addr68k_from_LADDR(STK_OFFSET | InterfacePage->currentfxp) + FRAMESIZE;
MState->pvar = (DLword *)NativeAligned2FromLAddr(STK_OFFSET | InterfacePage->currentfxp) + FRAMESIZE;
freeptr = next68k = Addr68k_from_LADDR(STK_OFFSET | CURRENTFX->nextblock);
freeptr = next68k = NativeAligned2FromLAddr(STK_OFFSET | CURRENTFX->nextblock);
if (GETWORD(next68k) != STK_FSB_WORD) error("Starting Lisp: Next stack block isn't free!");

4
src/misc7.c
View File

@@ -11,7 +11,7 @@
/* misc7.c
*/
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned2FromLAddr
#include "arith.h" // for N_GETNUMBER
#include "bbtsubdefs.h" // for n_new_cursorin
#include "dbprint.h" // for DBPRINT
@@ -50,7 +50,7 @@ LispPTR N_OP_misc7(LispPTR arg1, LispPTR arg2, LispPTR arg3, LispPTR arg4, LispP
if (alpha != 1) ERROR_EXIT(arg7);
base = Addr68k_from_LADDR(arg1);
base = NativeAligned2FromLAddr(arg1);
N_GETNUMBER(arg2, x, doufn);
N_GETNUMBER(arg3, y, doufn);
N_GETNUMBER(arg4, operation, doufn);

4
src/mkatom.c
View File

@@ -33,7 +33,7 @@
#ifndef BYTESWAP
#include <string.h> // for memcmp
#endif
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned2FromLAddr
#include "cell.h" // for PNCell, GetPnameCell
#include "dbprint.h" // for DBPRINT
#include "lispemul.h" // for DLword, LispPTR, T, NIL, POINTERMASK
@@ -309,7 +309,7 @@ LispPTR make_atom(const char *char_base, DLword offset, DLword length)
atom_index = hash_entry - 1;
/* get pname pointer */
pnptr = (PNCell *)GetPnameCell(atom_index);
pname_base = (char *)Addr68k_from_LADDR(POINTERMASK & pnptr->pnamebase);
pname_base = (char *)NativeAligned2FromLAddr(POINTERMASK & pnptr->pnamebase);
if ((length == GETBYTE(pname_base)) &&
(compare_chars(++pname_base, char_base + offset, length) == T)) {

8
src/mkcell.c
View File

@@ -27,7 +27,7 @@
*/
/**********************************************************************/
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned2FromLAddr
#include "allocmdsdefs.h" // for alloc_mdspage, initmdspage
#include "commondefs.h" // for error
#include "emlglob.h"
@@ -68,7 +68,7 @@ LispPTR N_OP_createcell(LispPTR tos) {
retry:
if ((tos = newcell = ((dtd68k->dtd_free) & POINTERMASK)) != NIL) {
ptr = (DLword *)Addr68k_from_LADDR(newcell);
ptr = (DLword *)NativeAligned2FromLAddr(newcell);
if (917505 == *(LispPTR *)ptr) error("N_OP_createcell E0001 error");
/* replace dtd_free with newcell's top DLword (it may keep next chain)*/
dtd68k->dtd_free = (*((LispPTR *)ptr)) & POINTERMASK;
@@ -113,7 +113,7 @@ retry:
if (newcell > POINTERMASK) error("createcell : BAD Lisp address");
#endif
ptr = Addr68k_from_LADDR(newcell);
ptr = NativeAligned2FromLAddr(newcell);
if (917505 == *(LispPTR *)ptr) error("N_OP_createcell E0001 error");
@@ -140,7 +140,7 @@ retry:
check_dtd_chain(type);
#endif
return (Addr68k_from_LADDR(newcell));
return (NativeAligned2FromLAddr(newcell)); /* XXX: is it really only aligned(2)? */
} else {
dtd68k->dtd_free = initmdspage(alloc_mdspage(dtd68k->dtd_typeentry), dtd68k->dtd_size, NIL);

4
src/mnwevent.c
View File

@@ -95,7 +95,7 @@ MNWEvent *NewEvent() {
if (index != 0xFFFFFFFF) {
MNWEVENTQUEUE68k = GetVALCELL68k(index);
DOMNWEVENT_index = get_package_atom("\\DOMNWEVENT", 11, "INTERLISP", 9, NIL);
CTopMNWEvent = (DLword *)Addr68k_from_LADDR(*MNWEVENTQUEUE68k);
CTopMNWEvent = (DLword *)NativeAligned2FromLAddr(*MNWEVENTQUEUE68k);
}
}
if (CTopMNWEvent) {
@@ -523,7 +523,7 @@ void DoMNWRing(int type, LispPTR screen, LispPTR window, int l, int b, int wid,
if (index != 0xFFFFFFFF) {
MNWEVENTQUEUE68k = GetVALCELL68k(index);
DOMNWEVENT_index = get_package_atom("\\DOMNWEVENT", 11, "INTERLISP", 9, NIL);
CTopMNWEvent = (DLword *)Addr68k_from_LADDR(*MNWEVENTQUEUE68k);
CTopMNWEvent = (DLword *)NativeAligned2FromLAddr(*MNWEVENTQUEUE68k);
}
}
do_ring:

6
src/mvs.c
View File

@@ -18,7 +18,7 @@
/* */
/************************************************************************/
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned4FromLAddr
#ifdef RESWAPPEDCODESTREAM
#include "byteswapdefs.h" // for byte_swap_code_block
#endif
@@ -63,7 +63,7 @@ newframe:
fnhead = (struct fnhead *)FuncObj;
pc = (ByteCode *)PC + 3; /* to skip the miscn opcode we're in now */
} else {
fnhead = (struct fnhead *)Addr68k_from_LADDR(POINTERMASK & SWA_FNHEAD((int)caller->fnheader));
fnhead = (struct fnhead *)NativeAligned4FromLAddr(POINTERMASK & SWA_FNHEAD((int)caller->fnheader));
pc = (ByteCode *)fnhead + (caller->pc);
}
#ifdef RESWAPPEDCODESTREAM
@@ -159,7 +159,7 @@ newframe:
fnhead = (struct fnhead *)FuncObj;
pc = (ByteCode *)PC + 3; /* Skip over the miscn opcode we're in now */
} else {
fnhead = (struct fnhead *)Addr68k_from_LADDR(POINTERMASK & SWA_FNHEAD((int)caller->fnheader));
fnhead = (struct fnhead *)NativeAligned4FromLAddr(POINTERMASK & SWA_FNHEAD((int)caller->fnheader));
pc = (ByteCode *)fnhead + (caller->pc);
}

4
src/osmsg.c
View File

@@ -240,8 +240,8 @@ LispPTR mess_read(LispPTR *args)
SETJMP(NIL);
/* Get buff address from LISP */
naddress = (LispPTR *)(Addr68k_from_LADDR(args[0]));
base = (char *)(Addr68k_from_LADDR(((OneDArray *)naddress)->base));
naddress = (LispPTR *)(NativeAligned4FromLAddr(args[0]));
base = (char *)(NativeAligned2FromLAddr(((OneDArray *)naddress)->base));
close(log_id);
TIMEOUT(log_id = open(logfile, O_RDONLY));

40
src/picture.c
View File

@@ -35,20 +35,20 @@
short *sbase; \
int i; \
\
arrayp = (OneDArray *)(Addr68k_from_LADDR((unsigned int)Lisp)); \
arrayp = (OneDArray *)(NativeAligned4FromLAddr((unsigned int)Lisp)); \
Len = min(MaxLen, arrayp->totalsize); \
\
switch (arrayp->typenumber) { \
case THIN_CHAR_TYPENUMBER: \
base = \
((char *)(Addr68k_from_LADDR((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
((char *)(NativeAligned2FromLAddr((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
for (i = 0; i < Len; i++) C[i] = base[i]; \
C[Len] = '\0'; \
break; \
\
case FAT_CHAR_TYPENUMBER: \
sbase = \
((short *)(Addr68k_from_LADDR((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
((short *)(NativeAligned2FromLAddr((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
base = (char *)sbase; \
for (i = 0; i < Len * 2; i++) C[i] = base[i]; \
C[Len * 2] = '\0'; \
@@ -65,19 +65,19 @@
short *sbase; \
int idx; \
\
arrayp = (OneDArray *)(Addr68k_from_LADDR((unsigned int)Lisp)); \
arrayp = (OneDArray *)(NativeAligned4FromLAddr((unsigned int)Lisp)); \
\
switch (arrayp->typenumber) { \
case THIN_CHAR_TYPENUMBER: \
base = \
((char *)(Addr68k_from_LADDR((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
((char *)(NativeAligned2FromLAddr((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
for (idx = 0; idx < Len; idx++) base[idx] = C[idx]; \
arrayp->fillpointer = Len; \
break; \
\
case FAT_CHAR_TYPENUMBER: \
sbase = \
((short *)(Addr68k_from_LADDR((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
((short *)(NativeAligned2FromLAddr((unsigned int)arrayp->base))) + ((int)(arrayp->offset)); \
base = (char *)sbase; \
for (idx = 0; idx < Len * 2; idx++) base[idx] = C[idx]; \
arrayp->fillpointer = Len; \
@@ -91,7 +91,7 @@
{ \
int *base; \
\
base = (int *)Addr68k_from_LADDR((unsigned int)Lisp); \
base = (int *)NativeAligned4FromLAddr((unsigned int)Lisp); \
*base = C; \
}
@@ -143,7 +143,7 @@ LispPTR Picture_Create(LispPTR *args)
cell = (unsigned int *)createcell68k(TYPE_FIXP);
*cell = (unsigned int)storage;
return (LADDR_from_68k(cell));
return (LAddrFromNative(cell));
} /* end Picture_Create */
@@ -154,7 +154,7 @@ LispPTR Picture_Free(LispPTR *args)
LispPicture *n_picture;
Pixrect *pict;
n_picture = (LispPicture *)Addr68k_from_LADDR(args[1]);
n_picture = (LispPicture *)NativeAligned4FromLAddr(args[1]);
pict = (Pixrect *)n_picture->storage;
/* TrueColorFb should not be destory. */
@@ -174,7 +174,7 @@ LispPTR Picture_GetValue(LispPTR *args)
Pixrect *pict;
unsigned int *cell;
n_picture = (LispPicture *)Addr68k_from_LADDR(args[1]);
n_picture = (LispPicture *)NativeAligned4FromLAddr(args[1]);
x = (DLword)args[2];
y = (DLword)args[3];
@@ -183,7 +183,7 @@ LispPTR Picture_GetValue(LispPTR *args)
cell = (unsigned int *)createcell68k(TYPE_FIXP);
*cell = (unsigned int)value;
return (LADDR_from_68k(cell));
return (LAddrFromNative(cell));
} /* end Picture_GetValue */
@@ -193,7 +193,7 @@ LispPTR Picture_SetValue(LispPTR *args)
LispPicture *n_picture;
struct pixrect *pict;
n_picture = (LispPicture *)Addr68k_from_LADDR(args[1]);
n_picture = (LispPicture *)NativeAligned4FromLAddr(args[1]);
x = (DLword)args[2];
y = (DLword)args[3];
N_GETNUMBER(args[4], value, bad_arg);
@@ -215,7 +215,7 @@ LispPTR Picture_Get(LispPTR *args)
LispPicture *n_picture;
int length;
n_picture = (LispPicture *)Addr68k_from_LADDR(args[1]);
n_picture = (LispPicture *)NativeAligned4FromLAddr(args[1]);
LStringToCString(args[2], file_name, MAX_NAME_LEN, length);
if ((n_picture->storage = (unsigned int)File_to_Pixrect(file_name)) != NULL) {
@@ -235,7 +235,7 @@ LispPTR Picture_Put(LispPTR *args)
char *name;
int length;
n_picture = (LispPicture *)Addr68k_from_LADDR(args[1]);
n_picture = (LispPicture *)NativeAligned4FromLAddr(args[1]);
LStringToCString(args[2], file_name, MAX_NAME_LEN, length);
Pixrect_to_File((Pixrect *)n_picture->storage, file_name);
@@ -253,8 +253,8 @@ LispPTR Picture_Bitblt(LispPTR *args)
int video_flg;
LispPTR operation, cl_region;
src = (LispPicture *)Addr68k_from_LADDR(args[1]);
dst = (LispPicture *)Addr68k_from_LADDR(args[4]);
src = (LispPicture *)NativeAligned4FromLAddr(args[1]);
dst = (LispPicture *)NativeAligned4FromLAddr(args[4]);
N_GETNUMBER(args[2], src_left, bad_arg);
N_GETNUMBER(args[3], src_bottom, bad_arg);
N_GETNUMBER(args[5], dst_left, bad_arg);
@@ -362,7 +362,7 @@ LispPTR Picture_Bltshade(LispPTR *args)
LispPTR cl_region;
int dst_left, dst_bottom, left, right, bottom, top, width, height, operation, video_flg;
dst = (LispPicture *)Addr68k_from_LADDR(args[2]);
dst = (LispPicture *)NativeAligned4FromLAddr(args[2]);
N_GETNUMBER(args[1], texture, bad_arg);
N_GETNUMBER(args[3], dst_left, bad_arg);
N_GETNUMBER(args[4], dst_bottom, bad_arg);
@@ -470,7 +470,7 @@ LispPTR VideoFile_Open(LispPTR *args)
cell = (unsigned int *)createcell68k(TYPE_FIXP);
*cell = videofile;
return (LADDR_from_68k(cell));
return (LAddrFromNative(cell));
} /* end VideoFile_Open */
LispPTR VideoFile_Close(LispPTR *args)
@@ -491,7 +491,7 @@ LispPTR VideoFile_Read(LispPTR *args)
unsigned int *cell, pix, videofile;
N_GETNUMBER(args[1], (unsigned int)videofile, bad_arg);
n_picture = (LispPicture *)Addr68k_from_LADDR(args[2]);
n_picture = (LispPicture *)NativeAligned4FromLAddr(args[2]);
if ((n_picture->storage = (unsigned int)read_rasterfile(videofile)) != NULL) {
n_picture->width = (DLword)(((Pixrect *)n_picture->storage)->pr_width);
@@ -513,7 +513,7 @@ LispPTR VideoFile_Write(LispPTR *args)
int status;
N_GETNUMBER(args[1], videofile, bad_arg);
n_pict = (LispPicture *)Addr68k_from_LADDR(args[2]);
n_pict = (LispPicture *)NativeAligned4FromLAddr(args[2]);
if ((status = write_rasterfile(videofile, (Pixrect *)n_pict->storage))) {
return (ATOM_T);

66
src/rawcolor.c
View File

@@ -49,7 +49,7 @@ typedef struct {
} BIGBM;
#define GetNewFragment(list, frag, type) \
frag = (type)Addr68k_from_LADDR(car(list)); \
frag = (type)NativeAligned4FromLAddr(car(list)); \
list = cdr(list);
LispPTR SLOWBLTCHAR_index;
@@ -143,17 +143,17 @@ C_slowbltchar(LispPTR *args)
extern LispPTR *TOPWDS68k;
n_dstream = (Stream *)Addr68k_from_LADDR(displaystream);
n_dd = (DISPLAYDATA *)Addr68k_from_LADDR(n_dstream->IMAGEDATA);
n_fontd = (FONTDESC *)Addr68k_from_LADDR(n_dd->ddfont);
n_destbitmap = (BITMAP *)Addr68k_from_LADDR(n_dd->dddestination);
n_dstream = (Stream *)NativeAligned4FromLAddr(displaystream);
n_dd = (DISPLAYDATA *)NativeAligned4FromLAddr(n_dstream->IMAGEDATA);
n_fontd = (FONTDESC *)NativeAligned4FromLAddr(n_dd->ddfont);
n_destbitmap = (BITMAP *)NativeAligned4FromLAddr(n_dd->dddestination);
if ((n_fontd->ROTATION & 0xffff) == 0) {
if ((csinfo = *(((LispPTR *)Addr68k_from_LADDR(n_fontd->FONTCHARSETVECTOR)) +
if ((csinfo = *(((LispPTR *)NativeAligned4FromLAddr(n_fontd->FONTCHARSETVECTOR)) +
CharSet(charcode))) == NIL)
PUNT_TO_SLOWBLTCHAR; /* CSINFO is not cached */
n_csinfo = (CHARSETINFO *)Addr68k_from_LADDR(csinfo);
n_csinfo = (CHARSETINFO *)NativeAligned4FromLAddr(csinfo);
SFGetNum(n_dd->ddxposition, curx);
SFGetNum(n_dd->ddyposition, cury);
@@ -166,7 +166,7 @@ C_slowbltchar(LispPTR *args)
cl_bottom = n_dd->ddclippingbottom;
cl_top = n_dd->ddclippingtop;
newx = curx + *(DLword *)Addr68k_from_LADDR(n_dd->ddwidthscache + Char8Code(charcode));
newx = curx + *(DLword *)NativeAligned2FromLAddr(n_dd->ddwidthscache + Char8Code(charcode));
if (newx > rmargin) PUNT_TO_SLOWBLTCHAR; /* do \DSPPRINTCR/LF */
@@ -179,8 +179,8 @@ C_slowbltchar(LispPTR *args)
COLORSCREEN_index = MAKEATOM("\\COLORSCREEN");
COLORSCREEN68k = GetVALCELL68k(COLORSCREEN_index);
}
ColorScreenData = (SCREEN *)Addr68k_from_LADDR(*COLORSCREEN68k);
window = (WINDOW *)Addr68k_from_LADDR(ColorScreenData->SCTOPW);
ColorScreenData = (SCREEN *)NativeAligned4FromLAddr(*COLORSCREEN68k);
window = (WINDOW *)NativeAligned4FromLAddr(ColorScreenData->SCTOPW);
if ((displaystream != ColorScreenData->SCTOPW) && (displaystream != window->DSP) &&
(displaystream != *TOPWDS68k) && ((fmemb(n_dd->dddestination, *SCREENBITMAPS68k)) != NIL))
PUNT_TO_SLOWBLTCHAR;
@@ -201,13 +201,13 @@ C_slowbltchar(LispPTR *args)
extern int ScreenLocked;
extern int displayheight;
n_srcBM = (BITMAP *)Addr68k_from_LADDR(n_csinfo->CHARSETBITMAP);
n_srcBM = (BITMAP *)NativeAligned4FromLAddr(n_csinfo->CHARSETBITMAP);
src_h = n_srcBM->bmheight;
src_w = n_srcBM->bmwidth;
src_x = *((DLword *)Addr68k_from_LADDR(n_dd->ddoffsetscache + Char8Code(charcode)));
src_x = *((DLword *)NativeAligned2FromLAddr(n_dd->ddoffsetscache + Char8Code(charcode)));
src_y = 0;
w = *(DLword *)Addr68k_from_LADDR(n_dd->ddcharimagewidths + Char8Code(charcode));
w = *(DLword *)NativeAligned2FromLAddr(n_dd->ddcharimagewidths + Char8Code(charcode));
h = src_h;
(short)dst_x = (short)curx;
@@ -247,12 +247,12 @@ C_slowbltchar(LispPTR *args)
}
if (GetTypeNumber(n_dd->dddestination) == TYPE_BITMAP) { /* Bitap */
n_destBM = (BITMAP *)Addr68k_from_LADDR(n_dd->dddestination);
n_destBM = (BITMAP *)NativeAligned4FromLAddr(n_dd->dddestination);
ScreenLocked = T;
/* xposition is shifted 3 Kludge for cursorin
in color(8bpp) ** x's meaning is different from
bitbltsub's. For now,I use this func with Kludge */
displayflg = n_new_cursorin(Addr68k_from_LADDR(n_destBM->bmbase), dst_x << 3,
displayflg = n_new_cursorin(NativeAligned2FromLAddr(n_destBM->bmbase), dst_x << 3,
/* Kludge:YCoordination upside down*/
displayheight - cury, w, h);
if (displayflg) HideCursor;
@@ -307,8 +307,8 @@ void ColorizeFont8(BITMAP *sBM, DLword sXOffset, DLword sYOffset, BITMAP *dBM, D
sYOffset = sBM->bmheight - (sYOffset + height);
dYOffset = dBM->bmheight - (dYOffset + height);
nbase = (DLword *)Addr68k_from_LADDR(sBM->bmbase) + (sBM->bmrasterwidth * sYOffset);
(DLword *)dbase = (DLword *)Addr68k_from_LADDR(dBM->bmbase) + (dBM->bmrasterwidth * dYOffset);
nbase = (DLword *)NativeAligned2FromLAddr(sBM->bmbase) + (sBM->bmrasterwidth * sYOffset);
(DLword *)dbase = (DLword *)NativeAligned2FromLAddr(dBM->bmbase) + (dBM->bmrasterwidth * dYOffset);
for (i = 0, dbase += dXOffset; /* 8bpp */
i < height; i++, nbase += sBM->bmrasterwidth, ((DLword *)dbase) += dBM->bmrasterwidth) {
lineBlt8(nbase, (int)sXOffset, dbase, (int)width, col0, col1, sourcetype, operation);
@@ -352,7 +352,7 @@ void ColorizeFont8_BIGBM(BITMAP *sBM, DLword sXOffset, DLword sYOffset, BIGBM *d
/* search fragment of bitmaps including the destination top. */
while (dest_fragbottom <= dYOffset) {
GetNewFragment(dest_bmlist, dest_frag, BITMAP *);
if (dest_frag == (BITMAP *)Addr68k_from_LADDR(NIL_PTR)) return;
if (dest_frag == (BITMAP *)NativeAligned4FromLAddr(NIL_PTR)) return;
dest_fragtop = dest_fragbottom;
dest_fragbottom += dest_frag->bmheight;
} /* end while */
@@ -371,8 +371,8 @@ loop:
} /* end if */
dbase =
(DLword *)Addr68k_from_LADDR(dest_frag->bmbase) + (dest_frag->bmrasterwidth * dest_yoffset);
nbase = (DLword *)Addr68k_from_LADDR(sBM->bmbase) + (sBM->bmrasterwidth * sYOffset);
(DLword *)NativeAligned2FromLAddr(dest_frag->bmbase) + (dest_frag->bmrasterwidth * dest_yoffset);
nbase = (DLword *)NativeAligned2FromLAddr(sBM->bmbase) + (sBM->bmrasterwidth * sYOffset);
sYOffset += (DLword)dest_h; /* next src yoffset */
@@ -385,7 +385,7 @@ loop:
height -= dest_h;
if (height > 0) {
GetNewFragment(dest_bmlist, dest_frag, BITMAP *);
if (dest_frag != (BITMAP *)Addr68k_from_LADDR(NIL_PTR)) {
if (dest_frag != (BITMAP *)NativeAligned4FromLAddr(NIL_PTR)) {
dest_fragtop = dest_fragbottom;
dest_fragbottom = dest_fragtop + dest_frag->bmheight;
dest_yoffset = 0; /* y offset must be zero. */
@@ -410,8 +410,8 @@ void newColorizeFont8(PILOTBBT *pbt, u_char backcolor, u_char forecolor, LispPTR
u_char *dbase;
int i;
nbase = (DLword *)Addr68k_from_LADDR((pbt->pbtsourcehi << 16) | (pbt->pbtsourcelo));
(DLword *)dbase = (DLword *)Addr68k_from_LADDR((pbt->pbtdesthi << 16) | (pbt->pbtdestlo));
nbase = (DLword *)NativeAligned2FromLAddr((pbt->pbtsourcehi << 16) | (pbt->pbtsourcelo));
(DLword *)dbase = (DLword *)NativeAligned2FromLAddr((pbt->pbtdesthi << 16) | (pbt->pbtdestlo));
dbase += pbt->pbtdestbit;
for (i = 0; i < pbt->pbtheight;
i++, nbase += pbt->pbtsourcebpl / 16, dbase += pbt->pbtdestbpl / 8) {
@@ -437,9 +437,9 @@ void Uncolorize_Bitmap(LispPTR args[])
int y;
int s_height, s_width, s_bitsperpixel, s_rasterwidth, d_rasterwidth;
s_bitmap = (BITMAP *)Addr68k_from_LADDR(args[0]);
d_bitmap = (BITMAP *)Addr68k_from_LADDR(args[1]);
OnOff = (DLword *)Addr68k_from_LADDR(args[2]);
s_bitmap = (BITMAP *)NativeAligned4FromLAddr(args[0]);
d_bitmap = (BITMAP *)NativeAligned4FromLAddr(args[1]);
OnOff = (DLword *)NativeAligned2FromLAddr(args[2]);
s_height = s_bitmap->bmheight;
s_width = s_bitmap->bmwidth;
@@ -447,8 +447,8 @@ void Uncolorize_Bitmap(LispPTR args[])
if (s_bitsperpixel != 8) return;
s_base = (u_char *)Addr68k_from_LADDR(s_bitmap->bmbase);
d_base = (DLword *)Addr68k_from_LADDR(d_bitmap->bmbase);
s_base = (u_char *)NativeAligned2FromLAddr(s_bitmap->bmbase);
d_base = (DLword *)NativeAligned2FromLAddr(d_bitmap->bmbase);
s_rasterwidth = s_bitmap->bmrasterwidth;
d_rasterwidth = d_bitmap->bmrasterwidth;
@@ -516,10 +516,10 @@ LispPTR Colorize_Bitmap(LispPTR args[])
N_GETNUMBER(args[10], d_nbits, bad_arg);
if (d_nbits != 8) return (NIL); /* do nothing. */
s_bitmap = (BITMAP *)Addr68k_from_LADDR(args[0]);
s_bitmap = (BITMAP *)NativeAligned4FromLAddr(args[0]);
N_GETNUMBER(args[1], s_left, bad_arg);
N_GETNUMBER(args[2], s_bottom, bad_arg);
d_bitmap = (BITMAP *)Addr68k_from_LADDR(args[3]);
d_bitmap = (BITMAP *)NativeAligned4FromLAddr(args[3]);
N_GETNUMBER(args[4], d_left, bad_arg);
N_GETNUMBER(args[5], d_bottom, bad_arg);
N_GETNUMBER(args[6], width, bad_arg);
@@ -527,9 +527,9 @@ LispPTR Colorize_Bitmap(LispPTR args[])
N_GETNUMBER(args[8], color0, bad_arg);
N_GETNUMBER(args[9], color1, bad_arg);
s_base = (DLword *)Addr68k_from_LADDR(s_bitmap->bmbase) +
s_base = (DLword *)NativeAligned2FromLAddr(s_bitmap->bmbase) +
s_bitmap->bmrasterwidth * (s_bitmap->bmheight - (s_bottom + height));
(DLword *)d_base = (DLword *)Addr68k_from_LADDR(d_bitmap->bmbase) +
(DLword *)d_base = (DLword *)NativeAligned2FromLAddr(d_bitmap->bmbase) +
d_bitmap->bmrasterwidth * (d_bitmap->bmheight - (d_bottom + height));
for (i = 0, d_base += d_left; i < height;
@@ -612,7 +612,7 @@ void Draw_8BppColorLine(LispPTR *args)
else
mode = 0; /* REPLACE_atom */
n_bmbase = (u_char *)Addr68k_from_LADDR(args[9]);
n_bmbase = (u_char *)NativeAligned2FromLAddr(args[9]);
raster_width = (short)(args[10] & 0xffff);
color = (u_char)(args[11] & 0xff);

10
src/rawrs232c.c
View File

@@ -57,8 +57,8 @@ LispPTR raw_rs232c_open(LispPTR portname)
int fd;
if (GetTypeNumber(portname) != TYPE_ONED_ARRAY) error("PORTNAME is not string");
head = (ONED_ARRAY *)Addr68k_from_LADDR(portname);
lispname = (char *)Addr68k_from_LADDR(head->BASE);
head = (ONED_ARRAY *)NativeAligned4FromLAddr(portname);
lispname = (char *)NativeAligned2FromLAddr(head->BASE);
if ((fd = open(lispname, O_RDWR)) < 0) {
perror("RS open fail: ");
@@ -80,7 +80,7 @@ LispPTR raw_rs232c_setparams(LispPTR fd, LispPTR data)
return (NIL);
}
ndata = (RawRSParam *)Addr68k_from_LADDR(data);
ndata = (RawRSParam *)NativeAligned4FromLAddr(data);
/* Input */
termdata.c_iflag |= IXON | IXOFF;
@@ -245,7 +245,7 @@ LispPTR raw_rs232c_write(LispPTR fd, LispPTR baseptr, LispPTR len)
{
unsigned char *ptr;
ptr = (unsigned char *)Addr68k_from_LADDR(baseptr);
ptr = (unsigned char *)NativeAligned2FromLAddr(baseptr);
if (write((fd & 0xffff), ptr, (len & 0xffff)) < 0) {
perror("RS-write :");
@@ -268,7 +268,7 @@ LispPTR raw_rs232c_read(LispPTR fd, LispPTR buff, LispPTR nbytes)
select(32, &readfds, NULL, NULL, &RS_TimeOut);
if (FD_ISSET(real_fd, &readfds)) {
buffptr = (unsigned char *)Addr68k_from_LADDR(buff);
buffptr = (unsigned char *)NativeAligned2FromLAddr(buff);
if ((length = read(real_fd, buffptr, (nbytes & 0xffff))) < 0) {
perror("RS read :");

4
src/return.c
View File

@@ -119,7 +119,7 @@ void contextsw(DLword fxnum, DLword bytenum, DLword flags)
CurrentStackPTR += 2;
}
CURRENTFX->nextblock = LOLOC(LADDR_from_68k(CurrentStackPTR));
CURRENTFX->nextblock = LOLOC(LAddrFromNative(CurrentStackPTR));
/* FSB set */
GETWORD(CurrentStackPTR) = STK_FSB_WORD;
@@ -131,7 +131,7 @@ void contextsw(DLword fxnum, DLword bytenum, DLword flags)
Midpunt(fxnum); /* exchanging FX */
next68k = (DLword *)Addr68k_from_LADDR(STK_OFFSET | CURRENTFX->nextblock);
next68k = (DLword *)NativeAligned2FromLAddr(STK_OFFSET | CURRENTFX->nextblock);
if (GETWORD(next68k) != STK_FSB_WORD) error("contextsw(): MP9316");
freeptr = next68k;

4
src/rpc.c
View File

@@ -87,8 +87,8 @@ LispPTR rpc(LispPTR *args)
N_GETNUMBER(args[1], port, handle_error);
/* Translate the buffer pointer into C pointers */
outbuf = (char *)(Addr68k_from_LADDR(args[2]));
inbuf = (char *)(Addr68k_from_LADDR(args[3]));
outbuf = (char *)(NativeAligned2FromLAddr(args[2]));
inbuf = (char *)(NativeAligned2FromLAddr(args[3]));
N_GETNUMBER(args[4], msec_until_timeout, handle_error);

8
src/rplcons.c
View File

@@ -45,13 +45,13 @@ LispPTR N_OP_rplcons(LispPTR list, LispPTR item) {
/* There are some rest Cell and "list" must be ONPAGE cdr_coded */
#ifndef NEWCDRCODING
page = POINTER_PAGE(list);
list68k = (ConsCell *)Addr68k_from_LADDR(list);
list68k = (ConsCell *)NativeAligned4FromLAddr(list);
if ((GetCONSCount(page) != 0) && (list68k->cdr_code > CDR_MAXINDIRECT)) {
GCLOOKUP(item, ADDREF);
GCLOOKUP(cdr(list), DELREF);
conspage = (struct conspage *)Addr68k_from_LPAGE(page);
conspage = (struct conspage *)NativeAligned4FromLPage(page);
new_cell = (ConsCell *)GetNewCell_68k(conspage);
conspage->count--;
@@ -62,9 +62,9 @@ LispPTR N_OP_rplcons(LispPTR list, LispPTR item) {
ListpDTD->dtd_cnt0++;
list68k->cdr_code = CDR_ONPAGE | ((LADDR_from_68k(new_cell) & 0xff) >> 1);
list68k->cdr_code = CDR_ONPAGE | ((LAddrFromNative(new_cell) & 0xff) >> 1);
return (LADDR_from_68k(new_cell));
return (LAddrFromNative(new_cell));
} else
#endif /* ndef NEWCDRCODING */

10
src/rs232c.c
View File

@@ -222,10 +222,10 @@ rs232c_read() {
if (RS232C_Fd >= 0) {
if (RS232CGetFlag->busy) {
iocb =
(DLRS232C_IOCB *)Addr68k_from_LADDR(((*(RS232CGetCSB + 1) & 0xff) << 16) + *RS232CGetCSB);
(DLRS232C_IOCB *)NativeAligned4FromLAddr(((*(RS232CGetCSB + 1) & 0xff) << 16) + *RS232CGetCSB);
if ((count =
read(RS232C_Fd, (char *)Addr68k_from_LADDR(((iocb->block_pointer_hi & 0xff) << 16) +
read(RS232C_Fd, (char *)NativeAligned2FromLAddr(((iocb->block_pointer_hi & 0xff) << 16) +
iocb->block_pointer_lo),
iocb->byte_count)) < 0) {
((DLRS232C_IOCB_TRANSFER_STATUS *)(&iocb->transfer_status))->success = 0;
@@ -270,12 +270,12 @@ RS232C_write() {
char *buf;
DLRS232C_IOCB *iocb;
iocb = (DLRS232C_IOCB *)Addr68k_from_LADDR(((*(RS232CPutCSB + 1) & 0xff) << 16) + *RS232CPutCSB);
iocb = (DLRS232C_IOCB *)NativeAligned4FromLAddr(((*(RS232CPutCSB + 1) & 0xff) << 16) + *RS232CPutCSB);
if (RS232CPutFlag->busy && RS232C_Fd >= 0) {
if (iocb->put) {
for (size = iocb->byte_count,
buf = (char *)Addr68k_from_LADDR(((iocb->block_pointer_hi & 0xff) << 16) +
buf = (char *)NativeAligned2FromLAddr(((iocb->block_pointer_hi & 0xff) << 16) +
iocb->block_pointer_lo);
size > 0; size -= count, buf += count) {
trynum = 0;
@@ -762,7 +762,7 @@ rs232c_debug( name, sw )
printf("DEBUG:\n");
printf("DEBUG: \t\tSymbol Address Contents\n");
printf("DEBUG: \t\tIOPAGE %#x\n",Addr68k_from_LADDR(IOPAGE_OFFSET));
printf("DEBUG: \t\tIOPAGE %#x\n",NativeAligned4FromLAddr(IOPAGE_OFFSET));
printf("DEBUG: \t\tHardWareConfig %#x %#x\n", HardWareConfig, *(DLword*)
HardWareConfig);
printf("DEBUG: \t\tRS232CGetFlag %#x %#x\n", RS232CGetFlag, *(DLword*)

10
src/storage.c
View File

@@ -18,7 +18,7 @@
/*****************************************************************/
#include <stdio.h> // for printf
#include "address.h" // for POINTER_PAGE
#include "adr68k.h" // for Addr68k_from_LADDR, LADDR_from_68k
#include "adr68k.h" // for NativeAligned4FromLAddr, LAddrFromNative
#include "car-cdrdefs.h" // for cdr, car, rplacd, rplaca
#include "commondefs.h" // for error
#include "conspagedefs.h" // for cons
@@ -78,7 +78,7 @@ void checkfor_storagefull(unsigned int npages) {
Please save and reload a.s.a.p.");
} else if (*STORAGEFULL_word == NIL) {
*STORAGEFULL_word = ATOM_T;
int_state = (INTSTAT *)Addr68k_from_LADDR(*INTERRUPTSTATE_word);
int_state = (INTSTAT *)NativeAligned4FromLAddr(*INTERRUPTSTATE_word);
int_state->storagefull = T;
*PENDINGINTERRUPT_word = ATOM_T;
}
@@ -314,12 +314,12 @@ LispPTR newpage(LispPTR base) {
/* compute virtual page of new FPtoVP table page */
/* i.e., the vp that holds the next FPtoVP entry */
vp_of_fp = (LADDR_from_68k(FPtoVP + nactive) >> 8);
vp_of_fp = (LAddrFromNative(FPtoVP + nactive) >> 8);
/* compute file page where this entry has to be to ensure
that FPtoVP is contiguous on the file */
fp_of_fptovp = InterfacePage->fptovpstart + (vp_of_fp - (LADDR_from_68k(FPtoVP) >> 8));
fp_of_fptovp = InterfacePage->fptovpstart + (vp_of_fp - (LAddrFromNative(FPtoVP) >> 8));
/* debugging check: make sure FPtoVP is contiguous */
@@ -356,7 +356,7 @@ LispPTR newpage(LispPTR base) {
{
/* set vmemfull state */
if (*VMEM_FULL_STATE_word == NIL) {
int_state = (INTSTAT *)Addr68k_from_LADDR(*INTERRUPTSTATE_word);
int_state = (INTSTAT *)NativeAligned4FromLAddr(*INTERRUPTSTATE_word);
int_state->vmemfull = T;
*PENDINGINTERRUPT_word = ATOM_T;
}

10
src/subr.c
View File

@@ -30,7 +30,7 @@
#include <stdio.h> // for printf, sprintf, NULL
#include <time.h> // for nanosleep, timespec
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned2FromLAddr, NativeAligned4FromLAddr
#include "arith.h" // for N_GETNUMBER, ARITH_SWITCH
#include "bbtsubdefs.h" // for bitblt_bitmap, bitbltsub, bitshade_bitmap
#include "cell.h" // for PNCell, GetPnameCell
@@ -84,7 +84,7 @@ char *atom_to_str(LispPTR atom_index) {
char *pname_base;
pnptr = (PNCell *)GetPnameCell(atom_index);
pname_base = (char *)Addr68k_from_LADDR(pnptr->pnamebase);
pname_base = (char *)NativeAligned2FromLAddr(pnptr->pnamebase);
return (pname_base + 1);
} /*atom_to_str*/
@@ -483,7 +483,7 @@ void OP_subrcall(int subr_no, int argnum) {
/* XXX: this WILL NOT WORK if Lisp memory is allocated outside the low 4GB */
/* not supported since native addresses can't be represented as
a Lisp FIXP
ARITH_SWITCH(Addr68k_from_LADDR(args[0]), TopOfStack);
ARITH_SWITCH(NativeAligned2FromLAddr(args[0]), TopOfStack);
*/
TopOfStack = NIL_PTR;
break;
@@ -496,7 +496,7 @@ void OP_subrcall(int subr_no, int argnum) {
{
UNSIGNED iarg;
N_GETNUMBER(args[0], iarg, ret_nil);
ARITH_SWITCH(LADDR_from_68k(iarg), TopOfStack);
ARITH_SWITCH(LAddrFromNative(iarg), TopOfStack);
break;
};
*/
@@ -535,7 +535,7 @@ void OP_subrcall(int subr_no, int argnum) {
error("called SUBR 0166, not defined!!");
{int temp;
N_GETNUMBER(TopOfStack, temp, badarg);
temp = (UNSIGNED) Addr68k_from_LADDR(temp);
temp = (UNSIGNED) NativeAligned4FromLAddr(temp);
ARITH_SWITCH(temp, TopOfStack);
break;
badarg: TopOfStack = NIL;

2
src/subr0374.c
View File

@@ -41,7 +41,7 @@ LispPTR subr_k_trace(LispPTR *args) {
char *base;
len = 0xFFFF & args[1];
base = (char *)Addr68k_from_LADDR(args[0]);
base = (char *)NativeAligned2FromLAddr(args[0]);
while (len-- > 0) putc(*base++, stderr);
putc('\n', stderr);
return (NIL);

30
src/sxhash.c
View File

@@ -10,7 +10,7 @@
#include "version.h"
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned4FromLAddr
#include "arith.h" // for FIXP_VALUE
#include "car-cdrdefs.h" // for car, cdr
#include "cell.h" // for PLCell, PNCell, GetPnameCell, GetPropCell
@@ -78,24 +78,24 @@ static unsigned short sxhash(LispPTR obj) {
case TYPE_PATHNAME: return (sxhash_pathname(obj));
case TYPE_ONED_ARRAY:
case TYPE_GENERAL_ARRAY:
str = (OneDArray *)Addr68k_from_LADDR(obj);
str = (OneDArray *)NativeAligned4FromLAddr(obj);
if (str->stringp) return (sxhash_string(str));
if (str->bitp) return (sxhash_bitvec(str));
return (EQHASHINGBITS(obj));
case TYPE_BIGNUM: {
LispPTR contents;
contents = ((BIGNUM *)Addr68k_from_LADDR(obj))->contents;
contents = ((BIGNUM *)NativeAligned4FromLAddr(obj))->contents;
return ((unsigned short)car(contents) + (((unsigned short)car(cdr(contents))) << 12));
}
case TYPE_COMPLEX: {
COMPLEX *object;
object = (COMPLEX *)Addr68k_from_LADDR(obj);
object = (COMPLEX *)NativeAligned4FromLAddr(obj);
return (sxhash(object->real) ^ sxhash(object->imaginary));
}
case TYPE_RATIO: {
RATIO *object;
object = (RATIO *)Addr68k_from_LADDR(obj);
object = (RATIO *)NativeAligned4FromLAddr(obj);
return (sxhash(object->numerator) ^ sxhash(object->denominator));
}
@@ -119,13 +119,13 @@ static unsigned short sxhash_string(OneDArray *obj) {
case THIN_CHAR_TYPENUMBER: {
char *thin;
unsigned i;
thin = ((char *)(Addr68k_from_LADDR(obj->base))) + offset;
thin = ((char *)(NativeAligned2FromLAddr(obj->base))) + offset;
for (i = 0; i < len; i++) hash = sxhash_rotate(hash ^ GETBYTE(thin++));
} break;
case FAT_CHAR_TYPENUMBER: {
unsigned short *fat;
unsigned i;
fat = ((unsigned short *)(Addr68k_from_LADDR(obj->base))) + offset;
fat = ((unsigned short *)(NativeAligned2FromLAddr(obj->base))) + offset;
for (i = 0; i < len; i++) hash = sxhash_rotate(hash ^ GETWORD(fat++));
} break;
default: error("SXHASH of a string not made of chars!\n");
@@ -139,7 +139,7 @@ static unsigned short sxhash_bitvec(OneDArray *obj) {
unsigned short hash = 0;
len = (unsigned)obj->fillpointer;
offset = (unsigned)obj->offset;
base = ((unsigned short *)(Addr68k_from_LADDR(obj->base))) + (offset >> 4);
base = ((unsigned short *)(NativeAligned2FromLAddr(obj->base))) + (offset >> 4);
if (offset == 0) {
hash = (*base);
if (len < 16) hash = hash >> (16 - len);
@@ -165,7 +165,7 @@ static unsigned short sxhash_list(LispPTR obj) {
static unsigned short sxhash_pathname(LispPTR obj) {
unsigned short hash = 0;
PATHNAME *path;
path = (PATHNAME *)(Addr68k_from_LADDR(obj));
path = (PATHNAME *)(NativeAligned4FromLAddr(obj));
hash = sxhash_rotate(sxhash(path->host) ^ sxhash(path->device));
hash = sxhash_rotate(hash ^ sxhash(path->type));
hash = sxhash_rotate(hash ^ sxhash(path->version));
@@ -202,7 +202,7 @@ static unsigned short stringequalhash(LispPTR obj) {
case TYPE_LITATOM:
ind = ((int)obj) & POINTERMASK;
pnptr = (PNCell *)GetPnameCell(ind);
base = (DLword *)Addr68k_from_LADDR(pnptr->pnamebase);
base = (DLword *)NativeAligned2FromLAddr(pnptr->pnamebase);
Prop = (PLCell *)GetPropCell(ind);
fatp = Prop->fatpnamep;
offset = 1;
@@ -210,10 +210,10 @@ static unsigned short stringequalhash(LispPTR obj) {
break;
case TYPE_ONED_ARRAY:
case TYPE_GENERAL_ARRAY:
str = (OneDArray *)Addr68k_from_LADDR(obj);
str = (OneDArray *)NativeAligned4FromLAddr(obj);
if (str->stringp) {
fatp = (str->typenumber) == FAT_CHAR_TYPENUMBER;
base = Addr68k_from_LADDR(str->base);
base = NativeAligned2FromLAddr(str->base);
offset = str->offset;
len = str->fillpointer;
} else
@@ -270,7 +270,7 @@ static unsigned short stringhash(LispPTR obj) {
case TYPE_LITATOM:
ind = ((int)obj) & POINTERMASK;
pnptr = (PNCell *)GetPnameCell(ind);
base = (DLword *)Addr68k_from_LADDR(pnptr->pnamebase);
base = (DLword *)NativeAligned2FromLAddr(pnptr->pnamebase);
Prop = (PLCell *)GetPropCell(ind);
fatp = Prop->fatpnamep;
offset = 1;
@@ -278,10 +278,10 @@ static unsigned short stringhash(LispPTR obj) {
break;
case TYPE_ONED_ARRAY:
case TYPE_GENERAL_ARRAY:
str = (OneDArray *)Addr68k_from_LADDR(obj);
str = (OneDArray *)NativeAligned4FromLAddr(obj);
if (str->stringp) {
fatp = (str->typenumber) == FAT_CHAR_TYPENUMBER;
base = Addr68k_from_LADDR(str->base);
base = NativeAligned2FromLAddr(str->base);
offset = str->offset;
len = str->fillpointer;
} else

114
src/testtool.c
View File

@@ -47,7 +47,7 @@
#include <stdio.h> // for printf, putchar, fflush, getchar, stdin
#include <stdlib.h> // for exit
#include <string.h> // for strlen
#include "adr68k.h" // for LADDR_from_68k, Addr68k_from_LADDR, Addr68...
#include "adr68k.h" // for LAddrFromNative, NativeAligned2FromLAddr, NativeAligned4FromLAddr
#include "array.h" // for arrayheader
#include "cell.h" // for conspage, PNCell, GetDEFCELL68k, GetPnameCell
#include "commondefs.h" // for error
@@ -86,7 +86,7 @@ void print_atomname(LispPTR index)
pnptr = (PNCell *)GetPnameCell(index);
print_package_name(pnptr->pkg_index);
pname = (char *)Addr68k_from_LADDR(pnptr->pnamebase);
pname = (char *)NativeAligned2FromLAddr(pnptr->pnamebase);
length = (DLword)GETBYTE(pname++);
@@ -112,11 +112,11 @@ int find_package_from_name(const char *packname, int len) {
struct arrayheader *pi_array;
/* assumes the *PACKAGE-FROM-INDEX* array is simple with no offset */
pi_array = (struct arrayheader *)Addr68k_from_LADDR(*Package_from_Index_word);
pi_array = (struct arrayheader *)NativeAligned4FromLAddr(*Package_from_Index_word);
for (index = 1; index < pi_array->totalsize; index++) {
package = (PACKAGE *)Addr68k_from_LADDR(aref1(*Package_from_Index_word, index));
namestring = (NEWSTRINGP *)Addr68k_from_LADDR(package->NAME);
pname = (char *)Addr68k_from_LADDR(namestring->base);
package = (PACKAGE *)NativeAligned4FromLAddr(aref1(*Package_from_Index_word, index));
namestring = (NEWSTRINGP *)NativeAligned4FromLAddr(package->NAME);
pname = (char *)NativeAligned2FromLAddr(namestring->base);
if (namestring->offset != 0) { pname += namestring->offset; }
len2 = (DLword)(namestring->fillpointer);
@@ -143,9 +143,9 @@ void print_package_name(int index) {
printf("#:");
return;
}
package = (PACKAGE *)Addr68k_from_LADDR(aref1(*Package_from_Index_word, index));
namestring = (NEWSTRINGP *)Addr68k_from_LADDR(package->NAME);
pname = (char *)Addr68k_from_LADDR(namestring->base);
package = (PACKAGE *)NativeAligned4FromLAddr(aref1(*Package_from_Index_word, index));
namestring = (NEWSTRINGP *)NativeAligned4FromLAddr(package->NAME);
pname = (char *)NativeAligned2FromLAddr(namestring->base);
if (namestring->offset != 0) {
pname += namestring->offset;
printf("OFFSET:\n");
@@ -242,13 +242,13 @@ void dump_dtd(void) {
/************************************************************************/
void check_type_68k(int type, LispPTR *ptr) {
if (type != (GetTypeNumber(LADDR_from_68k(ptr)))) {
printf("Mismatching occur !!! LispAddr 0x%x type %d\n", LADDR_from_68k(ptr), type);
if (type != (GetTypeNumber(LAddrFromNative(ptr)))) {
printf("Mismatching occur !!! LispAddr 0x%x type %d\n", LAddrFromNative(ptr), type);
exit(-1);
}
printf("LispPTR 0x%x is the datatype %d\n", LADDR_from_68k(ptr),
GetTypeNumber(LADDR_from_68k(ptr)));
printf("LispPTR 0x%x is the datatype %d\n", LAddrFromNative(ptr),
GetTypeNumber(LAddrFromNative(ptr)));
}
/************************************************************************/
@@ -286,15 +286,15 @@ lp:
printf(
"conspage at 0x%x(lisp) has %d free cells , next available cell offset is %d ,and next page "
"is 0x%x(lisp)\n",
LADDR_from_68k(base), (0xff & base->count), (0xff & base->next_cell), base->next_page);
LAddrFromNative(base), (0xff & base->count), (0xff & base->next_cell), base->next_page);
for (i = 0, cell = (ConsCell *)base + 1; i < 127; i++, cell++) {
printf(" LADDR : %d = Cell[ %d ]## cdr_code= %d ,car = %d\n", LADDR_from_68k(cell), i + 1,
printf(" LADDR : %d = Cell[ %d ]## cdr_code= %d ,car = %d\n", LAddrFromNative(cell), i + 1,
cell->cdr_code, cell->car_field);
}
if ((linking == T) && (base->next_page != NIL_PTR)) {
base = (struct conspage *)Addr68k_from_LPAGE(base->next_page);
base = (struct conspage *)NativeAligned4FromLPage(base->next_page);
goto lp;
}
@@ -306,7 +306,7 @@ lp:
void trace_listpDTD(void) {
extern struct dtd *ListpDTD;
printf("Dump conspages from ListpDTD chain\n");
dump_conspage((struct conspage *)Addr68k_from_LPAGE(ListpDTD->dtd_nextpage), T);
dump_conspage((struct conspage *)NativeAligned4FromLPage(ListpDTD->dtd_nextpage), T);
}
/************************************************************************/
@@ -319,7 +319,7 @@ void trace_listpDTD(void) {
void a68k(LispPTR lispptr) {
DLword *val;
val = Addr68k_from_LADDR(lispptr);
val = NativeAligned2FromLAddr(lispptr);
printf("68k: %p (%"PRIuPTR")\n", (void *)val, (uintptr_t)val);
}
@@ -333,7 +333,7 @@ void a68k(LispPTR lispptr) {
void laddr(DLword *addr68k) {
int val;
val = LADDR_from_68k(addr68k);
val = LAddrFromNative(addr68k);
printf("LADDR : 0x%x (%d)\n", val, val);
}
@@ -353,10 +353,10 @@ void dump_fnbody(LispPTR fnblockaddr)
DLbyte *scratch;
int i;
fnobj = (struct fnhead *)Addr68k_from_LADDR(fnblockaddr);
fnobj = (struct fnhead *)NativeAligned4FromLAddr(fnblockaddr);
printf("***DUMP Func Obj << ");
printf("start at 0x%x lisp address(%p 68k)\n", LADDR_from_68k(fnobj), (void *)fnobj);
printf("start at 0x%x lisp address(%p 68k)\n", LAddrFromNative(fnobj), (void *)fnobj);
print(fnobj->framename);
putchar('\n');
@@ -375,7 +375,7 @@ void dump_fnbody(LispPTR fnblockaddr)
for (i = 20; i < (fnobj->startpc); i += 2) {
int word;
word = (int)(0xffff & (GETWORD((DLword *)(scratch + i))));
printf(" 0x%x(%p 68k): 0%6o 0x%4x\n", LADDR_from_68k(scratch + i), (void *)(scratch + i), word, word);
printf(" 0x%x(%p 68k): 0%6o 0x%4x\n", LAddrFromNative(scratch + i), (void *)(scratch + i), word, word);
}
scratch = (DLbyte *)fnobj + (fnobj->startpc);
@@ -819,9 +819,9 @@ void dumpl(LispPTR laddr) {
int i;
LispPTR *ptr;
ptr = (LispPTR *)Addr68k_from_LADDR(laddr);
ptr = (LispPTR *)NativeAligned4FromLAddr(laddr);
for (i = 0; i < 40; i++, ptr++) printf("LADDR 0x%x : %d\n", LADDR_from_68k(ptr), *ptr);
for (i = 0; i < 40; i++, ptr++) printf("LADDR 0x%x : %d\n", LAddrFromNative(ptr), *ptr);
}
/**** dump specified area (in 16 bit width) ***/
@@ -830,10 +830,10 @@ void dumps(LispPTR laddr) {
int i;
DLword *ptr;
ptr = (DLword *)Addr68k_from_LADDR(laddr);
ptr = (DLword *)NativeAligned2FromLAddr(laddr);
for (i = 0; i < 40; i++, ptr++)
printf("LADDR 0x%x : %d\n", LADDR_from_68k(ptr), (GETWORD(ptr) & 0xffff));
printf("LADDR 0x%x : %d\n", LAddrFromNative(ptr), (GETWORD(ptr) & 0xffff));
}
/***********************/
@@ -855,19 +855,19 @@ void dump_bf(Bframe *bf) {
if (BFRAMEPTR(bf)->residual) { goto printflags; }
ptr = Addr68k_from_LADDR(STK_OFFSET + bf->ivar);
ptr = NativeAligned2FromLAddr(STK_OFFSET + bf->ivar);
if ((((DLword *)bf - ptr) > 512) || (((UNSIGNED)ptr & 1) != 0)) {
printf("\nInvalid basic frame");
return;
}
while (ptr < (DLword *)bf) {
printf("\n %x : %x %x", LADDR_from_68k(ptr), GETWORD(ptr), GETWORD(ptr + 1));
printf("\n %x : %x %x", LAddrFromNative(ptr), GETWORD(ptr), GETWORD(ptr + 1));
print(*ptr);
ptr += 2;
}
printflags:
printf("\n %x : %x %x ", LADDR_from_68k(bf), *(DLword *)bf, *((DLword *)bf + 1));
printf("\n %x : %x %x ", LAddrFromNative(bf), *(DLword *)bf, *((DLword *)bf + 1));
putchar('[');
if (BFRAMEPTR(bf)->residual) printf("Residual, ");
if (BFRAMEPTR(bf)->padding) printf("Padded, ");
@@ -890,7 +890,7 @@ void dump_fx(struct frameex1 *fx_addr68k) {
atomindex = get_framename((struct frameex1 *)fx_addr68k);
printf("\n*** Frame Extension for ");
print(atomindex);
printf("\n %x : %x %x ", LADDR_from_68k(ptr), GETWORD(ptr), GETWORD(ptr + 1));
printf("\n %x : %x %x ", LAddrFromNative(ptr), GETWORD(ptr), GETWORD(ptr + 1));
putchar('[');
if (fx_addr68k->fast) printf("F,");
@@ -900,20 +900,20 @@ void dump_fx(struct frameex1 *fx_addr68k) {
if (fx_addr68k->alink & 1) printf("[SLOWP]");
ptr += 2;
printf("\n %x : %x %x fnheadlo, fnheadhi\n", LADDR_from_68k(ptr), GETWORD(ptr), GETWORD(ptr + 1));
printf("\n %x : %x %x fnheadlo, fnheadhi\n", LAddrFromNative(ptr), GETWORD(ptr), GETWORD(ptr + 1));
ptr += 2;
printf("\n %x : %x %x next, pc\n", LADDR_from_68k(ptr), GETWORD(ptr), GETWORD(ptr + 1));
printf("\n %x : %x %x next, pc\n", LAddrFromNative(ptr), GETWORD(ptr), GETWORD(ptr + 1));
ptr += 2;
printf("\n %x : %x %x LoNmTbl, HiNmTbl\n", LADDR_from_68k(ptr), GETWORD(ptr), GETWORD(ptr + 1));
printf("\n %x : %x %x LoNmTbl, HiNmTbl\n", LAddrFromNative(ptr), GETWORD(ptr), GETWORD(ptr + 1));
ptr += 2;
printf("\n %x : %x %x #blink, #clink\n", LADDR_from_68k(ptr), GETWORD(ptr), GETWORD(ptr + 1));
printf("\n %x : %x %x #blink, #clink\n", LAddrFromNative(ptr), GETWORD(ptr), GETWORD(ptr + 1));
/* should pay attention to the name table like RAID does */
next68k = (DLword *)Addr68k_from_LADDR((fx_addr68k->nextblock + STK_OFFSET));
next68k = (DLword *)NativeAligned2FromLAddr((fx_addr68k->nextblock + STK_OFFSET));
if (fx_addr68k == CURRENTFX) { next68k = CurrentStackPTR + 2; }
if ((next68k < ptr) || (((UNSIGNED)next68k & 1) != 0)) {
@@ -923,7 +923,7 @@ void dump_fx(struct frameex1 *fx_addr68k) {
while (next68k > ptr) {
ptr += 2;
printf("\n %x : %x %x", LADDR_from_68k(ptr), GETWORD(ptr), GETWORD(ptr + 1));
printf("\n %x : %x %x", LAddrFromNative(ptr), GETWORD(ptr), GETWORD(ptr + 1));
}
} /* end dump_fx */
@@ -940,7 +940,7 @@ void dump_stackframe(struct frameex1 *fx_addr68k) {
if ((fx_addr68k->alink & 1) == 0) { /* FAST */
bf = (Bframe *)(((DLword *)fx_addr68k) - 2);
} else { /* SLOW */
bf = (Bframe *)Addr68k_from_LADDR((fx_addr68k->blink + STK_OFFSET));
bf = (Bframe *)NativeAligned4FromLAddr((fx_addr68k->blink + STK_OFFSET));
}
dump_bf(bf);
dump_fx((struct frameex1 *)fx_addr68k);
@@ -950,10 +950,10 @@ void dump_CSTK(int before) {
DLword *ptr;
ptr = CurrentStackPTR - before;
while (ptr != CurrentStackPTR) {
printf("\n%x : %x ", LADDR_from_68k(ptr), GETWORD(ptr));
printf("\n%x : %x ", LAddrFromNative(ptr), GETWORD(ptr));
ptr++;
}
printf("\nCurrentSTKP : %x ", LADDR_from_68k(CurrentStackPTR));
printf("\nCurrentSTKP : %x ", LAddrFromNative(CurrentStackPTR));
printf("\ncontents : %x ", *((LispPTR *)(CurrentStackPTR - 1)));
} /* dump_CSTK end */
@@ -997,16 +997,16 @@ int get_framename(struct frameex1 *fx_addr68k) {
scratch |= (unsigned int)(fx_addr68k->lonametable);
}
#endif /* BIGVM */
fnheader = (struct fnhead *)Addr68k_from_LADDR(scratch);
fnheader = (struct fnhead *)NativeAligned4FromLAddr(scratch);
return (fnheader->framename);
} /* get_framename end */
FX *get_nextFX(FX *fx) {
if (URaid_scanlink == URSCAN_ALINK)
return ((FX *)Addr68k_from_StkOffset(GETALINK(fx)));
return ((FX *)NativeAligned4FromStackOffset(GETALINK(fx)));
else
return ((FX *)Addr68k_from_StkOffset(GETCLINK(fx)));
return ((FX *)NativeAligned4FromStackOffset(GETCLINK(fx)));
} /* get_nextFX end */
@@ -1034,7 +1034,7 @@ LispPTR *MakeAtom68k(char *string) {
#else
index = VALS_OFFSET + (index << 1);
#endif /* BIGVM */
return ((LispPTR *) Addr68k_from_LADDR(index));
return ((LispPTR *) NativeAligned4FromLAddr(index));
}
/************************************************************************/
@@ -1106,12 +1106,12 @@ void all_stack_dump(DLword start, DLword end, DLword silent)
if (start == 0)
start68k = Stackspace + InterfacePage->stackbase;
else
start68k = Addr68k_from_LADDR(STK_OFFSET | start);
start68k = NativeAligned2FromLAddr(STK_OFFSET | start);
if (end == 0)
end68k = Stackspace + InterfacePage->endofstack;
else
end68k = Addr68k_from_LADDR(STK_OFFSET | end);
end68k = NativeAligned2FromLAddr(STK_OFFSET | end);
stkptr = (STKH *)start68k;
@@ -1122,9 +1122,9 @@ void all_stack_dump(DLword start, DLword end, DLword silent)
if ((STKHPTR(stkptr)->flags2 != 0) || (STKHPTR(stkptr)->usecount != 0)) { goto badblock; };
size = GETWORD(((DLword *)stkptr) + 1);
if (STKHPTR(stkptr)->flags1 == STK_GUARD)
printf("\n0x%x GUARD, size : 0x%x", LADDR_from_68k(stkptr), size);
printf("\n0x%x GUARD, size : 0x%x", LAddrFromNative(stkptr), size);
else
printf("\n0x%x FSB, size : 0x%x", LADDR_from_68k(stkptr), size);
printf("\n0x%x FSB, size : 0x%x", LAddrFromNative(stkptr), size);
if (size <= 0 || size > ((DLword *)end68k - (DLword *)stkptr)) { goto badblock; };
@@ -1142,7 +1142,7 @@ void all_stack_dump(DLword start, DLword end, DLword silent)
{goto badblock;};*/
if (silent) {
SD_morep;
printf("\n0x%x: FX for ", LADDR_from_68k(stkptr));
printf("\n0x%x: FX for ", LAddrFromNative(stkptr));
print(get_framename((struct frameex1 *)stkptr));
printf(" [");
if (((FX *)stkptr)->fast) printf("fast,");
@@ -1158,7 +1158,7 @@ void all_stack_dump(DLword start, DLword end, DLword silent)
printf(" <-***current***");
size = EndSTKP - (DLword *)stkptr;
} else {
size = Addr68k_from_LADDR(STK_OFFSET | ((FX *)stkptr)->nextblock) - (DLword *)stkptr;
size = NativeAligned2FromLAddr(STK_OFFSET | ((FX *)stkptr)->nextblock) - (DLword *)stkptr;
};
goto checksize;
default:
@@ -1171,19 +1171,19 @@ void all_stack_dump(DLword start, DLword end, DLword silent)
if ((BFRAMEPTR(stkptr))->residual) {
if ((DLword *)stkptr != orig68k) {
printf("\n$$$Bad BF(res):0x%x", LADDR_from_68k(stkptr));
printf("\n$$$Bad BF(res):0x%x", LAddrFromNative(stkptr));
goto incptr;
}
} else {
if (BFRAMEPTR(stkptr)->ivar != StkOffset_from_68K(orig68k)) {
printf("\n$$$BF doesn't point TopIVAR:0x%x\n", LADDR_from_68k(stkptr));
if (BFRAMEPTR(stkptr)->ivar != StackOffsetFromNative(orig68k)) {
printf("\n$$$BF doesn't point TopIVAR:0x%x\n", LAddrFromNative(stkptr));
goto incptr;
}
}
if (silent) {
SD_morep;
printf("\n0x%x BF, ", LADDR_from_68k(stkptr));
printf("\n0x%x BF, ", LAddrFromNative(stkptr));
putchar('[');
if (BFRAMEPTR(stkptr)->residual) printf("Res,");
if (BFRAMEPTR(stkptr)->padding) printf("Pad,");
@@ -1196,7 +1196,7 @@ void all_stack_dump(DLword start, DLword end, DLword silent)
badblock:
SD_morep;
printf("\n0x%x: Invalid, %x %x", LADDR_from_68k(stkptr), GETWORD((DLword *)stkptr),
printf("\n0x%x: Invalid, %x %x", LAddrFromNative(stkptr), GETWORD((DLword *)stkptr),
GETWORD((DLword *)(stkptr + 1)));
incptr:
stkptr = (STKH *)(((DLword *)stkptr) + 2);
@@ -1217,7 +1217,7 @@ void dtd_chain(DLword type) {
dtdp = (struct dtd *)GetDTD(type);
next = dtdp->dtd_free;
next68k = (LispPTR *)Addr68k_from_LADDR(next);
next68k = (LispPTR *)NativeAligned4FromLAddr(next);
while ((*next68k) != 0) {
if (type != GetTypeNumber(next)) {
@@ -1228,7 +1228,7 @@ void dtd_chain(DLword type) {
putchar('\n');
next = *next68k;
next68k = (LispPTR *)Addr68k_from_LADDR(next);
next68k = (LispPTR *)NativeAligned4FromLAddr(next);
}
printf("That's All !\n");
@@ -1256,7 +1256,7 @@ void check_dtd_chain(DLword type)
return;
}
onext = next;
next = *((LispPTR *)Addr68k_from_LADDR(next));
next = *((LispPTR *)NativeAligned4FromLAddr(next));
next &= POINTERMASK;
}
}

12
src/timer.c
View File

@@ -170,7 +170,7 @@ LispPTR subr_gettime(LispPTR args[])
int result;
result = gettime(args[0] & 0xffff);
if (args[1]) {
*((int *)Addr68k_from_LADDR(args[1])) = result;
*((int *)NativeAligned4FromLAddr(args[1])) = result;
return (args[1]);
} else
N_ARITH_SWITCH(result);
@@ -278,7 +278,7 @@ void subr_settime(LispPTR args[])
struct dosdate_t dosday;
struct tm uxtime;
uxtime = *localtime((time_t *)(*((int *)Addr68k_from_LADDR(args[0])) - UNIX_ALTO_TIME_DIFF));
uxtime = *localtime((time_t *)(*((int *)NativeAligned4FromLAddr(args[0])) - UNIX_ALTO_TIME_DIFF));
dostime.hsecond = 0;
dostime.second = uxtime.tm_sec;
dostime.minute = uxtime.tm_min;
@@ -292,7 +292,7 @@ void subr_settime(LispPTR args[])
_dos_setdate(&dosday);
#else
struct timeval timev;
timev.tv_sec = *((int *)Addr68k_from_LADDR(args[0])) - UNIX_ALTO_TIME_DIFF;
timev.tv_sec = *((int *)NativeAligned4FromLAddr(args[0])) - UNIX_ALTO_TIME_DIFF;
timev.tv_usec = 0;
settimeofday(&timev, NULL);
#endif
@@ -313,8 +313,8 @@ void subr_copytimestats(LispPTR args[])
{
MISCSTATS *source;
MISCSTATS *dest;
source = (MISCSTATS *)Addr68k_from_LADDR(args[0]);
dest = (MISCSTATS *)Addr68k_from_LADDR(args[1]);
source = (MISCSTATS *)NativeAligned4FromLAddr(args[0]);
dest = (MISCSTATS *)NativeAligned4FromLAddr(args[1]);
update_miscstats();
*dest = *source;
}
@@ -345,7 +345,7 @@ LispPTR N_OP_rclk(LispPTR tos)
gettimeofday(&timev, NULL);
usec = (timev.tv_sec * 1000000UL) + timev.tv_usec;
#endif /* DOS */
*((unsigned int *)(Addr68k_from_LADDR(tos))) = usec;
*((unsigned int *)(NativeAligned4FromLAddr(tos))) = usec;
return (tos);
} /* end N_OP_rclk */

8
src/truecolor.c
View File

@@ -33,7 +33,7 @@
#define IntToFixp(C, Lisp) \
{ \
int *base; \
base = (int *)Addr68k_from_LADDR((unsigned int)Lisp); \
base = (int *)NativeAligned4FromLAddr((unsigned int)Lisp); \
*base = C; \
}
@@ -152,7 +152,7 @@ int TrueColor_Initialize(LispPTR overlay_bmbase)
error("cgeight_init_color_display: Unsupported FBreal_type %d\n", DisplayType);
} /* end if( DisplayType ) */
OverlayRegion68k = Addr68k_from_LADDR(overlay_bmbase);
OverlayRegion68k = NativeAligned2FromLAddr(overlay_bmbase);
size = ((displaywidth * displayheight / 8 + (getpagesize() - 1)) & -getpagesize());
ScreenLocked = T;
@@ -188,7 +188,7 @@ int TrueColor_Initialize(LispPTR overlay_bmbase)
ret_value = (unsigned int *)createcell68k(TYPE_FIXP);
*ret_value = pict;
return (LADDR_from_68k(ret_value));
return (LAddrFromNative(ret_value));
} /* end TrueColor_Initialize */
@@ -204,7 +204,7 @@ int TrueColor_VideoInitialize(LispPTR videoenable_bmbase)
clear_video_region();
Video_Initialize(FrameBufferFd);
VideoEnableRegion68k = Addr68k_from_LADDR(videoenable_bmbase);
VideoEnableRegion68k = NativeAligned2FromLAddr(videoenable_bmbase);
size = ((displaywidth * displayheight / 8 + (getpagesize() - 1)) & -getpagesize());
source = mem_point(displaywidth, displayheight, 1, VideoEnableRegion68k);

8
src/tty.c
View File

@@ -37,9 +37,9 @@ void tty_init(void)
TTY_Dev = "/dev/ttyb"; /* Modify device name */
TTY_Fd = (-1);
DLTTYPortCmd = (DLTTY_OUT_COMMAND *)Addr68k_from_LADDR(IOPAGE_OFFSET + 20);
DLTTYIn = (DLTTY_IN_CSB *)Addr68k_from_LADDR(IOPAGE_OFFSET + 36);
DLTTYOut = (DLTTY_OUT_CSB *)Addr68k_from_LADDR(IOPAGE_OFFSET + 34);
DLTTYPortCmd = (DLTTY_OUT_COMMAND *)NativeAligned2FromLAddr(IOPAGE_OFFSET + 20);
DLTTYIn = (DLTTY_IN_CSB *)NativeAligned2FromLAddr(IOPAGE_OFFSET + 36);
DLTTYOut = (DLTTY_OUT_CSB *)NativeAligned2FromLAddr(IOPAGE_OFFSET + 34);
}
void tty_open(void)
@@ -198,6 +198,6 @@ void tty_debug(const char *name)
printf("DEBUG:\n");
printf("DEBUG: \t\tSymbol Address Contents\n");
printf("DEBUG: \t\tIOPAGE %p\n", (void *)Addr68k_from_LADDR(IOPAGE_OFFSET));
printf("DEBUG: \t\tIOPAGE %p\n", (void *)NativeAligned2FromLAddr(IOPAGE_OFFSET));
/* In the future, we could print out the various fields of DLTTYOut, DLTTYIn, and DLTTYPortCmd */
}

4
src/ubf1.c
View File

@@ -9,7 +9,7 @@
#include "version.h"
#include "adr68k.h" // for LADDR_from_68k
#include "adr68k.h" // for LAddrFromNative
#include "arith.h" // for N_ARITH_SWITCH
#include "lispemul.h" // for state, ERROR_EXIT, DLword, LispPTR
#include "lspglob.h"
@@ -34,7 +34,7 @@ LispPTR N_OP_ubfloat1(int arg, int alpha) {
DLword *wordp;
wordp = createcell68k(TYPE_FLOATP);
*((int *)wordp) = arg;
return (LADDR_from_68k(wordp));
return (LAddrFromNative(wordp));
}
case 1: /* unbox */
{

4
src/ubf3.c
View File

@@ -11,7 +11,7 @@
#include "version.h"
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned4FromLAddr
#include "lispemul.h" // for state, ERROR_EXIT, LispPTR, SEGMASK
#include "lispmap.h" // for S_POSITIVE
#include "lspglob.h"
@@ -36,7 +36,7 @@ LispPTR N_OP_ubfloat3(int arg3, LispPTR arg2, LispPTR arg1, int alpha) {
FPCLEAR;
if ((arg1 & SEGMASK) != S_POSITIVE) ERROR_EXIT(arg1);
degree = 0xFFFF & arg1;
fptr = (float *)Addr68k_from_LADDR(arg2);
fptr = (float *)NativeAligned4FromLAddr(arg2);
ans = *((float *)fptr);
while (degree--) ans = (ans * val) + *((float *)(++fptr));
if (FPTEST(ans)) ERROR_EXIT(arg1); /* relies on contagion of inf, nan? */

8
src/ufn.c
View File

@@ -104,10 +104,10 @@ void ufn(DLword bytecode)
/* Get Next Block offset form OPCODE byte */
CURRENTFX->nextblock =
(LADDR_from_68k(CurrentStackPTR) & 0x0ffff) - (entry68k->arg_num << 1) + 2 /** +1 **/;
(LAddrFromNative(CurrentStackPTR) & 0x0ffff) - (entry68k->arg_num << 1) + 2 /** +1 **/;
/* Setup IVar */
IVar = Addr68k_from_LADDR((((LispPTR)(CURRENTFX->nextblock)) | STK_OFFSET));
IVar = NativeAligned2FromLAddr((((LispPTR)(CURRENTFX->nextblock)) | STK_OFFSET));
#ifdef LISPTRACE
print(entry68k->atom_name);
@@ -133,7 +133,7 @@ void ufn(DLword bytecode)
}
/* Nov 25 87 take */
tmp_fn = (struct fnhead *)Addr68k_from_LADDR(defcell68k->defpointer);
tmp_fn = (struct fnhead *)NativeAligned4FromLAddr(defcell68k->defpointer);
/* stack overflow check STK_SAFE is redundant?? */
if ((UNSIGNED)(CurrentStackPTR + tmp_fn->stkmin + STK_SAFE) >= (UNSIGNED)StkLimO) {
@@ -166,7 +166,7 @@ void ufn(DLword bytecode)
/* Set up FX */
GETWORD(CurrentStackPTR) = FX_MARK;
((struct frameex1 *)CurrentStackPTR)->alink = LADDR_from_68k(PVar);
((struct frameex1 *)CurrentStackPTR)->alink = LAddrFromNative(PVar);
PVar = (DLword *)CurrentStackPTR + FRAMESIZE;
#ifdef BIGVM
((struct frameex1 *)CurrentStackPTR)->fnheader = (defcell68k->defpointer);

8
src/ufs.c
View File

@@ -161,7 +161,7 @@ LispPTR UFS_getfilename(LispPTR *args)
char lfname[MAXPATHLEN], file[MAXPATHLEN];
ERRSETJMP(NIL);
Lisp_errno = (int *)(Addr68k_from_LADDR(args[3]));
Lisp_errno = (int *)(NativeAligned4FromLAddr(args[3]));
LispStringLength(args[0], len, rval);
len += 1; /* Add 1 for terminating NULL char. */
@@ -248,7 +248,7 @@ LispPTR UFS_deletefile(LispPTR *args)
int len, rval;
ERRSETJMP(NIL);
Lisp_errno = (int *)(Addr68k_from_LADDR(args[1]));
Lisp_errno = (int *)(NativeAligned4FromLAddr(args[1]));
LispStringLength(args[0], len, rval);
len += 1;
@@ -313,7 +313,7 @@ LispPTR UFS_renamefile(LispPTR *args)
int rval, len;
ERRSETJMP(NIL);
Lisp_errno = (int *)(Addr68k_from_LADDR(args[2]));
Lisp_errno = (int *)(NativeAligned4FromLAddr(args[2]));
LispStringLength(args[0], len, rval);
len += 1;
@@ -387,7 +387,7 @@ LispPTR UFS_directorynamep(LispPTR *args)
struct stat sbuf;
ERRSETJMP(NIL);
Lisp_errno = (int *)(Addr68k_from_LADDR(args[2]));
Lisp_errno = (int *)(NativeAligned4FromLAddr(args[2]));
LispStringLength(args[0], len, rval);
len += 1;

4
src/unixcomm.c
View File

@@ -699,7 +699,7 @@ LispPTR Unix_handlecomm(LispPTR *args) {
N_GETNUMBER(args[1], slot, bad); /* Get job # */
if (!valid_slot(slot)) return (NIL); /* No fd open; punt the read */
bufp = (Addr68k_from_LADDR(args[2])); /* User buffer */
bufp = (NativeAligned2FromLAddr(args[2])); /* User buffer */
DBPRINT(("Read buffer slot %d, type is %d\n", slot, UJ[slot].type));
switch (UJ[slot].type) {
@@ -854,7 +854,7 @@ LispPTR Unix_handlecomm(LispPTR *args) {
DLword *bufp;
int i;
N_GETNUMBER(args[1], slot, bad); /* Get job # */
bufp = (Addr68k_from_LADDR(args[2])); /* User buffer */
bufp = (NativeAligned2FromLAddr(args[2])); /* User buffer */
N_GETNUMBER(args[3], i, bad); /* # to write */
DBPRINT(("Write buffer, type is %d\n", UJ[slot].type));

8
src/unwind.c
View File

@@ -116,7 +116,7 @@ LispPTR find_the_blip(LispPTR blip, LispPTR throwp, FX *unwinder)
LispPTR CATCH_RETURN_FROM_ATOM = parse_atomstring("SI::*CATCH-RETURN-FROM*");
for (target = (LispPTR)unwinder; FX_INVALIDP(target); GETCLINK(target_addr)) {
target_addr = (FX *)Addr68k_from_StkOffset(target);
target_addr = (FX *)NativeAligned4FromStackOffset(target);
if (blip == *target_addr) {
LispPTR var_name_in_frame = variable_name_in_frame(target_addr, (FVPVAR << 8) + 1);
if (var_name_in_frame == CATCH_RETURN_TO_ATOM) {
@@ -136,7 +136,7 @@ LispPTR find_the_blip(LispPTR blip, LispPTR throwp, FX *unwinder)
no_result:
return (NIL_PTR);
cons_result:
return (cons(StkOffset_from_68K(target), pc));
return (cons(StackOffsetFromNative(target), pc));
}
LispPTR variable_name_in_frame(FX *fx_addr, LispPTR code)
@@ -146,7 +146,7 @@ LispPTR variable_name_in_frame(FX *fx_addr, LispPTR code)
DLword *name_table_base;
DLword value;
name_table_base = Addr68k_from_LADDR(GETNAMETABLE(fx_addr));
name_table_base = NativeAligned2FromLAddr(GETNAMETABLE(fx_addr));
name_ptr = name_table_base + FNHEADSIZE;
name_table_base = name_ptr + ((FNHEAD *)name_table_base)->ntsize;
@@ -173,7 +173,7 @@ LispPTR pvar_value_in_frame(FX *frame_addr, LispPTR atom_index)
DLword *name_table_base;
DLword value;
name_table_base = Addr68k_from_LADDR(GETNAMETABLE(frame_addr));
name_table_base = NativeAligned2FromLAddr(GETNAMETABLE(frame_addr));
name_ptr = name_table_base + FNHEADSIZE;
name_table_base = name_ptr + ((FNHEAD *)name_table_base)->ntsize;

32
src/uraid.c
View File

@@ -415,24 +415,24 @@ LispPTR uraid_commands() {
switch (URaid_arg1[0]) {
case 'k':
printf("IFP->KBDFXP :\n");
bt1((FX*)Addr68k_from_StkOffset(InterfacePage->kbdfxp));
bt1((FX *)NativeAligned4FromStackOffset(InterfacePage->kbdfxp));
break;
case 'm':
printf("IFP->MISCFXP :\n");
bt1((FX*)Addr68k_from_StkOffset(InterfacePage->miscfxp));
bt1((FX *)NativeAligned4FromStackOffset(InterfacePage->miscfxp));
break;
case 'r':
printf("IFP->RESETFXP :\n");
bt1((FX*)Addr68k_from_StkOffset(InterfacePage->resetfxp));
bt1((FX *)NativeAligned4FromStackOffset(InterfacePage->resetfxp));
break;
case 'g':
printf("IFP->GCFXP :\n");
bt1((FX*)Addr68k_from_StkOffset(InterfacePage->gcfxp));
bt1((FX *)NativeAligned4FromStackOffset(InterfacePage->gcfxp));
break;
case 'p':
printf("IFP->FAULTFXP :\n");
bt1((FX*)Addr68k_from_StkOffset(InterfacePage->faultfxp));
bt1((FX *)NativeAligned4FromStackOffset(InterfacePage->faultfxp));
break;
case 'u': bt(); break;
@@ -477,9 +477,9 @@ LispPTR uraid_commands() {
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));
printf("CSTKP : 0x%x\n", LAddrFromNative(CurrentStackPTR));
printf("PVAR : 0x%x\n", LAddrFromNative(PVar));
printf("IVAR : 0x%x\n", LAddrFromNative(IVar));
printPC();
putchar('\n');
break;
@@ -645,11 +645,11 @@ LispPTR uraid_commands() {
{
int i;
DLword *ptr, *endptr;
ptr = (DLword *)Addr68k_from_LADDR(address);
ptr = (DLword *)NativeAligned2FromLAddr(address);
endptr = ptr + num;
while (ptr < endptr) {
printf("0x%x : ", LADDR_from_68k(ptr));
printf("0x%x : ", LAddrFromNative(ptr));
for (i = 0; ((ptr < endptr) && (i < XDUMPW)); ptr++, i++) { printf("%4x ", *ptr); }
putchar('\n');
@@ -727,7 +727,7 @@ LispPTR uraid_commands() {
{
DLword *ptr;
ptr = (DLword *)Addr68k_from_LADDR(address);
ptr = (DLword *)NativeAligned2FromLAddr(address);
*ptr = val;
printf("0x%x : 0x%x\n", address, *ptr);
}
@@ -910,21 +910,21 @@ char *alloc_hideDISP(int size)
case 0 :
case SFS_SWITCHABLE :
retaddr =
(char*)Addr68k_from_LADDR((*ArraySpace2_word) & POINTERMASK);
(char *)NativeAligned2FromLAddr((*ArraySpace2_word) & POINTERMASK);
printf("Hidespace inside Lisp(2)\n");
break;
case SFS_ARRAYSWITCHED :
retaddr=(char*)Addr68k_from_LADDR(*Next_Array_word & 0xffff);
retaddr=(char *)NativeAligned2FromLAddr(*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)
if((UNSIGNED)NativeAligned2FromLAddr(*Next_MDSpage_word & 0xffff)
- (UNSIGNED)NativeAligned2FromLAddr(*Next_Array_word & 0xffff)
>size) {
retaddr= (char*)Addr68k_from_LADDR(*Next_Array_word & 0xffff);
retaddr= (char *)NativeAligned2FromLAddr(*Next_Array_word & 0xffff);
printf("Hidespace inside Lisp(4)\n");
}
else if((retaddr=malloc(size)) ==0){

10
src/uutils.c
View File

@@ -27,7 +27,7 @@
#include <stdlib.h> // for getenv
#include <string.h> // for strcmp, strcpy, strlen, strncpy
#include <unistd.h> // for getuid, gethostid, gethostname, getpgrp
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned4FromLAddr
#include "keyboard.h" // for KBEVENT, KB_ALLUP, RING, KEYEVENTSIZE, MAXKE...
#include "lispemul.h" // for LispPTR, DLword, NIL, ATOM_T
#include "lspglob.h"
@@ -52,12 +52,12 @@ static int lisp_string_to_c_string(LispPTR Lisp, char *C, size_t length) {
if (GetTypeNumber(Lisp) != TYPE_ONED_ARRAY) { return (-1); }
arrayp = (OneDArray *)(Addr68k_from_LADDR(Lisp));
arrayp = (OneDArray *)NativeAligned4FromLAddr(Lisp);
if (arrayp->fillpointer >= length) { return (-1); } /* too long */
switch (arrayp->typenumber) {
case THIN_CHAR_TYPENUMBER:
base = ((char *)(Addr68k_from_LADDR(arrayp->base))) + ((int)(arrayp->offset));
base = ((char *)NativeAligned2FromLAddr(arrayp->base)) + ((int)(arrayp->offset));
#ifndef BYTESWAP
strncpy(C, base, arrayp->fillpointer);
#else
@@ -96,13 +96,13 @@ static int c_string_to_lisp_string(char *C, LispPTR Lisp) {
length = strlen(C);
if (GetTypeNumber(Lisp) != TYPE_ONED_ARRAY) { return (-1); }
arrayp = (OneDArray *)(Addr68k_from_LADDR(Lisp));
arrayp = (OneDArray *)NativeAligned4FromLAddr(Lisp);
if (arrayp->totalsize < length + 1) { return (-1); }
/* too short for C string */
switch (arrayp->typenumber) {
case THIN_CHAR_TYPENUMBER:
base = ((char *)(Addr68k_from_LADDR(arrayp->base))) + ((int)(arrayp->offset));
base = ((char *)NativeAligned2FromLAddr(arrayp->base)) + ((int)(arrayp->offset));
#ifndef BYTESWAP
strcpy(base, C);
#else

10
src/vars3.c
View File

@@ -9,7 +9,7 @@
#include "version.h"
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned4FromLAddr
#include "car-cdrdefs.h" // for car, cdr
#include "cell.h" // for cadr_cell, CDR_NIL, CDR_INDIRECT, S_N_CHECK...
#include "emlglob.h"
@@ -47,11 +47,11 @@ struct cadr_cell cadr(LispPTR cell_adr)
return (cadr1);
}
}
pcons = (ConsCell *)Addr68k_from_LADDR(cell_adr);
pcons = (ConsCell *)NativeAligned4FromLAddr(cell_adr);
while (pcons->cdr_code == CDR_INDIRECT) {
/* CDR indirect */
cell_adr = pcons->car_field;
pcons = (ConsCell *)Addr68k_from_LADDR(pcons->car_field);
pcons = (ConsCell *)NativeAligned4FromLAddr(pcons->car_field);
} /* skip CDR_INDIRECT cell */
cadr1.car_cell = pcons->car_field;
@@ -68,7 +68,7 @@ struct cadr_cell cadr(LispPTR cell_adr)
cadr1.cdr_cell = cell_adr + offset;
} else {
/* CDR different page */
pcons = (ConsCell *)Addr68k_from_LADDR((cell_adr) + offset);
pcons = (ConsCell *)NativeAligned4FromLAddr((cell_adr) + offset);
cadr1.cdr_cell = pcons->car_field;
}
#else
@@ -78,7 +78,7 @@ struct cadr_cell cadr(LispPTR cell_adr)
cadr1.cdr_cell = (mPAGEMASK & cell_adr) | offset;
} else {
/* CDR different page */
pcons = (ConsCell *)Addr68k_from_LADDR(((mPAGEMASK & cell_adr) | offset));
pcons = (ConsCell *)NativeAligned4FromLAddr(((mPAGEMASK & cell_adr) | offset));
cadr1.cdr_cell = pcons->car_field;
}
#endif /* NEWCDRCODING */

2
src/vmemsave.c
View File

@@ -96,7 +96,7 @@ extern int please_fork;
int lispstringP(LispPTR Lisp)
{
switch (((OneDArray *)(Addr68k_from_LADDR(Lisp)))->typenumber) {
switch (((OneDArray *)(NativeAligned4FromLAddr(Lisp)))->typenumber) {
case THIN_CHAR_TYPENUMBER:
case FAT_CHAR_TYPENUMBER: return (1);

10
src/xc.c
View File

@@ -243,7 +243,7 @@ op_ufn : {
nextopcode:
#ifdef MYOPTRACE
if ((struct fnhead *)Addr68k_from_LADDR(0x2ed600) == FuncObj) {
if ((struct fnhead *)NativeAligned4FromLAddr(0x2ed600) == FuncObj) {
quick_stack_check();
#endif /* MYOPTRACE */
OPTPRINT(("PC= %p (fn+%td) op= %02x TOS= 0x%x\n", (void *)PCMAC, PCMAC - (char *)FuncObj, Get_BYTE_PCMAC0, TOPOFSTACK));
@@ -254,7 +254,7 @@ nextopcode:
#ifdef PCTRACE
/* Tracing PC/Function/Opcode in a ring buffer */
pc_table[pccounter] = (int)PCMAC - (int)FuncObj;
fn_table[pccounter] = (LispPTR)LADDR_from_68k(FuncObj);
fn_table[pccounter] = (LispPTR)LAddrFromNative(FuncObj);
op_table[pccounter] = Get_BYTE_PCMAC0;
if (99 == pccounter++) pccounter = 0;
#endif /* PCTRACE */
@@ -1122,7 +1122,7 @@ check_interrupt:
}
if ((Irq_Stk_End <= 0) || (Irq_Stk_Check <= 0) || need_irq) {
if (StkOffset_from_68K(CSTKPTR) > InterfacePage->stackbase) {
if (StackOffsetFromNative(CSTKPTR) > InterfacePage->stackbase) {
/* Interrupts not Disabled */
EXT;
update_timer();
@@ -1199,7 +1199,7 @@ check_interrupt:
*Reclaim_cnt_word = NIL;
cause_interruptcall(DORECLAIM_index);
} else if (*PENDINGINTERRUPT68k != NIL) {
INTSTAT2 *intstate = ((INTSTAT2 *)Addr68k_from_LADDR(*INTERRUPTSTATE_word));
INTSTAT2 *intstate = ((INTSTAT2 *)NativeAligned4FromLAddr(*INTERRUPTSTATE_word));
/*unsigned char newints = (intstate->pendingmask) & ~(intstate->handledmask);
if (newints) */
{
@@ -1208,7 +1208,7 @@ check_interrupt:
cause_interruptcall(INTERRUPTFRAME_index);
}
} else if (ETHEREventCount > 0) {
INTSTAT *intstate = ((INTSTAT *)Addr68k_from_LADDR(*INTERRUPTSTATE_word));
INTSTAT *intstate = ((INTSTAT *)NativeAligned4FromLAddr(*INTERRUPTSTATE_word));
if (!(intstate->ETHERInterrupt) && !(((INTSTAT2 *)intstate)->handledmask & 0x40)) {
intstate->ETHERInterrupt = 1;
((INTSTAT2 *)intstate)->handledmask |= ((INTSTAT2 *)intstate)->pendingmask;

4
src/xinit.c
View File

@@ -16,7 +16,7 @@
#include <signal.h> // for sig_atomic_t
#include <stdbool.h> // for false, bool, true
#include <stdio.h> // for NULL
#include "adr68k.h" // for Addr68k_from_LADDR
#include "adr68k.h" // for NativeAligned4FromLAddr
#include "dbprint.h" // for TPRINT
#include "devif.h" // for (anonymous), MRegion, DspInterface, OUTER_S...
#include "dspifdefs.h" // for GenericReturnT
@@ -288,7 +288,7 @@ DspInterface X_init(DspInterface dsp, LispPTR lispbitmap, int width_hint, int he
dsp->ScreenBitmap.byte_order = MSBFirst;
#endif /* BYTESWAP */
dsp->ScreenBitmap.data = (char *)(lispbitmap ? Addr68k_from_LADDR((LispPTR)lispbitmap) : 0);
dsp->ScreenBitmap.data = (char *)(lispbitmap ? NativeAligned4FromLAddr((LispPTR)lispbitmap) : 0);
switch (depth_hint) {
case 8: /* Color Screen */