diff --git a/inc/adr68k.h b/inc/adr68k.h index 8fd36a9..1b8cb47 100644 --- a/inc/adr68k.h +++ b/inc/adr68k.h @@ -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 +#include +#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 */ diff --git a/inc/arith.h b/inc/arith.h index d538f0d..71a815a 100644 --- a/inc/arith.h +++ b/inc/arith.h @@ -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) diff --git a/inc/cell.h b/inc/cell.h index 391144a..84b4670 100644 --- a/inc/cell.h +++ b/inc/cell.h @@ -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 */ diff --git a/inc/inlineC.h b/inc/inlineC.h index f473268..bd3cdf7 100644 --- a/inc/inlineC.h +++ b/inc/inlineC.h @@ -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) diff --git a/inc/inlnSPARC.h b/inc/inlnSPARC.h index 07e00ef..660cad5 100644 --- a/inc/inlnSPARC.h +++ b/inc/inlnSPARC.h @@ -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;} diff --git a/inc/locfile.h b/inc/locfile.h index 0f32f0c..c45c80a 100644 --- a/inc/locfile.h +++ b/inc/locfile.h @@ -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 diff --git a/inc/mnxdefs.h b/inc/mnxdefs.h index 5fc3580..b58ac4b 100644 --- a/inc/mnxdefs.h +++ b/inc/mnxdefs.h @@ -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)) diff --git a/inc/my.h b/inc/my.h index a55de8b..20bd233 100644 --- a/inc/my.h +++ b/inc/my.h @@ -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); \ diff --git a/inc/return.h b/inc/return.h index 91ee10c..85d7478 100644 --- a/inc/return.h +++ b/inc/return.h @@ -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; \ diff --git a/inc/stack.h b/inc/stack.h index 1552a27..63ae579 100644 --- a/inc/stack.h +++ b/inc/stack.h @@ -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); \ diff --git a/inc/tosfns.h b/inc/tosfns.h index 9f262c1..62105c6 100644 --- a/inc/tosfns.h +++ b/inc/tosfns.h @@ -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; \ diff --git a/inc/tosret.h b/inc/tosret.h index 16eac9d..43d49ab 100644 --- a/inc/tosret.h +++ b/inc/tosret.h @@ -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)) \ diff --git a/src/allocmds.c b/src/allocmds.c index c432538..a0dc2ee 100644 --- a/src/allocmds.c +++ b/src/allocmds.c @@ -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 */ diff --git a/src/arithops.c b/src/arithops.c index 2334966..9bee65e 100644 --- a/src/arithops.c +++ b/src/arithops.c @@ -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: diff --git a/src/arrayops.c b/src/arrayops.c index b0df307..5ca2dd7 100644 --- a/src/arrayops.c +++ b/src/arrayops.c @@ -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 */ diff --git a/src/bbtsub.c b/src/bbtsub.c index d5877d8..6e02b48 100644 --- a/src/bbtsub.c +++ b/src/bbtsub.c @@ -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 diff --git a/src/bin.c b/src/bin.c index 764bf36..37de20e 100644 --- a/src/bin.c +++ b/src/bin.c @@ -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)++))); diff --git a/src/bitblt.c b/src/bitblt.c index 6fae33f..9967ff8 100644 --- a/src/bitblt.c +++ b/src/bitblt.c @@ -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); diff --git a/src/blt.c b/src/blt.c index b55f1b4..4e0cac3 100644 --- a/src/blt.c +++ b/src/blt.c @@ -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); diff --git a/src/car-cdr.c b/src/car-cdr.c index 8721f68..d0f791e 100644 --- a/src/car-cdr.c +++ b/src/car-cdr.c @@ -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); } diff --git a/src/chardev.c b/src/chardev.c index a3c202f..8fcf0ff 100644 --- a/src/chardev.c +++ b/src/chardev.c @@ -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 diff --git a/src/chatter.c b/src/chatter.c index 33f7ece..841b355 100644 --- a/src/chatter.c +++ b/src/chatter.c @@ -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; \ } diff --git a/src/conspage.c b/src/conspage.c index faca254..561bcfb 100644 --- a/src/conspage.c +++ b/src/conspage.c @@ -16,7 +16,7 @@ #include // 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))) diff --git a/src/dbgtool.c b/src/dbgtool.c index ed2de64..1cb305b 100644 --- a/src/dbgtool.c +++ b/src/dbgtool.c @@ -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"); diff --git a/src/dir.c b/src/dir.c index e0cf39d..c5dd06a 100644 --- a/src/dir.c +++ b/src/dir.c @@ -25,7 +25,7 @@ #include // for strcpy, strcmp, strlen, strrchr, strcat #include // for stat, S_ISDIR, st_atime, st_mtime #include // 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; diff --git a/src/draw.c b/src/draw.c index 4c191f6..cd12310 100644 --- a/src/draw.c +++ b/src/draw.c @@ -19,7 +19,7 @@ #include // for ptrdiff_t #include // 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; diff --git a/src/dsk.c b/src/dsk.c index 96068a4..e59bb6f 100644 --- a/src/dsk.c +++ b/src/dsk.c @@ -19,7 +19,7 @@ #include // for ino_t, time_t, off_t #include // 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 diff --git a/src/ejlisp.c b/src/ejlisp.c index 13726b9..09ca3fc 100644 --- a/src/ejlisp.c +++ b/src/ejlisp.c @@ -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]); diff --git a/src/ether.c b/src/ether.c index 57ff507..1d8bb99 100644 --- a/src/ether.c +++ b/src/ether.c @@ -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) diff --git a/src/findkey.c b/src/findkey.c index 99f6f07..88d250a 100644 --- a/src/findkey.c +++ b/src/findkey.c @@ -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; } diff --git a/src/foreign.c b/src/foreign.c index afc2705..3052a29 100644 --- a/src/foreign.c +++ b/src/foreign.c @@ -18,6 +18,7 @@ #include #include +#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; } } diff --git a/src/fp.c b/src/fp.c index 37cc43b..ddd3339 100644 --- a/src/fp.c +++ b/src/fp.c @@ -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() */ /************************************************************************/ diff --git a/src/fvar.c b/src/fvar.c index e3b22f3..d01502b 100644 --- a/src/fvar.c +++ b/src/fvar.c @@ -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; } diff --git a/src/gcarray.c b/src/gcarray.c index d93e841..e25dc37 100644 --- a/src/gcarray.c +++ b/src/gcarray.c @@ -44,7 +44,7 @@ #include // for printf #include // 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 */ diff --git a/src/gccode.c b/src/gccode.c index 2db1bfc..fe91225 100644 --- a/src/gccode.c +++ b/src/gccode.c @@ -31,7 +31,7 @@ #include // 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); diff --git a/src/gcfinal.c b/src/gcfinal.c index cd19fae..5b6cf96 100644 --- a/src/gcfinal.c +++ b/src/gcfinal.c @@ -44,7 +44,7 @@ #include // 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; diff --git a/src/gchtfind.c b/src/gchtfind.c index c2c4d27..300ebe3 100644 --- a/src/gchtfind.c +++ b/src/gchtfind.c @@ -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)); } } diff --git a/src/gcmain3.c b/src/gcmain3.c index 4b7e41d..0134c00 100644 --- a/src/gcmain3.c +++ b/src/gcmain3.c @@ -35,7 +35,7 @@ #include // 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); diff --git a/src/gcr.c b/src/gcr.c index c89c624..59e6515 100644 --- a/src/gcr.c +++ b/src/gcr.c @@ -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; diff --git a/src/gcrcell.c b/src/gcrcell.c index a191b2d..43c8ca0 100644 --- a/src/gcrcell.c +++ b/src/gcrcell.c @@ -65,7 +65,7 @@ #include // 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"); diff --git a/src/gvar2.c b/src/gvar2.c index 7a7fc93..870bb25 100644 --- a/src/gvar2.c +++ b/src/gvar2.c @@ -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); } diff --git a/src/hardrtn.c b/src/hardrtn.c index 3c454dd..df87969 100644 --- a/src/hardrtn.c +++ b/src/hardrtn.c @@ -23,7 +23,7 @@ */ /********************************************************************/ #include // 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) diff --git a/src/inet.c b/src/inet.c index 7be2735..4c11d19 100644 --- a/src/inet.c +++ b/src/inet.c @@ -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); diff --git a/src/initsout.c b/src/initsout.c index 50c41e3..78f7608 100644 --- a/src/initsout.c +++ b/src/initsout.c @@ -25,7 +25,7 @@ #include // for strlen, strncpy #include // for time_t #include // 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"); diff --git a/src/intcall.c b/src/intcall.c index d2b7a94..db33d8e 100644 --- a/src/intcall.c +++ b/src/intcall.c @@ -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 */ diff --git a/src/keyevent.c b/src/keyevent.c index b7773ae..0e25335 100644 --- a/src/keyevent.c +++ b/src/keyevent.c @@ -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; diff --git a/src/kprint.c b/src/kprint.c index 8cd5909..dd4d658 100644 --- a/src/kprint.c +++ b/src/kprint.c @@ -12,7 +12,7 @@ #include // 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); } diff --git a/src/ldsout.c b/src/ldsout.c index c7adba0..6dedd44 100644 --- a/src/ldsout.c +++ b/src/ldsout.c @@ -18,7 +18,7 @@ #include // for mmap #include // for stat, fstat #include // 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 */ diff --git a/src/lisp2c.c b/src/lisp2c.c index 046eded..e21e2b1 100644 --- a/src/lisp2c.c +++ b/src/lisp2c.c @@ -14,7 +14,7 @@ #include // for sprintf #include // 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! */ diff --git a/src/llcolor.c b/src/llcolor.c index b80cd70..7417805 100644 --- a/src/llcolor.c +++ b/src/llcolor.c @@ -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 */ diff --git a/src/llstk.c b/src/llstk.c index a9f1828..8ab171a 100644 --- a/src/llstk.c +++ b/src/llstk.c @@ -22,7 +22,7 @@ #include // for printf, putchar #include // 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)); diff --git a/src/loopsops.c b/src/loopsops.c index 7817924..0bcabf9 100644 --- a/src/loopsops.c +++ b/src/loopsops.c @@ -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); diff --git a/src/lowlev1.c b/src/lowlev1.c index e3c0fe6..45fb924 100644 --- a/src/lowlev1.c +++ b/src/lowlev1.c @@ -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. <> @@ -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); } diff --git a/src/lowlev2.c b/src/lowlev2.c index 184686d..3e3bb4d 100644 --- a/src/lowlev2.c +++ b/src/lowlev2.c @@ -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); } diff --git a/src/lpmain.c b/src/lpmain.c index c5e6446..b896c35 100644 --- a/src/lpmain.c +++ b/src/lpmain.c @@ -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) diff --git a/src/main.c b/src/main.c index 5640d45..2cd69c9 100644 --- a/src/main.c +++ b/src/main.c @@ -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!"); diff --git a/src/misc7.c b/src/misc7.c index db4fcbe..58d0904 100644 --- a/src/misc7.c +++ b/src/misc7.c @@ -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); diff --git a/src/mkatom.c b/src/mkatom.c index 45af0ed..f88c7c9 100644 --- a/src/mkatom.c +++ b/src/mkatom.c @@ -33,7 +33,7 @@ #ifndef BYTESWAP #include // 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)) { diff --git a/src/mkcell.c b/src/mkcell.c index 84b5522..fab09e0 100644 --- a/src/mkcell.c +++ b/src/mkcell.c @@ -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); diff --git a/src/mnwevent.c b/src/mnwevent.c index 04779a9..1c90c41 100644 --- a/src/mnwevent.c +++ b/src/mnwevent.c @@ -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: diff --git a/src/mvs.c b/src/mvs.c index 8d1f0e8..ad34b64 100644 --- a/src/mvs.c +++ b/src/mvs.c @@ -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); } diff --git a/src/osmsg.c b/src/osmsg.c index 0b4a51f..3e5e0a8 100644 --- a/src/osmsg.c +++ b/src/osmsg.c @@ -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)); diff --git a/src/picture.c b/src/picture.c index 31f3dde..5014ff1 100644 --- a/src/picture.c +++ b/src/picture.c @@ -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); diff --git a/src/rawcolor.c b/src/rawcolor.c index 7052b51..ce15095 100644 --- a/src/rawcolor.c +++ b/src/rawcolor.c @@ -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); diff --git a/src/rawrs232c.c b/src/rawrs232c.c index 36d6f1e..3dcb9d0 100644 --- a/src/rawrs232c.c +++ b/src/rawrs232c.c @@ -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 :"); diff --git a/src/return.c b/src/return.c index 22b7cce..d0eebed 100644 --- a/src/return.c +++ b/src/return.c @@ -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; diff --git a/src/rpc.c b/src/rpc.c index b501a61..c2009ee 100644 --- a/src/rpc.c +++ b/src/rpc.c @@ -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); diff --git a/src/rplcons.c b/src/rplcons.c index 68dc246..7d72ae5 100644 --- a/src/rplcons.c +++ b/src/rplcons.c @@ -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 */ diff --git a/src/rs232c.c b/src/rs232c.c index 885e690..9576f6e 100644 --- a/src/rs232c.c +++ b/src/rs232c.c @@ -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*) diff --git a/src/storage.c b/src/storage.c index 291a194..8ec6165 100644 --- a/src/storage.c +++ b/src/storage.c @@ -18,7 +18,7 @@ /*****************************************************************/ #include // 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; } diff --git a/src/subr.c b/src/subr.c index 6a85db5..ce7e391 100644 --- a/src/subr.c +++ b/src/subr.c @@ -30,7 +30,7 @@ #include // for printf, sprintf, NULL #include // 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; diff --git a/src/subr0374.c b/src/subr0374.c index 1805c7f..3a76988 100644 --- a/src/subr0374.c +++ b/src/subr0374.c @@ -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); diff --git a/src/sxhash.c b/src/sxhash.c index b102c11..be786c5 100644 --- a/src/sxhash.c +++ b/src/sxhash.c @@ -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 diff --git a/src/testtool.c b/src/testtool.c index cdf5695..37c0cf4 100644 --- a/src/testtool.c +++ b/src/testtool.c @@ -47,7 +47,7 @@ #include // for printf, putchar, fflush, getchar, stdin #include // for exit #include // 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; } } diff --git a/src/timer.c b/src/timer.c index dfa4078..9408fe0 100644 --- a/src/timer.c +++ b/src/timer.c @@ -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 */ diff --git a/src/truecolor.c b/src/truecolor.c index c8bb453..a23bd13 100644 --- a/src/truecolor.c +++ b/src/truecolor.c @@ -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); diff --git a/src/tty.c b/src/tty.c index bae7171..86447cd 100644 --- a/src/tty.c +++ b/src/tty.c @@ -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 */ } diff --git a/src/ubf1.c b/src/ubf1.c index 9911ae3..d0f8e03 100644 --- a/src/ubf1.c +++ b/src/ubf1.c @@ -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 */ { diff --git a/src/ubf3.c b/src/ubf3.c index d39f3fa..845ad11 100644 --- a/src/ubf3.c +++ b/src/ubf3.c @@ -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? */ diff --git a/src/ufn.c b/src/ufn.c index cfa5450..3f64be2 100644 --- a/src/ufn.c +++ b/src/ufn.c @@ -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); diff --git a/src/ufs.c b/src/ufs.c index 6f41e88..c0b3269 100644 --- a/src/ufs.c +++ b/src/ufs.c @@ -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; diff --git a/src/unixcomm.c b/src/unixcomm.c index 5f8dfe7..0c9a18f 100644 --- a/src/unixcomm.c +++ b/src/unixcomm.c @@ -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)); diff --git a/src/unwind.c b/src/unwind.c index 6ec66e2..6285f59 100644 --- a/src/unwind.c +++ b/src/unwind.c @@ -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; diff --git a/src/uraid.c b/src/uraid.c index 69eb0e3..cb2c9d6 100644 --- a/src/uraid.c +++ b/src/uraid.c @@ -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){ diff --git a/src/uutils.c b/src/uutils.c index 0de5d5d..5a6607b 100644 --- a/src/uutils.c +++ b/src/uutils.c @@ -27,7 +27,7 @@ #include // for getenv #include // for strcmp, strcpy, strlen, strncpy #include // 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 diff --git a/src/vars3.c b/src/vars3.c index 825031b..8de5e6c 100644 --- a/src/vars3.c +++ b/src/vars3.c @@ -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 */ diff --git a/src/vmemsave.c b/src/vmemsave.c index ba0720a..0e2aad6 100644 --- a/src/vmemsave.c +++ b/src/vmemsave.c @@ -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); diff --git a/src/xc.c b/src/xc.c index 7f7b4db..cec2e9e 100644 --- a/src/xc.c +++ b/src/xc.c @@ -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; diff --git a/src/xinit.c b/src/xinit.c index 0c87d1d..10ebb38 100644 --- a/src/xinit.c +++ b/src/xinit.c @@ -16,7 +16,7 @@ #include // for sig_atomic_t #include // for false, bool, true #include // 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 */