#ifndef INLINEC_H
#define INLINEC_H 1

/* $Id: inlineC.h,v 1.3 1999/01/03 02:06:02 sybalsky Exp $ (C) Copyright Venue, All Rights Reserved
 */

/************************************************************************/
/*                                                                      */
/*      (C) Copyright 1989-92 Venue. All Rights Reserved.               */
/*      Manufactured in the United States of America.                   */
/*                                                                      */
/************************************************************************/

/*
        These are the Macros Used to generate inline c code.
        These are the goto ni definitions of the opcodes.
*/

/************************************************************************/
/*                                                                      */
/*          Macros for fetching bytes & words PC-relative               */
/*                                                                      */
/*      These are this way so that they can be redefined for the 386i,  */
/*      where it makes a difference in speed if you know in advance.    */
/*                                                                      */
/************************************************************************/

#define Get_BYTE_PCMAC0 Get_BYTE(PCMAC)
#define Get_BYTE_PCMAC1 Get_BYTE(PCMAC + 1)
#define Get_BYTE_PCMAC2 Get_BYTE(PCMAC + 2)
#define Get_BYTE_PCMAC3 Get_BYTE(PCMAC + 3)

#define Get_DLword_PCMAC0 Get_DLword(PCMAC)
#define Get_DLword_PCMAC1 Get_DLword(PCMAC + 1)
#define Get_DLword_PCMAC2 Get_DLword(PCMAC + 2)
#define Get_DLword_PCMAC3 Get_DLword(PCMAC + 3)

#define Get_Pointer_PCMAC0
#define Get_Pointer_PCMAC1 Get_Pointer(PCMAC + 1)
#define Get_Pointer_PCMAC2 Get_Pointer(PCMAC + 2)

/* For getting a signed byte */
#ifndef BYTESWAP
/* in the unswapped case, the type of the argument carries through to the result */
#define Get_SBYTE_PCMAC0 GETBYTE((int8_t *)PCMAC)
#define Get_SBYTE_PCMAC1 GETBYTE((int8_t *)PCMAC + 1)
#else
/* cf. GETBYTE in lsptypes.h */
#define Get_SBYTE_PCMAC0 (*(int8_t *)(3 ^ (UNSIGNED)(PCMAC)))
#define Get_SBYTE_PCMAC1 (*(int8_t *)(3 ^ (UNSIGNED)(PCMAC + 1)))
#endif

/* for getting an atom number, e.g., for FNx or DTEST */
#ifdef BIGATOMS
#define Get_AtomNo_PCMAC1 Get_Pointer_PCMAC1
#define Get_AtomNo_PCMAC2 Get_Pointer_PCMAC2
#ifdef BIGVM
#define nextop_atom nextop5
#define nextop_ptr nextop5
#else
#define nextop_atom nextop4
#define nextop_ptr nextop4
#endif /* BIGVM */
#else
#define Get_AtomNo_PCMAC1 Get_DLword_PCMAC1
#define Get_AtomNo_PCMAC2 Get_DLword_PCMAC2
#define nextop_atom nextop3
#define nextop_ptr nextop4
#endif /* BIGATOMS */

#define CHECK_INTERRUPT \
  if ((UNSIGNED)CSTKPTR > Irq_Stk_Check) goto check_interrupt

#define nextop0 goto nextopcode
#define nextop1  \
  do {           \
    PCMACL += 1; \
    nextop0;     \
  } while (0)
#define nextop2  \
  do {           \
    PCMACL += 2; \
    nextop0;     \
  } while (0)
#define nextop3  \
  do {           \
    PCMACL += 3; \
    nextop0;     \
  } while (0)
#define nextop4  \
  do {           \
    PCMACL += 4; \
    nextop0;     \
  } while (0)
#define nextop5  \
  do {           \
    PCMACL += 5; \
    nextop0;     \
  } while (0)

#define OPCAR                                                                                     \
  do {                                                                                            \
    if (Listp(TOPOFSTACK)) {                                                                      \
      register ConsCell *DATUM68K = (ConsCell *)(Addr68k_from_LADDR(TOPOFSTACK));                 \
      if (DATUM68K->cdr_code == CDR_INDIRECT) {                                                   \
        TOPOFSTACK = ((LispPTR)((ConsCell *)Addr68k_from_LADDR(DATUM68K->car_field))->car_field); \
        nextop1;                                                                                  \
      } else {                                                                                    \
        TOPOFSTACK = ((LispPTR)DATUM68K->car_field);                                              \
        nextop1;                                                                                  \
      }                                                                                           \
    } else if (TOPOFSTACK == NIL_PTR) {                                                           \
      nextop1;                                                                                    \
    } else if (TOPOFSTACK == ATOM_T) {                                                            \
      nextop1;                                                                                    \
    } else {                                                                                      \
      goto op_ufn;                                                                                \
    }                                                                                             \
  } while (0) /* end of OPCAR */

#ifdef NEWCDRCODING
#define OPCDR                                                                              \
  do {                                                                                     \
    if (Listp(TOPOFSTACK)) {                                                               \
      register ConsCell *DATUM68K = (ConsCell *)(Addr68k_from_LADDR(TOPOFSTACK));          \
      register int CDRCODEX = DATUM68K->cdr_code;                                          \
      if (CDRCODEX == CDR_NIL) {                                                           \
        /* cdr-nil */                                                                      \
        TOPOFSTACK = (NIL_PTR);                                                            \
        nextop1;                                                                           \
      } else if (CDRCODEX > CDR_ONPAGE) {                                                  \
        /* cdr-samepage */                                                                 \
        TOPOFSTACK = ((TOPOFSTACK) + ((CDRCODEX & 7) << 1));                               \
        nextop1;                                                                           \
      } else if (CDRCODEX == CDR_INDIRECT) { /* CDRCODEX < CDR_ONPAGE */                   \
        /* cdr-indirect */                                                                 \
        TOPOFSTACK = (cdr((LispPTR)(DATUM68K->car_field)));                                \
        nextop1;                                                                           \
      } else {                                                                             \
        /* cdr-differentpage */                                                            \
        TOPOFSTACK =                                                                       \
            ((ConsCell *)(Addr68k_from_LADDR((TOPOFSTACK) + (CDRCODEX << 1))))->car_field; \
        nextop1;                                                                           \
      }                                                                                    \
    } else if (TOPOFSTACK == NIL_PTR) {                                                    \
      nextop1;                                                                             \
    } else {                                                                               \
      goto op_ufn;                                                                         \
    }                                                                                      \
  } while (0) /* end of OPCDR */
#else
#define OPCDR                                                                                  \
  do {                                                                                         \
    if (Listp(TOPOFSTACK)) {                                                                   \
      register ConsCell *DATUM68K = (ConsCell *)(Addr68k_from_LADDR(TOPOFSTACK));              \
      register int CDRCODEX = DATUM68K->cdr_code;                                              \
      if (CDRCODEX == CDR_NIL) {                                                               \
        /* cdr-nil */                                                                          \
        TOPOFSTACK = (NIL_PTR);                                                                \
        nextop1;                                                                               \
      } else if (CDRCODEX > CDR_ONPAGE) {                                                      \
        /* cdr-samepage */                                                                     \
        TOPOFSTACK = (POINTER_PAGEBASE(TOPOFSTACK) + ((CDRCODEX & 127) << 1));                 \
        nextop1;                                                                               \
      } else if (CDRCODEX == CDR_INDIRECT) { /* CDRCODEX < CDR_ONPAGE */                       \
        /* cdr-indirect */                                                                     \
        TOPOFSTACK = (cdr((LispPTR)(DATUM68K->car_field)));                                    \
        nextop1;                                                                               \
      } else {                                                                                 \
        /* cdr-differentpage */                                                                \
        TOPOFSTACK =                                                                           \
            ((ConsCell *)(Addr68k_from_LADDR(POINTER_PAGEBASE(TOPOFSTACK) + (CDRCODEX << 1)))) \
                ->car_field;                                                                   \
        nextop1;                                                                               \
      }                                                                                        \
    } else if (TOPOFSTACK == NIL_PTR) {                                                        \
      nextop1;                                                                                 \
    } else {                                                                                   \
      goto op_ufn;                                                                             \
    }                                                                                          \
  } while (0) /* end of OPCDR */
#endif        /* NEWCDRCODING */

#define IVARMACRO(x) \
  do {               \
    PUSH(IVAR[x]);   \
    nextop1;         \
  } while (0)
#define PVARMACRO(x) \
  do {               \
    PUSH(PVAR[x]);   \
    nextop1;         \
  } while (0)
#define PVARSETMACRO(x)   \
  do {                    \
    PVAR[x] = TOPOFSTACK; \
    nextop1;              \
  } while (0)
#define PVARSETPOPMACRO(x) \
  do {                     \
    PVAR[x] = TOPOFSTACK;  \
    POP;                   \
    nextop1;               \
  } while (0)
#define PUSHATOM(x) \
  do {              \
    PUSH(x);        \
    nextop1;        \
  } while (0)

#define JUMPMACRO(x) \
  do {               \
    CHECK_INTERRUPT; \
    PCMACL += (x);   \
    nextop0;         \
  } while (0)

#define FJUMPMACRO(x)                         \
  do {                                        \
    if (TOPOFSTACK != 0) { goto PopNextop1; } \
    {                                         \
      CHECK_INTERRUPT;                        \
      POP;                                    \
      PCMACL += (x);                          \
      nextop0;                                \
    }                                         \
  } while (0)
#define TJUMPMACRO(x)                         \
  do {                                        \
    if (TOPOFSTACK == 0) { goto PopNextop1; } \
    {                                         \
      CHECK_INTERRUPT;                        \
      POP;                                    \
      PCMACL += (x);                          \
      nextop0;                                \
    }                                         \
  } while (0)

#define GETBASE_N(N)                                                                          \
  do {                                                                                        \
    TOPOFSTACK =                                                                              \
      (S_POSITIVE | GETWORD((DLword *)Addr68k_from_LADDR((POINTERMASK & TOPOFSTACK) + (N)))); \
    nextop2;                                                                                  \
  } while (0)

#define GETBASEPTR_N(N)                                                                            \
  do {                                                                                             \
    TOPOFSTACK = (POINTERMASK & *((LispPTR *)Addr68k_from_LADDR((POINTERMASK & TOPOFSTACK) + (N)))); \
    nextop2;                                                                                       \
  } while (0)
#define PUTBASEBYTE                                                                    \
  do {                                                                                 \
    register int byteoffset;                                                           \
    register char *p_data;                                                             \
    if (((SEGMASK & TOPOFSTACK) != S_POSITIVE) || ((unsigned short)TOPOFSTACK >= 256)) \
      goto op_ufn;                                                                     \
    byteoffset = GET_TOS_1;                                                            \
    switch ((SEGMASK & byteoffset)) {                                                  \
      case S_POSITIVE: byteoffset &= 0x0000FFFF; break;                                \
      case S_NEGATIVE: byteoffset |= 0xFFFF0000; break;                                \
      default:                                                                         \
        goto op_ufn;                                                                   \
        /***      if( GetTypeNumber(byteoffset) == TYPE_FIXP )                         \
                        byteoffset = *((int *)Addr68k_from_LADDR(byteoffset));         \
                else                                                                   \
                        goto op_ufn; ***/                                              \
    }                                                                                  \
    --CSTKPTRL;                                                                        \
    p_data = (char *)Addr68k_from_LADDR(POINTERMASK & (POP_TOS_1)) + byteoffset;       \
    GETBYTE(p_data) = 0xFF & TOPOFSTACK;                                               \
    nextop1;                                                                           \
  } while (0)

#define GETBASEBYTE                                                                                \
  do {                                                                                             \
    switch ((SEGMASK & TOPOFSTACK)) {                                                              \
      case S_POSITIVE: TOPOFSTACK &= 0x0000FFFF; break;                                            \
      case S_NEGATIVE: TOPOFSTACK |= 0xFFFF0000; break;                                            \
      default:                                                                                     \
        if (GetTypeNumber(TOPOFSTACK) == TYPE_FIXP)                                                \
          TOPOFSTACK = *((int *)Addr68k_from_LADDR(TOPOFSTACK));                                   \
        else                                                                                       \
          goto op_ufn;                                                                             \
    }                                                                                              \
    TOPOFSTACK =                                                                                   \
        (0xFF & (GETBYTE((char *)Addr68k_from_LADDR((POINTERMASK & (POP_TOS_1))) + TOPOFSTACK))) | \
        S_POSITIVE;                                                                                \
    nextop1;                                                                                       \
  } while (0)

#define PUTBASEPTR_N(n)                                        \
  do {                                                         \
    register int base;                                         \
    base = POINTERMASK & POP_TOS_1;                            \
    *((LispPTR *)Addr68k_from_LADDR(base + (n))) = TOPOFSTACK; \
    TOPOFSTACK = base;                                         \
    nextop2;                                                   \
  } while (0)

#define PUTBASE_N(n)                                                           \
  do {                                                                         \
    register int base;                                                         \
    if (GetHiWord(TOPOFSTACK) != (S_POSITIVE >> 16)) goto op_ufn;              \
    base = POINTERMASK & POP_TOS_1;                                            \
    GETWORD((DLword *)Addr68k_from_LADDR(base + (n))) = GetLoWord(TOPOFSTACK); \
    TOPOFSTACK = base;                                                         \
    nextop2;                                                                   \
  } while (0)

#define PVARX(x)                             \
  do {                                       \
    PUSH(GetLongWord((DLword *)PVAR + (x))); \
    nextop2;                                 \
  } while (0)
#define PVARX_(x)                                      \
  do {                                                 \
    *((LispPTR *)((DLword *)PVAR + (x))) = TOPOFSTACK; \
    nextop2;                                           \
  } while (0)
#define IVARX(x)                             \
  do {                                       \
    PUSH(GetLongWord((DLword *)IVAR + (x))); \
    nextop2;                                 \
  } while (0)
#define IVARX_(x)                                      \
  do {                                                 \
    *((LispPTR *)((DLword *)IVAR + (x))) = TOPOFSTACK; \
    nextop2;                                           \
  } while (0)

#ifndef BIGATOMS
#define GVAR(x)                               \
  do {                                        \
    PUSH(GetLongWord(Valspace + ((x) << 1))); \
    nextop_atom;                              \
  } while (0)
#elif defined(BIGVM)
#define GVAR(x)                                                                  \
  do {                                                                           \
    register int tx = x;                                                         \
    if (tx & SEGMASK) {                                                          \
      PUSH(GetLongWord(Addr68k_from_LADDR((tx) + NEWATOM_VALUE_OFFSET)));        \
    } else                                                                       \
      PUSH(GetLongWord((LispPTR *)AtomSpace + (tx * 5) + NEWATOM_VALUE_PTROFF)); \
                                                                                 \
    nextop_atom;                                                                 \
  } while (0)
#else
#define GVAR(x)                                                           \
  do {                                                                    \
    register int tx = x;                                                  \
    if (tx & SEGMASK) {                                                   \
      PUSH(GetLongWord(Addr68k_from_LADDR((tx) + NEWATOM_VALUE_OFFSET))); \
    } else                                                                \
      PUSH(GetLongWord(Valspace + ((tx) << 1)));                          \
                                                                          \
    nextop_atom;                                                          \
  } while (0)
#endif /* BIGATOMS */

#define COPY               \
  do {                     \
    HARD_PUSH(TOPOFSTACK); \
    nextop1;               \
  } while (0)

#define SWAP                \
  do {                      \
    register LispPTR temp;  \
    temp = GET_TOS_1;       \
    GET_TOS_1 = TOPOFSTACK; \
    TOPOFSTACK = temp;      \
    nextop1;                \
  } while (0)

/*********************************************/
/* Note: No matter how smart it seems, don't */
/* AND in POINTERMASK in VAG2, because there */
/* is code that depends on VAG2 building     */
/* full, 32-bit pointers from 16-bit ints.   */
/*********************************************/
#define N_OP_VAG2                                             \
  do {                                                        \
    TOPOFSTACK = ((GET_TOS_1 << 16) | (0xFFFF & TOPOFSTACK)); \
    CSTKPTRL--;                                               \
    nextop1;                                                  \
  } while (0)

#define FN0 \
  do { OPFN(0, fn0_args, fn0_xna, fn0_native); } while (0)
#define FN1 \
  do { OPFN(1, fn1_args, fn1_xna, fn1_native); } while (0)
#define FN2 \
  do { OPFN(2, fn2_args, fn2_xna, fn2_native); } while (0)
#define FN3 \
  do { OPFN(3, fn3_args, fn3_xna, fn3_native); } while (0)
#define FN4 \
  do { OPFN(4, fn4_args, fn4_xna, fn4_native); } while (0)
#define FNX  \
  do {       \
    OPFNX;   \
    nextop0; \
  } while (0)
#define ENVCALL \
  do {          \
    OP_ENVCALL; \
    nextop0;    \
  } while (0)
#define RETURN \
  do {         \
    OPRETURN;  \
    nextop0;   \
  } while (0)
#define APPLY \
  do { OPAPPLY; } while (0)
#define CHECKAPPLY \
  do {             \
    OPCHECKAPPLY;  \
    nextop1;       \
  } while (0)

#define BIN                                                                                  \
  do {                                                                                       \
    register Stream *stream68k; /* stream instance on TOS */                                 \
    register char *buff68k;     /* pointer to BUFF */                                        \
                                                                                             \
    if (GetTypeNumber(TOPOFSTACK) == TYPE_STREAM) {                                          \
      stream68k = (Stream *)Addr68k_from_LADDR(TOPOFSTACK);                                  \
      if ((!stream68k->BINABLE) || (stream68k->COFFSET >= stream68k->CBUFSIZE)) goto op_ufn; \
                                                                                             \
      /* get BUFFER instance */                                                              \
      buff68k = (char *)Addr68k_from_LADDR(stream68k->CBUFPTR);                              \
                                                                                             \
      /* get BYTE data and set it to TOS */                                                  \
      TOPOFSTACK = (S_POSITIVE | (Get_BYTE(buff68k + (stream68k->COFFSET)++)));              \
      nextop1;                                                                               \
    } else                                                                                   \
      goto op_ufn;                                                                           \
  } while (0)

#ifdef RECLAIMINC
#define RECLAIMCELL                         \
  do {                                      \
    TOPOFSTACK = gcreclaimcell(TOPOFSTACK); \
    nextop1;                                \
  } while (0)
#else
#define RECLAIMCELL goto op_ufn
#endif

#define GCSCAN1                                    \
  do {                                             \
    TOPOFSTACK = gcscan1(TOPOFSTACK & 0xffff);     \
    if (TOPOFSTACK) { TOPOFSTACK |= S_POSITIVE; }; \
    nextop1;                                       \
  } while (0)

#define GCSCAN2                                    \
  do {                                             \
    TOPOFSTACK = gcscan2(TOPOFSTACK & 0xffff);     \
    if (TOPOFSTACK) { TOPOFSTACK |= S_POSITIVE; }; \
    nextop1;                                       \
  } while (0)

#define CONTEXTSWITCH             \
  do {                            \
    EXT;                          \
    OP_contextsw();               \
    RET;                          \
    /*CHECK_INTERRUPT;*/ CLR_IRQ; \
    nextop0;                      \
  } while (0)

#define NOP \
  do { nextop1; } while (0)

#define RESLIST(n) goto op_ufn

#define FINDKEY(x)                            \
  do {                                        \
    TOPOFSTACK = N_OP_findkey(TOPOFSTACK, x); \
    nextop2;                                  \
  } while (0)

#define RPLPTR(n)                                       \
  do {                                                  \
    TOPOFSTACK = N_OP_rplptr(POP_TOS_1, TOPOFSTACK, n); \
    nextop2;                                            \
  } while (0)

#define GVAR_(atom_index)               \
  do {                                  \
    N_OP_gvar_(TOPOFSTACK, atom_index); \
    nextop_atom;                        \
  } while (0)

#define BIND                                                    \
  do {                                                          \
    register int byte = Get_BYTE_PCMAC1;                        \
    register unsigned n1;                                       \
    register unsigned n2;                                       \
    register LispPTR *ppvar;                                    \
    register int i;                                             \
    n1 = byte >> 4;                                             \
    n2 = byte & 0xf;                                            \
    ppvar = (LispPTR *)PVAR + 1 + Get_BYTE_PCMAC2;              \
    for (i = n1; --i >= 0;) { *--ppvar = NIL_PTR; }             \
    if (n2 == 0) {                                              \
      *CSTKPTRL++ = TOPOFSTACK;                                 \
    } else {                                                    \
      *--ppvar = TOPOFSTACK;                                    \
      for (i = 1; i < n2; i++) { *--ppvar = *(--CSTKPTRL); }    \
    }                                                           \
    TOPOFSTACK = ((~(n1 + n2)) << 16) | (Get_BYTE_PCMAC2 << 1); \
    nextop3;                                                    \
  } while (0)

#define UNBIND                                                  \
  do {                                                          \
    register int num;                                           \
    register LispPTR *ppvar;                                    \
    register int i;                                             \
    register LispPTR value;                                     \
    for (; (((int)*--CSTKPTRL) >= 0);)                          \
      ;                                                         \
    value = *CSTKPTR;                                           \
    num = (~value) >> 16;                                       \
    ppvar = (LispPTR *)((DLword *)PVAR + 2 + GetLoWord(value)); \
    for (i = num; --i >= 0;) { *--ppvar = 0xffffffff; }         \
    nextop1;                                                    \
  } while (0)

#define DUNBIND                                                          \
  do {                                                                   \
    register int num;                                                    \
    register LispPTR *ppvar;                                             \
    register int i;                                                      \
    register LispPTR value;                                              \
    if ((int)TOPOFSTACK < 0) {                                           \
      num = (~TOPOFSTACK) >> 16;                                         \
      if (num != 0) {                                                    \
        ppvar = (LispPTR *)((DLword *)PVAR + 2 + GetLoWord(TOPOFSTACK)); \
        for (i = num; --i >= 0;) { *--ppvar = 0xffffffff; }              \
      }                                                                  \
    } else {                                                             \
      for (; (((int)*--CSTKPTRL) >= 0);)                                 \
        ;                                                                \
      value = *CSTKPTR;                                                  \
      num = (~value) >> 16;                                              \
      ppvar = (LispPTR *)((DLword *)PVAR + 2 + GetLoWord(value));        \
      for (i = num; --i >= 0;) { *--ppvar = 0xffffffff; }                \
    }                                                                    \
    POP;                                                                 \
    nextop1;                                                             \
  } while (0)

#define N_OP_HILOC                                   \
  do {                                               \
    TOPOFSTACK = GetHiWord(TOPOFSTACK) | S_POSITIVE; \
    nextop1;                                         \
  } while (0)
#define N_OP_LOLOC                                   \
  do {                                               \
    TOPOFSTACK = GetLoWord(TOPOFSTACK) | S_POSITIVE; \
    nextop1;                                         \
  } while (0)

#define GETBITS_N_M(a, b)                                                                          \
  do {                                                                                             \
    register int temp, bb = b;                                                                     \
    temp = 0xF & bb;                                                                               \
    TOPOFSTACK = S_POSITIVE | (((GETWORD(Addr68k_from_LADDR(POINTERMASK & (TOPOFSTACK + (a))))) >> \
                                (16 - ((0xF & (bb >> 4)) + temp + 1))) &                           \
                               n_mask_array[temp]);                                                \
    nextop3;                                                                                       \
  } while (0)

#define PUTBITS_N_M(a, b)                                                                \
  do {                                                                                   \
    int base;                                                                            \
    register int bb = b;                                                                 \
    register DLword *pword;                                                              \
    register 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));                                    \
    field_size = 0xF & bb;                                                               \
    shift_size = 15 - (0xF & (bb >> 4)) - field_size;                                    \
    fmask = n_mask_array[field_size] << shift_size;                                      \
    GETWORD(pword) = ((TOPOFSTACK << shift_size) & fmask) | (GETWORD(pword) & (~fmask)); \
    TOPOFSTACK = base;                                                                   \
    nextop3;                                                                             \
  } while (0)

#define CONS                                       \
  do {                                             \
    TOPOFSTACK = N_OP_cons(POP_TOS_1, TOPOFSTACK); \
    nextop1;                                       \
  } while (0)

#define MYALINK                                                     \
  do {                                                              \
    PUSH((((CURRENTFX->alink) & 0xfffe) - FRAMESIZE) | S_POSITIVE); \
    nextop1;                                                        \
  } while (0)

#define MYARGCOUNT                                                \
  do {                                                            \
    register UNSIGNED arg_num;                                    \
    if ((CURRENTFX->alink & 1) == 0)                              \
      arg_num = (UNSIGNED)((LispPTR *)(CURRENTFX)-1);             \
    else                                                          \
      arg_num = (UNSIGNED)(Stackspace + CURRENTFX->blink);        \
    PUSH((DLword)((arg_num - (UNSIGNED)IVar) >> 2) | S_POSITIVE); \
    nextop1;                                                      \
  } while (0)

#define RCLK                            \
  do {                                  \
    TOPOFSTACK = N_OP_rclk(TOPOFSTACK); \
    nextop1;                            \
  } while (0)

#define LISTP                                                                  \
  do {                                                                         \
    if ((DLword)GetTypeNumber(TOPOFSTACK) != TYPE_LISTP) TOPOFSTACK = NIL_PTR; \
    nextop1;                                                                   \
  } while (0)

#define NTYPEX                                                     \
  do {                                                             \
    TOPOFSTACK = S_POSITIVE | (DLword)(GetTypeNumber(TOPOFSTACK)); \
    nextop1;                                                       \
  } while (0)

#define TYPEP(n)                                                        \
  do {                                                                  \
    if ((DLword)GetTypeNumber(TOPOFSTACK) != (n)) TOPOFSTACK = NIL_PTR; \
    nextop2;                                                            \
  } while (0)

#define TYPEMASK(n)                                                                           \
  do {                                                                                        \
    if ((((DLword)GetTypeEntry(TOPOFSTACK)) & ((DLword)(n) << 8)) == 0) TOPOFSTACK = NIL_PTR; \
    nextop2;                                                                                  \
  } while (0)

#define INSTANCEP(atom_index)                            \
  do {                                                   \
    TOPOFSTACK = N_OP_instancep(TOPOFSTACK, atom_index); \
    nextop_atom;                                         \
  } while (0)

#define STOREN(n)                               \
  do {                                          \
    *(CSTKPTR - (((n) + 2) >> 1)) = TOPOFSTACK; \
    nextop2;                                    \
  } while (0)

#define COPYN(n)                         \
  do {                                   \
    PUSH(*(CSTKPTR - (((n) + 2) >> 1))); \
    nextop2;                             \
  } while (0)

#define POPN(n)                            \
  do {                                     \
    TOPOFSTACK = *(CSTKPTRL -= ((n) + 1)); \
    nextop2;                               \
  } while (0)

#define CLARITHEQUAL                            \
  do {                                          \
    register int arg2;                          \
    SV;                                         \
    arg2 = POP_TOS_1;                           \
    if ((TOPOFSTACK & SEGMASK) == S_POSITIVE) { \
      if (arg2 == TOPOFSTACK) {                 \
        TOPOFSTACK = ATOM_T;                    \
        nextop1;                                \
      }                                         \
      if ((arg2 & SEGMASK) == S_POSITIVE) {     \
        TOPOFSTACK = NIL;                       \
        nextop1;                                \
      }                                         \
    }                                           \
    N_OP_POPPED_CALL_2(N_OP_eqq, arg2);         \
  } while (0)

#define S_CHARACTER 0x70000

#define AREF1                                                                                      \
  do {                                                                                             \
    LispPTR arrayarg;                                                                              \
    register LispPTR baseL;                                                                        \
    register int index;                                                                            \
    register OneDArray *arrayblk;                                                                  \
    SV;                                                                                            \
    arrayarg = POP_TOS_1;                                                                          \
    if (GetTypeNumber(arrayarg) != TYPE_ONED_ARRAY) goto aref_ufn;                                 \
    arrayblk = (OneDArray *)Addr68k_from_LADDR(arrayarg);                                          \
    if ((TOPOFSTACK & SEGMASK) != S_POSITIVE) goto aref_ufn;                                       \
    index = TOPOFSTACK & 0xFFFF;                                                                   \
    if (index >= arrayblk->totalsize) goto aref_ufn;                                               \
    index += arrayblk->offset;                                                                     \
    baseL = arrayblk->base;                                                                        \
    switch (arrayblk->typenumber) {                                                                \
      case 38: /* pointer : 32 bits */                                                             \
        TOPOFSTACK = *(((int *)Addr68k_from_LADDR(baseL)) + index);                                \
        nextop1;                                                                                   \
      case 20: /* signed : 16 bits */                                                              \
        TOPOFSTACK = (GETWORD(((DLword *)Addr68k_from_LADDR(baseL)) + index)) & 0xFFFF;            \
        if (TOPOFSTACK & 0x8000)                                                                   \
          TOPOFSTACK |= S_NEGATIVE;                                                                \
        else                                                                                       \
          TOPOFSTACK |= S_POSITIVE;                                                                \
        nextop1;                                                                                   \
      case 67: /* Character :  8 bits */                                                           \
        TOPOFSTACK =                                                                               \
            S_CHARACTER | ((GETBYTE(((char *)Addr68k_from_LADDR(baseL)) + index)) & 0xFF);         \
        nextop1;                                                                                   \
      case 22: /* signed : 32 bits */                                                              \
        TOPOFSTACK = *(((int *)Addr68k_from_LADDR(baseL)) + index);                                \
        switch (TOPOFSTACK & 0xFFFF0000) {                                                         \
          case 0: TOPOFSTACK |= S_POSITIVE; break;                                                 \
          case (unsigned)0xFFFF0000: TOPOFSTACK &= S_NEGATIVE; break;                              \
          default: {                                                                               \
            register DLword *wordp;                                                                \
            wordp = createcell68k(TYPE_FIXP);                                                      \
            *((int *)wordp) = TOPOFSTACK;                                                          \
            TOPOFSTACK = (LispPTR)LADDR_from_68k(wordp);                                           \
          }                                                                                        \
        }                                                                                          \
        nextop1;                                                                                   \
      case 0: /* unsigned : 1 bit per element */                                                   \
        TOPOFSTACK =                                                                               \
            S_POSITIVE | (((GETBYTE(((char *)Addr68k_from_LADDR(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); \
        nextop1;                                                                                   \
      case 4: /* unsigned : 16 bits per element */                                                 \
        TOPOFSTACK =                                                                               \
            S_POSITIVE | ((GETWORD(((DLword *)Addr68k_from_LADDR(baseL)) + index)) & 0xFFFF);      \
        nextop1;                                                                                   \
      case 54: /* Float : 32 bits */ {                                                             \
        register DLword *wordp;                                                                    \
        wordp = createcell68k(TYPE_FLOATP);                                                        \
        *((int *)wordp) = *(((int *)Addr68k_from_LADDR(baseL)) + index);                           \
        TOPOFSTACK = (LispPTR)LADDR_from_68k(wordp);                                               \
      }                                                                                            \
        nextop1;                                                                                   \
      case 68: /* Character :  16 bits */                                                          \
        TOPOFSTACK =                                                                               \
            S_CHARACTER | ((GETWORD(((DLword *)Addr68k_from_LADDR(baseL)) + index)) & 0xFFFF);     \
        nextop1;                                                                                   \
      case 86: /* XPointer : 32 bits */                                                            \
        TOPOFSTACK = *(((int *)Addr68k_from_LADDR(baseL)) + index);                                \
        nextop1;                                                                                   \
      default: /* Illegal or Unimplemented */ goto aref_ufn;                                       \
    } /* end switch typenumber */                                                                  \
  aref_ufn:                                                                                        \
    N_OP_POPPED_CALL_2(N_OP_aref1, arrayarg);                                                      \
  } while (0)

#ifdef BIGVM
#define DTEST(n)                                                                                   \
  do {                                                                                             \
    register int atom_index;                                                                       \
    register struct dtd *dtd68k;                                                                   \
    atom_index = n;                                                                                \
    for (dtd68k = (struct dtd *)GetDTD(GetTypeNumber(TOPOFSTACK)); atom_index != dtd68k->dtd_name; \
         dtd68k = (struct dtd *)GetDTD(dtd68k->dtd_supertype)) {                                   \
      if (dtd68k->dtd_supertype == 0) { goto op_ufn; }                                             \
    }                                                                                              \
    nextop_atom;                                                                                   \
  } while (0)
#else /* BIGVM */
#define DTEST(n)                                                               \
  do {                                                                         \
    register int atom_index;                                                   \
    register struct dtd *dtd68k;                                               \
    atom_index = n;                                                            \
    for (dtd68k = (struct dtd *)GetDTD(GetTypeNumber(TOPOFSTACK));             \
         atom_index != dtd68k->dtd_namelo + ((int)(dtd68k->dtd_namehi) << 16); \
         dtd68k = (struct dtd *)GetDTD(dtd68k->dtd_supertype)) {               \
      if (dtd68k->dtd_supertype == 0) { goto op_ufn; }                         \
    }                                                                          \
    nextop_atom;                                                               \
  } while (0)
#endif /* BIGVM */

#define FVAR(n)                                                                             \
  do {                                                                                      \
    register LispPTR *chain;                                                                \
    chain = (LispPTR *)(PVar + (n));                                                        \
    if (WBITSPTR(chain)->LSB) {                                                             \
      PUSH(GetLongWord(Addr68k_from_LADDR(POINTERMASK &swapx(native_newframe((n) >> 1))))); \
      nextop1;                                                                              \
    } /* if(((WBITS */                                                                      \
    PUSH(GetLongWord(Addr68k_from_LADDR(POINTERMASK &swapx(*chain))));                      \
    nextop1;                                                                                \
  } while (0)

#define FVARX(n)                                                                           \
  do {                                                                                     \
    register int nn = n;                                                                   \
    register LispPTR *chain;                                                               \
    chain = (LispPTR *)(PVar + nn);                                                        \
    if (WBITSPTR(chain)->LSB) {                                                            \
      PUSH(GetLongWord(Addr68k_from_LADDR(POINTERMASK &swapx(native_newframe(nn >> 1))))); \
      nextop2;                                                                             \
    } /* if(((WBITS */                                                                     \
    PUSH(GetLongWord(Addr68k_from_LADDR(POINTERMASK &swapx(*chain))));                     \
    nextop2;                                                                               \
  } while (0)

/* ********************************************************************      */
/* THE FOLLOWING WAS IN n_op_inlinedefsC.h */
/* ********************************************************************      */

#define GCREF(n)                          \
  do {                                    \
    GCLOOKUPV(TOPOFSTACK, n, TOPOFSTACK); \
    nextop2;                              \
  } while (0)

#ifndef BIGATOMS
#define ATOMCELL_N(n)                                    \
  do {                                                   \
    if ((unsigned int)TOPOFSTACK >> 16) { goto op_ufn; } \
    TOPOFSTACK = (n << 16) + (TOPOFSTACK << 1);          \
    nextop2;                                             \
  } while (0)
#elif defined(BIGVM)
#define ATOMCELL_N(n)                                                                             \
  do {                                                                                            \
    register int nn = n;                                                                          \
    if (0 == ((unsigned int)(TOPOFSTACK &= POINTERMASK) & SEGMASK)) {                             \
      /* old-symbol case; just add cell-number arg */                                             \
      switch (nn) {                                                                               \
        case PLIS_HI: /* PLIST entry for symbol */                                                \
          TOPOFSTACK = (ATOMS_HI << 16) + (10 * (unsigned int)TOPOFSTACK) + NEWATOM_PLIST_OFFSET; \
          break;                                                                                  \
        case PNP_HI: /* PNAME entry for symbol */                                                 \
          TOPOFSTACK = (ATOMS_HI << 16) + (10 * (unsigned int)TOPOFSTACK) + NEWATOM_PNAME_OFFSET; \
          break;                                                                                  \
        case VALS_HI: /* VALUE cell for symbol */                                                 \
          TOPOFSTACK = (ATOMS_HI << 16) + (10 * (unsigned int)TOPOFSTACK) + NEWATOM_VALUE_OFFSET; \
          break;                                                                                  \
        case DEFS_HI: /* DEFINITION for symbol */                                                 \
          TOPOFSTACK = (ATOMS_HI << 16) + (10 * (unsigned int)TOPOFSTACK) + NEWATOM_DEFN_OFFSET;  \
          break;                                                                                  \
        default: goto op_ufn;                                                                     \
      }                                                                                           \
      nextop2;                                                                                    \
    } else if (TYPE_NEWATOM == GetTypeNumber(TOPOFSTACK)) {                                       \
      /* NEW-symbol case; it's an offset from the main ptr */                                     \
      switch (nn) {                                                                               \
        case PLIS_HI: /* PLIST entry for symbol */                                                \
          TOPOFSTACK = TOPOFSTACK + NEWATOM_PLIST_OFFSET;                                         \
          break;                                                                                  \
        case PNP_HI: /* PNAME entry for symbol */                                                 \
          TOPOFSTACK = TOPOFSTACK + NEWATOM_PNAME_OFFSET;                                         \
          break;                                                                                  \
        case VALS_HI: /* VALUE cell for symbol */                                                 \
          TOPOFSTACK = TOPOFSTACK + NEWATOM_VALUE_OFFSET;                                         \
          break;                                                                                  \
        case DEFS_HI: /* DEFINITION for symbol */                                                 \
          TOPOFSTACK = TOPOFSTACK + NEWATOM_DEFN_OFFSET;                                          \
          break;                                                                                  \
        default: goto op_ufn;                                                                     \
      }                                                                                           \
      nextop2;                                                                                    \
    } else                                                                                        \
      goto op_ufn;                                                                                \
  } while (0)
#else /*        */

#define ATOMCELL_N(n)                                         \
  do {                                                        \
    register int nn = n;                                      \
    if (0 == ((unsigned int)TOPOFSTACK & SEGMASK)) {          \
      /* old-symbol case; just add cell-number arg */         \
      TOPOFSTACK = (nn << 16) + (TOPOFSTACK << 1);            \
      nextop2;                                                \
    } else if (TYPE_NEWATOM == GetTypeNumber(TOPOFSTACK)) {   \
      /* NEW-symbol case; it's an offset from the main ptr */ \
      switch (nn) {                                           \
        case PLIS_HI: /* PLIST entry for symbol */            \
          TOPOFSTACK = TOPOFSTACK + NEWATOM_PLIST_OFFSET;     \
          break;                                              \
        case PNP_HI: /* PNAME entry for symbol */             \
          TOPOFSTACK = TOPOFSTACK + NEWATOM_PNAME_OFFSET;     \
          break;                                              \
        case VALS_HI: /* VALUE cell for symbol */             \
          TOPOFSTACK = TOPOFSTACK + NEWATOM_VALUE_OFFSET;     \
          break;                                              \
        case DEFS_HI: /* DEFINITION for symbol */             \
          TOPOFSTACK = TOPOFSTACK + NEWATOM_DEFN_OFFSET;      \
          break;                                              \
        default: goto op_ufn;                                 \
      }                                                       \
      nextop2;                                                \
    } else                                                    \
      goto op_ufn;                                            \
  } while (0)
#endif /* BIGATOMS */

#define DIFFERENCE N_OP_CALL_2(N_OP_difference)
#define LOGOR N_OP_CALL_2(N_OP_logor)
#define LOGAND N_OP_CALL_2(N_OP_logand)
#define LOGXOR N_OP_CALL_2(N_OP_logxor)
#define PLUS2 N_OP_CALL_2(N_OP_plus2)
#define QUOTIENT N_OP_CALL_2(N_OP_quot)
#define TIMES2 N_OP_CALL_2(N_OP_times2)
#define GREATERP N_OP_CALL_2(N_OP_greaterp)
#define IDIFFERENCE N_OP_CALL_2(N_OP_idifference)
#define IPLUS2 N_OP_CALL_2(N_OP_iplus2)
#define IQUOTIENT N_OP_CALL_2(N_OP_iquot)
#define ITIMES2 N_OP_CALL_2(N_OP_itimes2)
#define IGREATERP N_OP_CALL_2(N_OP_igreaterp)
#define IREMAINDER N_OP_CALL_2(N_OP_iremainder)
#define IPLUS_N(n) N_OP_CALL_1d(N_OP_iplusn, n)
#define IDIFFERENCE_N(n) N_OP_CALL_1d(N_OP_idifferencen, n)
#define BOXIPLUS N_OP_CALL_2(N_OP_boxiplus)
#define BOXIDIFFERENCE N_OP_CALL_2(N_OP_boxidiff)
#define FPLUS2 N_OP_CALL_2(N_OP_fplus2)
#define FDIFFERENCE N_OP_CALL_2(N_OP_fdifference)
#define FTIMES2 N_OP_CALL_2(N_OP_ftimes2)
#define FQUOTIENT N_OP_CALL_2(N_OP_fquotient)
#define FGREATERP N_OP_CALL_2(N_OP_fgreaterp)
#define UBFLOAT1(n) N_OP_UNBOXED_CALL_1d(N_OP_ubfloat1, n)
#define UBFLOAT2(n) N_OP_UNBOXED_CALL_2d(N_OP_ubfloat2, n)
#define UBFLOAT3(n) N_OP_UNBOXED_CALL_3d(N_OP_ubfloat3, n)
#define LRSH1 N_OP_CALL_1(N_OP_lrsh1)
#define LRSH8 N_OP_CALL_1(N_OP_lrsh8)
#define LLSH1 N_OP_CALL_1(N_OP_llsh1)
#define LLSH8 N_OP_CALL_1(N_OP_llsh8)
#define LSH N_OP_CALL_2(N_OP_lsh)
#define RPLACA N_OP_CALL_2(N_OP_rplaca)
#define RPLACD N_OP_CALL_2(N_OP_rplacd)
#define RPLCONS N_OP_CALL_2(N_OP_rplcons)
#define MAKENUMBER N_OP_CALL_2(N_OP_makenumber)
#define EQLOP N_OP_CALL_2(N_OP_eqlop)
#define CLEQUAL N_OP_CALL_2(N_OP_clequal)
#define ILEQUAL N_OP_CALL_2(N_OP_equal)
#define CLFMEMB N_OP_CALL_exception_2(N_OP_clfmemb)
#define CLASSOC N_OP_CALL_exception_2(N_OP_classoc)
#define FMEMB N_OP_CALL_exception_2(N_OP_fmemb)
#define ASSOC N_OP_CALL_exception_2(N_OP_assoc)
#define ARG0 N_OP_CALL_1(N_OP_arg0)
#define LISTGET N_OP_CALL_exception_2C(N_OP_listget)
#define DRAWLINE N_OP_CALL_9(N_OP_drawline)
#define N_OP_ADDBASE N_OP_CALL_2(N_OP_addbase)

#define UNWIND(n, m)                                                                           \
  do {                                                                                         \
    if ((CSTKPTRL = N_OP_unwind(CSTKPTR, TOPOFSTACK, n, m)) == (LispPTR *)-1) goto unwind_err; \
    POP;                                                                                       \
    nextop3;                                                                                   \
  } while (0)

#define STKSCAN                            \
  do {                                     \
    TOPOFSTACK = N_OP_stkscan(TOPOFSTACK); \
    nextop1;                               \
  } while (0)

#define FVARX_(n)                           \
  do {                                      \
    TOPOFSTACK = N_OP_fvar_(TOPOFSTACK, n); \
    nextop2;                                \
  } while (0)

#define BLT N_OP_CALL_3(N_OP_blt)

#define PILOTBITBLT                                       \
  do {                                                    \
    TOPOFSTACK = N_OP_pilotbitblt(POP_TOS_1, TOPOFSTACK); \
    nextop1;                                              \
  } while (0)

#define CREATECELL N_OP_CALL_1(N_OP_createcell)

#define RESTLIST(n)                                       \
  do {                                                    \
    TOPOFSTACK = N_OP_restlist(POP_TOS_1, TOPOFSTACK, n); \
    nextop2;                                              \
  } while (0)

#define ASET1 N_OP_CALL_3(N_OP_aset1)
#define ASET2 N_OP_CALL_4(N_OP_aset2)
#define MISC3(n) N_OP_CALL_3d(N_OP_misc3, n)
#define MISC4(n) N_OP_CALL_4d(N_OP_misc4, n)
#define MISC7(n) N_OP_CALL_7d(N_OP_misc7, n)
#define AREF2 N_OP_CALL_3(N_OP_aref2)
#define MISCN(index, args)                          \
  do {                                              \
    EXT;                                            \
    if (OP_miscn(index, args)) {                    \
      RET;                                          \
      /* PUSH(S_POSITIVE | (index << 8) | args); */ \
      goto op_ufn;                                  \
    }                                               \
    RET;                                            \
    nextop0;                                        \
  } while (0)

/* ******************************************************************** */
/*      Call Interface where -1 indicates an error return               */
/* ******************************************************************** */

/* SV need do no work */
#define SV

/* UFN_CALLS are inserted in xc.c. Note that only ufn_2 calls have decremented the stack at the time
 * the UFN is called */

/* ufn_x      there are x args from the Lisp stack
   ufn_xd      there are x args from the Lisp stack &
                some from the code stream.
*/
#define UFN_CALLS                        \
                                         \
  unwind_err:                            \
  CSTKPTRL = (LispPTR *)CurrentStackPTR; \
  Error_Exit = 0;                        \
  goto op_ufn;                           \
  ufn_2d:                                \
  CSTKPTRL += 1;                         \
  goto fix_tos_ufn;                      \
  ufn_2d2:                               \
  CSTKPTRL += 1;                         \
  goto fix_tos_ufn;                      \
  ufn_2:                                 \
  CSTKPTRL += 1;                         \
  goto fix_tos_ufn;                      \
  exception_2:                           \
  Error_Exit = 0;                        \
  CSTKPTRL += 1;                         \
  TOPOFSTACK = TopOfStack;               \
  if (!Irq_Stk_End) {                    \
    goto check_interrupt;                \
  } else                                 \
    goto op_ufn;                         \
  exception_2C:                          \
  Error_Exit = 0;                        \
  TOPOFSTACK = TopOfStack;               \
  *CSTKPTRL = Scratch_CSTK;              \
  CSTKPTRL += 1;                         \
  if (!Irq_Stk_End) {                    \
    goto check_interrupt;                \
  } else {                               \
    goto op_ufn;                         \
  }                                      \
  fix_tos_ufn:                           \
  TOPOFSTACK = TopOfStack;               \
  Error_Exit = 0;                        \
  goto op_ufn;

#define N_OP_CALL_1(op_name)                                                    \
  do {                                                                          \
    if ((int)(TOPOFSTACK = (LispPTR)op_name(TOPOFSTACK)) < 0) goto fix_tos_ufn; \
    nextop1;                                                                    \
  } while (0)

#define N_OP_CALL_1d(op_name, n)                                                   \
  do {                                                                             \
    if ((int)(TOPOFSTACK = (LispPTR)op_name(TOPOFSTACK, n)) < 0) goto fix_tos_ufn; \
    nextop2;                                                                       \
  } while (0)

#define N_OP_UNBOXED_CALL_1d(op_name, n) \
  do {                                   \
    TOPOFSTACK = op_name(TOPOFSTACK, n); \
    if (Error_Exit) goto fix_tos_ufn;    \
    nextop2;                             \
  } while (0)

#define N_OP_CALL_2(op_name)                                                         \
  do {                                                                               \
    if ((int)(TOPOFSTACK = (LispPTR)op_name(POP_TOS_1, TOPOFSTACK)) < 0) goto ufn_2; \
    nextop1;                                                                         \
  } while (0)

#define N_OP_POPPED_CALL_2(op_name, popped_arg)                                       \
  do {                                                                                \
    if ((int)(TOPOFSTACK = (LispPTR)op_name(popped_arg, TOPOFSTACK)) < 0) goto ufn_2; \
    nextop1;                                                                          \
  } while (0)

#define N_OP_CALL_2d(op_name, n)                                                         \
  do {                                                                                   \
    if ((int)(TOPOFSTACK = (LispPTR)op_name(POP_TOS_1, TOPOFSTACK, n)) < 0) goto ufn_2d; \
    nextop2;                                                                             \
  } while (0)

#define N_OP_UNBOXED_CALL_2d(op_name, n)            \
  do {                                              \
    TOPOFSTACK = op_name(POP_TOS_1, TOPOFSTACK, n); \
    if (Error_Exit) goto ufn_2d;                    \
    nextop2;                                        \
  } while (0)

#define N_OP_CALL_2d2(op_name, a, b)                                                         \
  do {                                                                                       \
    if ((int)(TOPOFSTACK = (LispPTR)op_name(POP_TOS_1, TOPOFSTACK, a, b)) < 0) goto ufn_2d2; \
    nextop3;                                                                                 \
  } while (0)

#define N_OP_CALL_exception_2(op_name)                                                     \
  do {                                                                                     \
    if ((int)(TOPOFSTACK = (LispPTR)op_name(POP_TOS_1, TOPOFSTACK)) < 0) goto exception_2; \
    nextop1;                                                                               \
  } while (0)

#define N_OP_CALL_exception_2C(op_name)                                                     \
  do {                                                                                      \
    if ((int)(TOPOFSTACK = (LispPTR)op_name(POP_TOS_1, TOPOFSTACK)) < 0) goto exception_2C; \
    nextop1;                                                                                \
  } while (0)

#define N_OP_CALL_3(op_name)                                                                  \
  do {                                                                                        \
    if ((int)(TOPOFSTACK = (LispPTR)op_name(*(CSTKPTR - 2), *(CSTKPTR - 1), TOPOFSTACK)) < 0) \
      goto fix_tos_ufn;                                                                       \
    CSTKPTRL -= 2;                                                                            \
    nextop1;                                                                                  \
  } while (0)

#define N_OP_CALL_3d(op_name, n)                                                                 \
  do {                                                                                           \
    if ((int)(TOPOFSTACK = (LispPTR)op_name(*(CSTKPTR - 2), *(CSTKPTR - 1), TOPOFSTACK, n)) < 0) \
      goto fix_tos_ufn;                                                                          \
    CSTKPTRL -= 2;                                                                               \
    nextop2;                                                                                     \
  } while (0)

#define N_OP_UNBOXED_CALL_3d(op_name, n)                                 \
  do {                                                                   \
    TOPOFSTACK = op_name(*(CSTKPTR - 2), *(CSTKPTR - 1), TOPOFSTACK, n); \
    if (Error_Exit) goto fix_tos_ufn;                                    \
    CSTKPTRL -= 2;                                                       \
    nextop2;                                                             \
  } while (0)
#define N_OP_CALL_4(op_name)                                                                \
  do {                                                                                      \
    if ((int)(TOPOFSTACK = (LispPTR)op_name(*(CSTKPTR - 3), *(CSTKPTR - 2), *(CSTKPTR - 1), \
                                            TOPOFSTACK)) < 0)                               \
      goto fix_tos_ufn;                                                                     \
    CSTKPTRL -= 3;                                                                          \
    nextop1;                                                                                \
  } while (0)

#define N_OP_CALL_4d(op_name, n)                                                            \
  do {                                                                                      \
    if ((int)(TOPOFSTACK = (LispPTR)op_name(*(CSTKPTR - 3), *(CSTKPTR - 2), *(CSTKPTR - 1), \
                                            TOPOFSTACK, n)) < 0)                            \
      goto fix_tos_ufn;                                                                     \
    CSTKPTRL -= 3;                                                                          \
    nextop2;                                                                                \
  } while (0)

#define N_OP_CALL_7d(op_name, n)                                                                   \
  do {                                                                                             \
    if ((int)(TOPOFSTACK =                                                                         \
                  (LispPTR)op_name(*(CSTKPTR - 6), *(CSTKPTR - 5), *(CSTKPTR - 4), *(CSTKPTR - 3), \
                                   *(CSTKPTR - 2), *(CSTKPTR - 1), TOPOFSTACK, n)) < 0)            \
      goto fix_tos_ufn;                                                                            \
    CSTKPTRL -= 6;                                                                                 \
    nextop2;                                                                                       \
  } while (0)

#define N_OP_CALL_9(op_name)                                                                       \
  do {                                                                                             \
    if ((int)(TOPOFSTACK =                                                                         \
                  (LispPTR)op_name(*(CSTKPTR - 8), *(CSTKPTR - 7), *(CSTKPTR - 6), *(CSTKPTR - 5), \
                                   *(CSTKPTR - 4), *(CSTKPTR - 3), *(CSTKPTR - 2), *(CSTKPTR - 1), \
                                   TOPOFSTACK /*, fix_tos_ufn*/)) < 0)                             \
      goto fix_tos_ufn;                                                                            \
    CSTKPTRL -= 8;                                                                                 \
    nextop1;                                                                                       \
  } while (0)

#endif
