Changed compile-time flags to use C89 and fixed new warnings raised.

10 files changed, 389 insertions, 343 deletions

diff --git a/source/apu_blargg.c b/source/apu_blargg.c
index a89a905..d87d8d3 100644
--- a/source/apu_blargg.c
+++ b/source/apu_blargg.c
@@ -8,9 +8,7 @@
 #include <stdlib.h>
 #include <limits.h>
 
-#ifdef PSP
-#define inline __attribute((force_inline))
-#endif
+#include <retro_inline.h>
 
 #include "blargg_endian.h"
 #include "apu_blargg.h"
@@ -103,7 +101,7 @@ static int16_t gauss [512] =
 
 /* Gaussian interpolation */
 
-static inline int32_t dsp_interpolate( dsp_voice_t *v )
+static INLINE int32_t dsp_interpolate( dsp_voice_t *v )
 {
    int32_t offset, out, *in;
    int16_t *fwd, *rev;
@@ -171,7 +169,7 @@ static uint32_t const counter_offsets [32] =
 
 /* Envelope */
 
-static inline void dsp_run_envelope( dsp_voice_t* const v )
+static INLINE void dsp_run_envelope( dsp_voice_t* const v )
 {
    int32_t env, rate, env_data;
 
@@ -245,7 +243,7 @@ static inline void dsp_run_envelope( dsp_voice_t* const v )
 
 /* BRR Decoding */
 
-static inline void dsp_decode_brr( dsp_voice_t* v )
+static INLINE void dsp_decode_brr( dsp_voice_t* v )
 {
    int32_t nybbles, *pos, *end, header;
 
@@ -320,7 +318,7 @@ static inline void dsp_decode_brr( dsp_voice_t* v )
    if ( (dsp_m.every_other_sample ^= 1) != 0 ) \
       dsp_m.new_kon &= ~dsp_m.kon; /* clears KON 63 clocks after it was last read */
 
-static inline void dsp_misc_30()
+static INLINE void dsp_misc_30()
 {
    if ( dsp_m.every_other_sample )
    {
@@ -340,13 +338,13 @@ static inline void dsp_misc_30()
 
 /* Voices */
 
-static inline void dsp_voice_V1( dsp_voice_t* const v )
+static INLINE void dsp_voice_V1( dsp_voice_t* const v )
 {
    dsp_m.t_dir_addr = dsp_m.t_dir * 0x100 + dsp_m.t_srcn * 4;
    dsp_m.t_srcn = v->regs[V_SRCN];
 }
 
-static inline void dsp_voice_V2( dsp_voice_t* const v )
+static INLINE void dsp_voice_V2( dsp_voice_t* const v )
 {
    uint8_t *entry;
 
@@ -362,12 +360,12 @@ static inline void dsp_voice_V2( dsp_voice_t* const v )
    dsp_m.t_pitch = v->regs [V_PITCHL];
 }
 
-static inline void dsp_voice_V3a( dsp_voice_t* const v )
+static INLINE void dsp_voice_V3a( dsp_voice_t* const v )
 {
    dsp_m.t_pitch += (v->regs [V_PITCHH] & 0x3F) << 8;
 }
 
-static inline void dsp_voice_V3b( dsp_voice_t* const v )
+static INLINE void dsp_voice_V3b( dsp_voice_t* const v )
 {
    dsp_m.t_brr_byte = dsp_m.ram [(v->brr_addr + v->brr_offset) & 0xffff];
    dsp_m.t_brr_header = dsp_m.ram [v->brr_addr];
@@ -453,7 +451,7 @@ static void dsp_voice_V3c( dsp_voice_t* const v )
    }
 }
 
-static inline void dsp_voice_output( dsp_voice_t const* v, int32_t ch )
+static INLINE void dsp_voice_output( dsp_voice_t const* v, int32_t ch )
 {
    int32_t amp;
 
@@ -472,7 +470,7 @@ static inline void dsp_voice_output( dsp_voice_t const* v, int32_t ch )
    }
 }
 
-static inline void dsp_voice_V4( dsp_voice_t* const v )
+static INLINE void dsp_voice_V4( dsp_voice_t* const v )
 {
    /* Decode BRR */
    dsp_m.t_looped = 0;
@@ -504,7 +502,7 @@ static inline void dsp_voice_V4( dsp_voice_t* const v )
    dsp_voice_output( v, 0 );
 }
 
-static inline void dsp_voice_V5( dsp_voice_t* const v )
+static INLINE void dsp_voice_V5( dsp_voice_t* const v )
 {
    int32_t endx_buf;
    /* Output right */
@@ -519,13 +517,13 @@ static inline void dsp_voice_V5( dsp_voice_t* const v )
    dsp_m.endx_buf = (uint8_t) endx_buf;
 }
 
-static inline void dsp_voice_V6( dsp_voice_t* const v )
+static INLINE void dsp_voice_V6( dsp_voice_t* const v )
 {
    (void) v; /* avoid compiler warning about unused v */
    dsp_m.outx_buf = (uint8_t) (dsp_m.t_output >> 8);
 }
 
-static inline void dsp_voice_V7( dsp_voice_t* const v )
+static INLINE void dsp_voice_V7( dsp_voice_t* const v )
 {
    /* Update ENDX */
    dsp_m.regs[R_ENDX] = dsp_m.endx_buf;
@@ -533,20 +531,20 @@ static inline void dsp_voice_V7( dsp_voice_t* const v )
    dsp_m.envx_buf = v->t_envx_out;
 }
 
-static inline void dsp_voice_V8( dsp_voice_t* const v )
+static INLINE void dsp_voice_V8( dsp_voice_t* const v )
 {
    /* Update OUTX */
    v->regs [V_OUTX] = dsp_m.outx_buf;
 }
 
-static inline void dsp_voice_V9( dsp_voice_t* const v )
+static INLINE void dsp_voice_V9( dsp_voice_t* const v )
 {
    v->regs [V_ENVX] = dsp_m.envx_buf;
 }
 
 /* Most voices do all these in one clock, so make a handy composite */
 
-static inline void dsp_voice_V3( dsp_voice_t* const v )
+static INLINE void dsp_voice_V3( dsp_voice_t* const v )
 {
    dsp_voice_V3a( v );
    dsp_voice_V3b( v );
@@ -554,7 +552,7 @@ static inline void dsp_voice_V3( dsp_voice_t* const v )
 }
 
 /* Common combinations of voice steps on different voices. This greatly reduces
-   code size and allows everything to be inlined in these functions. */
+   code size and allows everything to be INLINEd in these functions. */
 
 static void dsp_voice_V7_V4_V1( dsp_voice_t* const v )
 {
@@ -599,7 +597,7 @@ static void dsp_voice_V9_V6_V3( dsp_voice_t* const v )
    ECHO_FIR( 0 ) [ch] = ECHO_FIR( 8 ) [ch] = s >> 1; \
 }
 
-static inline void dsp_echo_22()
+static INLINE void dsp_echo_22()
 {
    int32_t l, r;
 
@@ -617,7 +615,7 @@ static inline void dsp_echo_22()
    dsp_m.t_echo_in [1] = r;
 }
 
-static inline void dsp_echo_23()
+static INLINE void dsp_echo_23()
 {
    int32_t l, r;
 
@@ -630,7 +628,7 @@ static inline void dsp_echo_23()
    ECHO_READ(1);
 }
 
-static inline void dsp_echo_24()
+static INLINE void dsp_echo_24()
 {
    int32_t l, r;
 
@@ -641,7 +639,7 @@ static inline void dsp_echo_24()
    dsp_m.t_echo_in [1] += r;
 }
 
-static inline void dsp_echo_25()
+static INLINE void dsp_echo_25()
 {
    int32_t l = dsp_m.t_echo_in [0] + (((dsp_m.echo_hist_pos [6 + 1]) [0] * (int8_t) dsp_m.regs [R_FIR + 6 * 0x10]) >> 6);
    int32_t r = dsp_m.t_echo_in [1] + (((dsp_m.echo_hist_pos [6 + 1]) [1] * (int8_t) dsp_m.regs [R_FIR + 6 * 0x10]) >> 6);
@@ -667,7 +665,7 @@ static inline void dsp_echo_25()
    CLAMP16( var ); \
 }
 
-static inline void dsp_echo_26()
+static INLINE void dsp_echo_26()
 {
    int32_t l, r;
 
@@ -683,7 +681,7 @@ static inline void dsp_echo_26()
    dsp_m.t_echo_out [1] = r & ~1;
 }
 
-static inline void dsp_echo_27()
+static INLINE void dsp_echo_27()
 {
    int32_t l, r;
    int16_t *out;
@@ -726,7 +724,7 @@ static inline void dsp_echo_27()
    } \
    dsp_m.t_echo_out [ch] = 0;
 
-static inline void dsp_echo_29()
+static INLINE void dsp_echo_29()
 {
    dsp_m.t_esa = dsp_m.regs [R_ESA];
 
@@ -1246,9 +1244,10 @@ void spc_enable_rom( int32_t enable )
       dsp_run( clock_count ); \
    }
 
-static inline void spc_dsp_write( int32_t data, int32_t time )
+static INLINE void spc_dsp_write( int32_t data, int32_t time )
 {
    int32_t addr;
+   (void) time;
 
    /* Writes DSP registers. */
    addr = m.smp_regs[0][R_DSPADDR];
@@ -1863,8 +1862,6 @@ mov_abs_temp:
               SET_SP( x );
               goto loop;
 
-              /* case 0xC6: // MOV (X),A (handled by MOV addr,A in group 2) */
-
          case 0xAF: /* MOV (X)+,A */
               WRITE_DP( 0, x, a + NO_READ_BEFORE_WRITE  );
               x++;
@@ -2900,7 +2897,7 @@ static int32_t  r_left[4], r_right[4];
 #define CLAMP(x, low, high) (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x)))
 #define SHORT_CLAMP(n) ((int16_t) CLAMP((n), -32768, 32767))
 
-static inline int32_t hermite (int32_t mu1, int32_t a, int32_t b, int32_t c, int32_t d)
+static INLINE int32_t hermite (int32_t mu1, int32_t a, int32_t b, int32_t c, int32_t d)
 {
    int32_t mu2, mu3, m0, m1, a0, a1, a2, a3;
 
@@ -3006,7 +3003,7 @@ static void resampler_new(int32_t num_samples)
    resampler_clear();
 }
 
-static inline bool resampler_push(int16_t *src, int32_t num_samples)
+static INLINE bool resampler_push(int16_t *src, int32_t num_samples)
 {
    int32_t bytes, end, first_write_size;
    uint8_t  *src_ring;
@@ -3030,8 +3027,9 @@ static inline bool resampler_push(int16_t *src, int32_t num_samples)
    return true;
 }
 
-static inline void resampler_resize (int32_t num_samples)
+static INLINE void resampler_resize (int32_t num_samples)
 {
+   (void) num_samples;
    free(rb_buffer);
    rb_buffer_size = rb_size;
    rb_buffer = (uint8_t *)malloc(rb_buffer_size);
@@ -3394,8 +3392,8 @@ static void to_apu_from_state (uint8_t **buf, void *var, size_t size)
    *buf += size;
 }
 
-// work around optimization bug in android GCC
-// similar to this: http://jeffq.com/blog/over-aggressive-gcc-optimization-can-cause-sigbus-crash-when-using-memcpy-with-the-android-ndk/
+/* work around optimization bug in android GCC
+   similar to this: http://jeffq.com/blog/over-aggressive-gcc-optimization-can-cause-sigbus-crash-when-using-memcpy-with-the-android-ndk/ */
 #if defined(ANDROID) || defined(__QNX__)
 void __attribute__((optimize(0))) S9xAPUSaveState (uint8_t *block)
 #else
diff --git a/source/apu_blargg.h b/source/apu_blargg.h
index 3a07e2c..65faafd 100644
--- a/source/apu_blargg.h
+++ b/source/apu_blargg.h
@@ -82,17 +82,17 @@ typedef void (*dsp_copy_func_t)( uint8_t ** io, void* state, size_t );
 
 typedef struct
 {
-   int32_t  buf [BRR_BUF_SIZE_X2]; // decoded samples (twice the size to simplify wrap handling)
-   int32_t  buf_pos;               // place in buffer where next samples will be decoded
-   int32_t  interp_pos;            // relative fractional position in sample (0x1000 = 1.0)
-   int32_t  brr_addr;              // address of current BRR block
-   int32_t  brr_offset;            // current decoding offset in BRR block
-   uint8_t* regs;                  // pointer to voice's DSP registers
-   int32_t  vbit;                  // bitmask for voice: 0x01 for voice 0, 0x02 for voice 1, etc.
-   int32_t  kon_delay;             // KON delay/current setup phase
+   int32_t  buf [BRR_BUF_SIZE_X2]; /* decoded samples (twice the size to simplify wrap handling) */
+   int32_t  buf_pos;               /* place in buffer where next samples will be decoded */
+   int32_t  interp_pos;            /* relative fractional position in sample (0x1000 = 1.0) */
+   int32_t  brr_addr;              /* address of current BRR block */
+   int32_t  brr_offset;            /* current decoding offset in BRR block */
+   uint8_t* regs;                  /* pointer to voice's DSP registers */
+   int32_t  vbit;                  /* bitmask for voice: 0x01 for voice 0, 0x02 for voice 1, etc. */
+   int32_t  kon_delay;             /* KON delay/current setup phase */
    int32_t  env_mode;
-   int32_t  env;                   // current envelope level
-   int32_t  hidden_env;            // used by GAIN mode 7, very obscure quirk
+   int32_t  env;                   /* current envelope level */
+   int32_t  hidden_env;            /* used by GAIN mode 7, very obscure quirk */
    uint8_t  t_envx_out;
 } dsp_voice_t;
 
@@ -292,5 +292,5 @@ void    S9xClearSamples();
 bool    S9xMixSamples(int16_t * buffer, uint32_t sample_count);
 void    S9xSetSamplesAvailableCallback(apu_callback);
 
-#endif // APU_BLARGG_H
+#endif /* APU_BLARGG_H */
 #endif
diff --git a/source/apumem.h b/source/apumem.h
index c58b808..c021e41 100644
--- a/source/apumem.h
+++ b/source/apumem.h
@@ -3,10 +3,12 @@
 #ifndef _apumemory_h_
 #define _apumemory_h_
 
+#include <retro_inline.h>
+
 extern uint8_t W4;
 extern uint8_t APUROM[64];
 
-static inline uint8_t S9xAPUGetByteZ(uint8_t Address)
+static INLINE uint8_t S9xAPUGetByteZ(uint8_t Address)
 {
    if (Address >= 0xf0 && IAPU.DirectPage == IAPU.RAM)
    {
@@ -14,25 +16,25 @@ static inline uint8_t S9xAPUGetByteZ(uint8_t Address)
       {
          IAPU.WaitAddress2 = IAPU.WaitAddress1;
          IAPU.WaitAddress1 = IAPU.PC;
-         return (IAPU.RAM [Address]);
+         return IAPU.RAM [Address];
       }
       if (Address >= 0xfd)
       {
+         uint8_t t = IAPU.RAM [Address];
          IAPU.WaitAddress2 = IAPU.WaitAddress1;
          IAPU.WaitAddress1 = IAPU.PC;
-         uint8_t t = IAPU.RAM [Address];
          IAPU.RAM [Address] = 0;
-         return (t);
+         return t;
       }
       else if (Address == 0xf3)
-         return (S9xGetAPUDSP());
+         return S9xGetAPUDSP();
 
-      return (IAPU.RAM [Address]);
+      return IAPU.RAM [Address];
    }
-   return (IAPU.DirectPage [Address]);
+   return IAPU.DirectPage [Address];
 }
 
-static inline void S9xAPUSetByteZ(uint8_t byte, uint8_t Address)
+static INLINE void S9xAPUSetByteZ(uint8_t byte, uint8_t Address)
 {
    if (Address >= 0xf0 && IAPU.DirectPage == IAPU.RAM)
    {
@@ -58,7 +60,7 @@ static inline void S9xAPUSetByteZ(uint8_t byte, uint8_t Address)
       IAPU.DirectPage [Address] = byte;
 }
 
-static inline uint8_t S9xAPUGetByte(uint32_t Address)
+static INLINE uint8_t S9xAPUGetByte(uint32_t Address)
 {
    Address &= 0xffff;
 
@@ -80,7 +82,7 @@ static inline uint8_t S9xAPUGetByte(uint32_t Address)
    return t;
 }
 
-static inline void S9xAPUSetByte(uint8_t byte, uint32_t Address)
+static INLINE void S9xAPUSetByte(uint8_t byte, uint32_t Address)
 {
    Address &= 0xffff;
 
diff --git a/source/dsp4emu.c b/source/dsp4emu.c
index 6c492e9..da6e80f 100644
--- a/source/dsp4emu.c
+++ b/source/dsp4emu.c
@@ -114,23 +114,22 @@ resume1:
       DSP4.in_count = 8;
       DSP4_WAIT(2);
 
-      ////////////////////////////////////////////////////
-      // process one iteration of projection
+      /* process one iteration of projection */
 
-      // inspect inputs
+      /* inspect inputs */
 
 resume2:
       plane = DSP4_READ_WORD(0);
       px_dx = 0;
 
-      // ignore invalid data
+      /* ignore invalid data */
       if((uint16_t) plane == 0x8001)
          continue;
 
-      // one-time init
+      /* one-time init */
       if (far_plane)
       {
-         // setup final parameters
+         /* setup final parameters */
          project_focalx += plane;
          project_x1 = project_focalx;
          project_y1 = project_focaly;
@@ -138,37 +137,37 @@ resume2:
          far_plane = 0;
       }
 
-      // use proportional triangles to project new coords
+      /* use proportional triangles to project new coords */
       project_x2 = project_focalx * plane / view_plane;
       project_y2 = project_focaly * plane / view_plane;
 
-      // quadratic regression (rough)
+      /* quadratic regression (rough) */
       if (project_focaly >= -0x0f)
          py_dy = (int16_t)(project_focaly * project_focaly * -0.20533553 - 1.08330005 * project_focaly - 69.61094639);
       else
          py_dy = (int16_t)(project_focaly * project_focaly * -0.000657035759 - 1.07629051 * project_focaly - 65.69315963);
 
-      // approximate # of raster lines
+      /* approximate # of raster lines */
       segments = ABS(project_y2 - project_y1);
 
-      // prevent overdraw
+      /* prevent overdraw */
       if(project_y2 >= raster)
          segments = 0;
       else
          raster = project_y2;
 
-      // don't draw outside the window
+      /* don't draw outside the window */
       if(project_y2 < viewport_top)
          segments = 0;
 
-      // project new positions
+      /* project new positions */
       if (segments > 0)
-         px_dx = ((project_x2 - project_x1) << 8) / segments; // interpolate between projected points
+         px_dx = ((project_x2 - project_x1) << 8) / segments; /* interpolate between projected points */
 
-      // prepare output
+      /* prepare output */
       DSP4.out_count = 8 + 2 + 6 * segments;
 
-      // pre-block data
+      /* pre-block data */
       DSP4_WRITE_WORD(0, project_focalx);
       DSP4_WRITE_WORD(2, project_x2);
       DSP4_WRITE_WORD(4, project_focaly);
@@ -177,38 +176,38 @@ resume2:
 
       index = 10;
 
-      for (lcv = 0; lcv < segments; lcv++) // iterate through each point
+      for (lcv = 0; lcv < segments; lcv++) /* iterate through each point */
       {
-         // step through the projected line
+         /* step through the projected line */
          y_out = project_y + ((py_dy * lcv) >> 8);
          x_out = project_x + ((px_dx * lcv) >> 8);
 
-         // data
+         /* data */
          DSP4_WRITE_WORD(index + 0, project_ptr);
          DSP4_WRITE_WORD(index + 2, y_out);
          DSP4_WRITE_WORD(index + 4, x_out);
          index += 6;
 
-         // post-update
+         /* post-update */
          project_ptr -= 4;
       }
 
-      // post-update
+      /* post-update */
       project_y += ((py_dy * lcv) >> 8);
       project_x += ((px_dx * lcv) >> 8);
 
-      if (segments > 0) // new positions
+      if (segments > 0) /* new positions */
       {
          project_x1 = project_x2;
          project_y1 = project_y2;
 
-         // multi-op storage
+         /* multi-op storage */
          multi_focaly[multi_index2++] = project_focaly;
          multi_farplane[1] = plane;
          multi_raster[1] = project_y1 - 1;
       }
 
-      // update projection points
+      /* update projection points */
       project_pitchy += (int8_t)DSP4.parameters[3];
       project_pitchx += (int8_t)DSP4.parameters[5];
 
@@ -216,7 +215,7 @@ resume2:
       project_focalx += project_pitchx;
    } while (1);
 
-   // terminate op
+   /* terminate op */
    DSP4.waiting4command = true;
    DSP4.out_count = 0;
 }
@@ -231,7 +230,7 @@ void DSP4_Op07(void)
 
    DSP4.waiting4command = false;
 
-   // op flow control
+   /* op flow control */
    switch (DSP4_Logic)
    {
    case 1:
@@ -242,8 +241,7 @@ void DSP4_Op07(void)
       break;
    }
 
-   ////////////////////////////////////////////////////
-   // sort inputs
+   /* sort inputs */
 
    project_focaly = DSP4_READ_WORD(0x02);
    raster = DSP4_READ_WORD(0x04);
@@ -255,84 +253,82 @@ void DSP4_Op07(void)
    project_centerx = DSP4_READ_WORD(0x10);
    project_ptr = DSP4_READ_WORD(0x12);
 
-   // pre-compute
+   /* pre-compute */
    view_plane = PLANE_START;
 
-   // find projection targets
+   /* find projection targets */
    project_y1 = project_focaly;
    project_y -= viewport_bottom;
    project_x = project_centerx + project_x1;
 
-   // multi-op storage
+   /* multi-op storage */
    multi_index2 = 0;
 
-   ////////////////////////////////////////////////////
-   // command check
+   /* command check */
 
    do
    {
-      // scan next command
+      /* scan next command */
       DSP4.in_count = 2;
       DSP4_WAIT(1);
 
 resume1:
-      // inspect input
+      /* inspect input */
       command = DSP4_READ_WORD(0);
 
-      // check for opcode termination
+      /* check for opcode termination */
       if(command == 0x8000)
          break;
 
-      // already have 2 bytes in queue
+      /* already have 2 bytes in queue */
       DSP4.in_index = 2;
       DSP4.in_count = 12;
       DSP4_WAIT(2);
 
-      ////////////////////////////////////////////////////
-      // process one loop of projection
+      /* process one loop of projection */
 
 resume2:
       px_dx = 0;
 
-      // inspect inputs
+      /* inspect inputs */
       plane = DSP4_READ_WORD(0);
       project_y2 = DSP4_READ_WORD(2);
       project_x2 = DSP4_READ_WORD(6);
 
-      // ignore invalid data
+      /* ignore invalid data */
       if((uint16_t) plane == 0x8001)
          continue;
 
-      // multi-op storage
+      /* multi-op storage */
       project_focaly = multi_focaly[multi_index2];
 
-      // quadratic regression (rough)
+      /* quadratic regression (rough) */
       if (project_focaly >= -0x0f)
          py_dy = (int16_t)(project_focaly * project_focaly * -0.20533553 - 1.08330005 * project_focaly - 69.61094639);
       else
          py_dy = (int16_t)(project_focaly * project_focaly * -0.000657035759 - 1.07629051 * project_focaly - 65.69315963);
 
-      // approximate # of raster lines
+      /* approximate # of raster lines */
       segments = ABS(project_y2 - project_y1);
 
-      // prevent overdraw
+      /* prevent overdraw */
       if(project_y2 >= raster)
          segments = 0;
       else
          raster = project_y2;
 
-      // don't draw outside the window
+      /* don't draw outside the window */
       if(project_y2 < viewport_top)
          segments = 0;
 
-      // project new positions
+      /* project new positions */
       if (segments > 0)
       {
-         // interpolate between projected points
+         /* interpolate between projected points */
          px_dx = ((project_x2 - project_x1) << 8) / segments;
       }
 
-      // prepare pre-output
+      /* prepare pre-output */
       DSP4.out_count = 4 + 2 + 6 * segments;
 
       DSP4_WRITE_WORD(0, project_x2);
@@ -342,31 +338,31 @@ resume2:
       index = 6;
       for (lcv = 0; lcv < segments; lcv++)
       {
-         // pre-compute
+         /* pre-compute */
          y_out = project_y + ((py_dy * lcv) >> 8);
          x_out = project_x + ((px_dx * lcv) >> 8);
 
-         // data
+         /* data */
          DSP4_WRITE_WORD(index + 0, project_ptr);
          DSP4_WRITE_WORD(index + 2, y_out);
          DSP4_WRITE_WORD(index + 4, x_out);
          index += 6;
 
-         // post-update
+         /* post-update */
          project_ptr -= 4;
       }
 
-      // update internal variables
+      /* update internal variables */
       project_y += ((py_dy * lcv) >> 8);
       project_x += ((px_dx * lcv) >> 8);
 
-      // new positions
+      /* new positions */
       if (segments > 0)
       {
          project_x1 = project_x2;
          project_y1 = project_y2;
 
-         // multi-op storage
+         /* multi-op storage */
          multi_index2++;
       }
    } while (1);
@@ -378,14 +374,14 @@ resume2:
 void DSP4_Op08(void)
 {
    uint16_t command;
-   // used in envelope shaping
+   /* used in envelope shaping */
    int16_t x1_final;
    int16_t x2_final;
    int16_t plane, x_left, y_left, x_right, y_right;
    int16_t envelope1, envelope2;
    DSP4.waiting4command = false;
 
-   // op flow control
+   /* op flow control */
    switch (DSP4_Logic)
    {
    case 1:
@@ -396,10 +392,9 @@ void DSP4_Op08(void)
       break;
    }
 
-   ////////////////////////////////////////////////////
-   // process initial inputs
+   /* process initial inputs */
 
-   // clip values
+   /* clip values */
    path_clipRight[0] = DSP4_READ_WORD(0x00);
    path_clipRight[1] = DSP4_READ_WORD(0x02);
    path_clipRight[2] = DSP4_READ_WORD(0x04);
@@ -410,88 +405,86 @@ void DSP4_Op08(void)
    path_clipLeft[2] = DSP4_READ_WORD(0x0c);
    path_clipLeft[3] = DSP4_READ_WORD(0x0e);
 
-   // path positions
+   /* path positions */
    path_pos[0] = DSP4_READ_WORD(0x20);
    path_pos[1] = DSP4_READ_WORD(0x22);
    path_pos[2] = DSP4_READ_WORD(0x24);
    path_pos[3] = DSP4_READ_WORD(0x26);
 
-   // data locations
+   /* data locations */
    path_ptr[0] = DSP4_READ_WORD(0x28);
    path_ptr[1] = DSP4_READ_WORD(0x2a);
    path_ptr[2] = DSP4_READ_WORD(0x2c);
    path_ptr[3] = DSP4_READ_WORD(0x2e);
 
-   // project_y1 lines
+   /* project_y1 lines */
    path_raster[0] = DSP4_READ_WORD(0x30);
    path_raster[1] = DSP4_READ_WORD(0x32);
    path_raster[2] = DSP4_READ_WORD(0x34);
    path_raster[3] = DSP4_READ_WORD(0x36);
 
-   // viewport_top
+   /* viewport_top */
    path_top[0] = DSP4_READ_WORD(0x38);
    path_top[1] = DSP4_READ_WORD(0x3a);
    path_top[2] = DSP4_READ_WORD(0x3c);
    path_top[3] = DSP4_READ_WORD(0x3e);
 
-   // unknown (constants)
+   /* unknown (constants) */
 
    view_plane = PLANE_START;
 
-   ////////////////////////////////////////////////////
-   // command check
+   /* command check */
 
    do
    {
-      // scan next command
+      /* scan next command */
       DSP4.in_count = 2;
       DSP4_WAIT(1);
 
 resume1:
-      // inspect input
+      /* inspect input */
       command = DSP4_READ_WORD(0);
 
-      // terminate op
+      /* terminate op */
       if(command == 0x8000)
          break;
 
-      // already have 2 bytes in queue
+      /* already have 2 bytes in queue */
       DSP4.in_index = 2;
       DSP4.in_count = 18;
       DSP4_WAIT(2);
 
 resume2:
-      ////////////////////////////////////////////////////
-      // projection begins
+      /* projection begins */
 
-      // look at guidelines
+      /* look at guidelines */
       plane = DSP4_READ_WORD(0x00);
       x_left = DSP4_READ_WORD(0x02);
       y_left = DSP4_READ_WORD(0x04);
       x_right = DSP4_READ_WORD(0x06);
       y_right = DSP4_READ_WORD(0x08);
 
-      // envelope guidelines (one frame only)
+      /* envelope guidelines (one frame only) */
       envelope1 = DSP4_READ_WORD(0x0a);
       envelope2 = DSP4_READ_WORD(0x0c);
 
-      // ignore invalid data
+      /* ignore invalid data */
       if((uint16_t) plane == 0x8001)
          continue;
 
-      // first init
+      /* first init */
       if (plane == 0x7fff)
       {
          int32_t pos1, pos2;
 
-         // initialize projection
+         /* initialize projection */
          path_x[0] = x_left;
          path_x[1] = x_right;
 
          path_y[0] = y_left;
          path_y[1] = y_right;
 
-         // update coordinates
+         /* update coordinates */
          path_pos[0] -= x_left;
          path_pos[1] -= x_left;
          path_pos[2] -= x_right;
@@ -500,7 +493,7 @@ resume2:
          pos1 = path_pos[0] + envelope1;
          pos2 = path_pos[1] + envelope2;
 
-         // clip offscreen data
+         /* clip offscreen data */
          if(pos1 < path_clipLeft[0])
             pos1 = path_clipLeft[0];
          if(pos1 > path_clipRight[0])
@@ -513,59 +506,59 @@ resume2:
          path_plane[0] = plane;
          path_plane[1] = plane;
 
-         // initial output
+         /* initial output */
          DSP4.out_count = 2;
          DSP4.output[0] = pos1 & 0xFF;
          DSP4.output[1] = pos2 & 0xFF;
       }
-      // proceed with projection
+      /* proceed with projection */
       else
       {
          int16_t index = 0, lcv;
          int16_t left_inc = 0, right_inc = 0;
          int16_t dx1 = 0, dx2 = 0, dx3, dx4;
 
-         // # segments to traverse
+         /* # segments to traverse */
          segments = ABS(y_left - path_y[0]);
 
-         // prevent overdraw
+         /* prevent overdraw */
          if(y_left >= path_raster[0])
             segments = 0;
          else
             path_raster[0] = y_left;
 
-         // don't draw outside the window
+         /* don't draw outside the window */
          if(path_raster[0] < path_top[0])
             segments = 0;
 
-         // proceed if visibility rules apply
+         /* proceed if visibility rules apply */
          if (segments > 0)
          {
-            // use previous data
+            /* use previous data */
             dx1 = (envelope1 * path_plane[0] / view_plane);
             dx2 = (envelope2 * path_plane[0] / view_plane);
 
-            // use temporary envelope pitch (this frame only)
+            /* use temporary envelope pitch (this frame only) */
             dx3 = (envelope1 * plane / view_plane);
             dx4 = (envelope2 * plane / view_plane);
 
-            // project new shapes (left side)
+            /* project new shapes (left side) */
             x1_final = x_left + dx1;
             x2_final = path_x[0] + dx3;
 
-            // interpolate between projected points with shaping
+            /* interpolate between projected points with shaping */
             left_inc = ((x2_final - x1_final) << 8) / segments;
 
-            // project new shapes (right side)
+            /* project new shapes (right side) */
             x1_final = x_left + dx2;
             x2_final = path_x[0] + dx4;
 
-            // interpolate between projected points with shaping
+            /* interpolate between projected points with shaping */
             right_inc = ((x2_final - x1_final) << 8) / segments;
             path_plane[0] = plane;
          }
 
-         // zone 1
+         /* zone 1 */
          DSP4.out_count = (2 + 4 * segments);
          DSP4_WRITE_WORD(index, segments);
          index += 2;
@@ -574,11 +567,11 @@ resume2:
          {
             int16_t pos1, pos2;
 
-            // pre-compute
+            /* pre-compute */
             pos1 = path_pos[0] + ((left_inc * lcv) >> 8) + dx1;
             pos2 = path_pos[1] + ((right_inc * lcv) >> 8) + dx2;
 
-            // clip offscreen data
+            /* clip offscreen data */
             if(pos1 < path_clipLeft[0])
                pos1 = path_clipLeft[0];
             if(pos1 > path_clipRight[0])
@@ -588,13 +581,13 @@ resume2:
             if(pos2 > path_clipRight[1])
                pos2 = path_clipRight[1];
 
-            // data
+            /* data */
             DSP4_WRITE_WORD(index, path_ptr[0]);
             index += 2;
             DSP4.output[index++] = pos1 & 0xFF;
             DSP4.output[index++] = pos2 & 0xFF;
 
-            // post-update
+            /* post-update */
             path_ptr[0] -= 4;
             path_ptr[1] -= 4;
          }
@@ -602,10 +595,10 @@ resume2:
 
          if (segments > 0)
          {
-            // project points w/out the envelopes
+            /* project points w/out the envelopes */
             int16_t inc = ((path_x[0] - x_left) << 8) / segments;
 
-            // post-store
+            /* post-store */
             path_pos[0] += ((inc * lcv) >> 8);
             path_pos[1] += ((inc * lcv) >> 8);
 
@@ -613,48 +606,47 @@ resume2:
             path_y[0] = y_left;
          }
 
-         //////////////////////////////////////////////
-         // zone 2
+         /* zone 2 */
          segments = ABS(y_right - path_y[1]);
 
-         // prevent overdraw
+         /* prevent overdraw */
          if(y_right >= path_raster[2])
             segments = 0;
          else path_raster[2] = y_right;
 
-         // don't draw outside the window
+         /* don't draw outside the window */
          if(path_raster[2] < path_top[2])
             segments = 0;
 
-         // proceed if visibility rules apply
+         /* proceed if visibility rules apply */
          if (segments > 0)
          {
-            // use previous data
+            /* use previous data */
             dx1 = (envelope1 * path_plane[1] / view_plane);
             dx2 = (envelope2 * path_plane[1] / view_plane);
 
-            // use temporary envelope pitch (this frame only)
+            /* use temporary envelope pitch (this frame only) */
             dx3 = (envelope1 * plane / view_plane);
             dx4 = (envelope2 * plane / view_plane);
 
-            // project new shapes (left side)
+            /* project new shapes (left side) */
             x1_final = x_left + dx1;
             x2_final = path_x[1] + dx3;
 
-            // interpolate between projected points with shaping
+            /* interpolate between projected points with shaping */
             left_inc = ((x2_final - x1_final) << 8) / segments;
 
-            // project new shapes (right side)
+            /* project new shapes (right side) */
             x1_final = x_left + dx2;
             x2_final = path_x[1] + dx4;
 
-            // interpolate between projected points with shaping
+            /* interpolate between projected points with shaping */
             right_inc = ((x2_final - x1_final) << 8) / segments;
 
             path_plane[1] = plane;
          }
 
-         // write out results
+         /* write out results */
          DSP4.out_count += (2 + 4 * segments);
          DSP4_WRITE_WORD(index, segments);
          index += 2;
@@ -663,11 +655,11 @@ resume2:
          {
             int16_t pos1, pos2;
 
-            // pre-compute
+            /* pre-compute */
             pos1 = path_pos[2] + ((left_inc * lcv) >> 8) + dx1;
             pos2 = path_pos[3] + ((right_inc * lcv) >> 8) + dx2;
 
-            // clip offscreen data
+            /* clip offscreen data */
             if(pos1 < path_clipLeft[2])
                pos1 = path_clipLeft[2];
             if(pos1 > path_clipRight[2])
@@ -677,13 +669,13 @@ resume2:
             if(pos2 > path_clipRight[3])
                pos2 = path_clipRight[3];
 
-            // data
+            /* data */
             DSP4_WRITE_WORD(index, path_ptr[2]);
             index += 2;
             DSP4.output[index++] = pos1 & 0xFF;
             DSP4.output[index++] = pos2 & 0xFF;
 
-            // post-update
+            /* post-update */
             path_ptr[2] -= 4;
             path_ptr[3] -= 4;
          }
@@ -691,10 +683,10 @@ resume2:
 
          if (segments > 0)
          {
-            // project points w/out the envelopes
+            /* project points w/out the envelopes */
             int16_t inc = ((path_x[1] - x_right) << 8) / segments;
 
-            // post-store
+            /* post-store */
             path_pos[2] += ((inc * lcv) >> 8);
             path_pos[3] += ((inc * lcv) >> 8);
 
@@ -712,7 +704,7 @@ resume2:
 void DSP4_Op0D(void)
 {
    uint16_t command;
-   // inspect inputs
+   /* inspect inputs */
    int16_t plane;
    int16_t index, lcv;
    int16_t py_dy, px_dx;
@@ -720,7 +712,7 @@ void DSP4_Op0D(void)
 
    DSP4.waiting4command = false;
 
-   // op flow control
+   /* op flow control */
    switch (DSP4_Logic)
    {
    case 1:
@@ -731,10 +723,9 @@ void DSP4_Op0D(void)
       break;
    }
 
-   ////////////////////////////////////////////////////
-   // process initial inputs
+   /* process initial inputs */
 
-   // sort inputs
+   /* sort inputs */
    project_focaly = DSP4_READ_WORD(0x02);
    raster = DSP4_READ_WORD(0x04);
    viewport_top = DSP4_READ_WORD(0x06);
@@ -751,15 +742,14 @@ void DSP4_Op0D(void)
    project_pitchx = DSP4_READ_WORD(0x1c);
    far_plane = DSP4_READ_WORD(0x1e);
 
-   // multi-op storage
+   /* multi-op storage */
    multi_index1++;
    multi_index1 %= 4;
 
-   // remap 0D->09 window data ahead of time
-   // index starts at 1-3,0
-   //
-   // Op0D: BL,TL,BR,TR
-   // Op09: TL,TR,BL,BR (1,2,3,0)
+   /* remap 0D->09 window data ahead of time */
+   /* index starts at 1-3,0 */
+   /* Op0D: BL,TL,BR,TR */
+   /* Op09: TL,TR,BL,BR (1,2,3,0) */
    switch (multi_index1)
    {
    case 1:
@@ -776,88 +766,86 @@ void DSP4_Op0D(void)
       break;
    }
 
-   // pre-compute
+   /* pre-compute */
    view_plane = PLANE_START;
 
-   // figure out projection data
+   /* figure out projection data */
    project_y -= viewport_bottom;
    project_x = project_centerx + project_x1;
 
-   ////////////////////////////////////////////////////
-   // command check
+   /* command check */
 
    do
    {
-      // scan next command
+      /* scan next command */
       DSP4.in_count = 2;
       DSP4_WAIT(1);
 
 resume1:
-      // inspect input
+      /* inspect input */
       command = DSP4_READ_WORD(0);
 
-      // terminate op
+      /* terminate op */
       if(command == 0x8000)
          break;
 
-      // already have 2 bytes in queue
+      /* already have 2 bytes in queue */
       DSP4.in_index = 2;
       DSP4.in_count = 8;
       DSP4_WAIT(2);
 
-      ////////////////////////////////////////////////////
-      // project section of the track
+      /* project section of the track */
 
 resume2:
       plane = DSP4_READ_WORD(0);
       px_dx = 0;
 
 
-      // ignore invalid data
+      /* ignore invalid data */
       if((uint16_t) plane == 0x8001)
          continue;
 
-      // one-time init
+      /* one-time init */
       if (far_plane)
       {
-         // setup final data
+         /* setup final data */
          project_x1 = project_focalx;
          project_y1 = project_focaly;
          plane = far_plane;
          far_plane = 0;
       }
 
-      // use proportional triangles to project new coords
+      /* use proportional triangles to project new coords */
       project_x2 = project_focalx * plane / view_plane;
       project_y2 = project_focaly * plane / view_plane;
 
-      // quadratic regression (rough)
+      /* quadratic regression (rough) */
       if (project_focaly >= -0x0f)
          py_dy = (int16_t)(project_focaly * project_focaly * -0.20533553 - 1.08330005 * project_focaly - 69.61094639);
       else
          py_dy = (int16_t)(project_focaly * project_focaly * -0.000657035759 - 1.07629051 * project_focaly - 65.69315963);
 
-      // approximate # of raster lines
+      /* approximate # of raster lines */
       segments = ABS(project_y2 - project_y1);
 
-      // prevent overdraw
+      /* prevent overdraw */
       if(project_y2 >= raster)
          segments = 0;
       else
          raster = project_y2;
 
-      // don't draw outside the window
+      /* don't draw outside the window */
       if(project_y2 < viewport_top)
          segments = 0;
 
-      // project new positions
+      /* project new positions */
       if (segments > 0)
       {
-         // interpolate between projected points
+         /* interpolate between projected points */
          px_dx = ((project_x2 - project_x1) << 8) / segments;
       }
 
-      // prepare output
+      /* prepare output */
       DSP4.out_count = 8 + 2 + 6 * segments;
       DSP4_WRITE_WORD(0, project_focalx);
       DSP4_WRITE_WORD(2, project_x2);
@@ -866,23 +854,23 @@ resume2:
       DSP4_WRITE_WORD(8, segments);
       index = 10;
 
-      for (lcv = 0; lcv < segments; lcv++) // iterate through each point
+      for (lcv = 0; lcv < segments; lcv++) /* iterate through each point */
       {
-         // step through the projected line
+         /* step through the projected line */
          y_out = project_y + ((py_dy * lcv) >> 8);
          x_out = project_x + ((px_dx * lcv) >> 8);
 
-         // data
+         /* data */
          DSP4_WRITE_WORD(index + 0, project_ptr);
          DSP4_WRITE_WORD(index + 2, y_out);
          DSP4_WRITE_WORD(index + 4, x_out);
          index += 6;
 
-         // post-update
+         /* post-update */
          project_ptr -= 4;
       }
 
-      // post-update
+      /* post-update */
       project_y += ((py_dy * lcv) >> 8);
       project_x += ((px_dx * lcv) >> 8);
 
@@ -891,12 +879,12 @@ resume2:
          project_x1 = project_x2;
          project_y1 = project_y2;
 
-         // multi-op storage
+         /* multi-op storage */
          multi_farplane[multi_index2] = plane;
          multi_raster[multi_index2] = project_y1;
       }
 
-      // update focal projection points
+      /* update focal projection points */
       project_pitchy += (int8_t)DSP4.parameters[3];
       project_pitchx += (int8_t)DSP4.parameters[5];
 
@@ -917,7 +905,7 @@ void DSP4_Op09(void)
 
    DSP4.waiting4command = false;
 
-   // op flow control
+   /* op flow control */
    switch (DSP4_Logic)
    {
    case 1:
@@ -943,10 +931,9 @@ void DSP4_Op09(void)
       break;
    }
 
-   ////////////////////////////////////////////////////
-   // process initial inputs
+   /* process initial inputs */
 
-   // grab screen information
+   /* grab screen information */
    view_plane = PLANE_START;
    center_x = DSP4_READ_WORD(0x00);
    center_y = DSP4_READ_WORD(0x02);
@@ -955,14 +942,14 @@ void DSP4_Op09(void)
    viewport_top = DSP4_READ_WORD(0x0a);
    viewport_bottom = DSP4_READ_WORD(0x0c);
 
-   // expand viewport dimensions
+   /* expand viewport dimensions */
    viewport_left -= 8;
 
-   // cycle through viewport window data
+   /* cycle through viewport window data */
    multi_index1++;
    multi_index1 %= 4;
 
-   // convert track line to the window region
+   /* convert track line to the window region */
    project_y2 = center_y + multi_raster[multi_index1] * (viewport_bottom - center_y) / (0x33 - 0);
    if (!op09_mode)
       project_y2 -= 2;
@@ -971,8 +958,7 @@ void DSP4_Op09(void)
 
    do
    {
-      ////////////////////////////////////////////////////
-      // check for new sprites
+      /* check for new sprites */
       do
       {
          uint16_t second;
@@ -982,23 +968,23 @@ void DSP4_Op09(void)
          DSP4_WAIT(1);
 
 resume1:
-         // try to classify sprite
+         /* try to classify sprite */
          second = DSP4_READ_WORD(2);
 
-         // op termination
+         /* op termination */
          if(second == 0x8000)
             goto terminate;
 
          second >>= 8;
          sprite_type = 0;
 
-         // vehicle sprite
+         /* vehicle sprite */
          if (second == 0x90)
          {
             sprite_type = 1;
             break;
          }
-         // terrain sprite
+         /* terrain sprite */
          else if (second != 0)
          {
             sprite_type = 2;
@@ -1006,18 +992,17 @@ resume1:
          }
 
 no_sprite:
-         // no sprite. try again
+         /* no sprite. try again */
          DSP4.in_count = 2;
          DSP4_WAIT(2);
 
 resume2:;
       } while (1);
 
-      ////////////////////////////////////////////////////
-      // process projection information
+      /* process projection information */
 
 sprite_found:
-      // vehicle sprite
+      /* vehicle sprite */
       if (sprite_type == 1)
       {
          int16_t plane;
@@ -1025,60 +1010,60 @@ sprite_found:
          int16_t focal_back;
          int32_t height;
 
-         // we already have 4 bytes we want
+         /* we already have 4 bytes we want */
          DSP4.in_count = 6 + 12;
          DSP4.in_index = 4;
          DSP4_WAIT(3);
 
 resume3:
-         // filter inputs
+         /* filter inputs */
          project_y1 = DSP4_READ_WORD(0x00);
          focal_back = DSP4_READ_WORD(0x06);
          car_left = DSP4_READ_WORD(0x0c);
          plane = DSP4_READ_WORD(0x0e);
          car_right = DSP4_READ_WORD(0x10);
 
-         // calculate car's x-center
+         /* calculate car's x-center */
          project_focalx = car_right - car_left;
 
-         // determine how far into the screen to project
+         /* determine how far into the screen to project */
          project_focaly = focal_back;
          project_x = project_focalx * plane / view_plane;
          segments = 0x33 - project_focaly * plane / view_plane;
          far_plane = plane;
 
-         // prepare memory
+         /* prepare memory */
          sprite_x = center_x + project_x;
          sprite_y = viewport_bottom - segments;
          far_plane = plane;
 
-         // make the car's x-center available
+         /* make the car's x-center available */
          DSP4.out_count = 2;
          DSP4_WRITE_WORD(0, project_focalx);
 
-         // grab a few remaining vehicle values
+         /* grab a few remaining vehicle values */
          DSP4.in_count = 4;
 
          DSP4_WAIT(4);
 
-resume4: // store final values
+resume4: /* store final values */
          height = DSP4_READ_WORD(0);
          sprite_offset = DSP4_READ_WORD(2);
 
-         // vertical lift factor
+         /* vertical lift factor */
          sprite_y += height;
       }
-      else if (sprite_type == 2) // terrain sprite
+      else if (sprite_type == 2) /* terrain sprite */
       {
          int16_t plane;
 
-         // we already have 4 bytes we want
+         /* we already have 4 bytes we want */
          DSP4.in_count = 6 + 6 + 2;
          DSP4.in_index = 4;
          DSP4_WAIT(5);
 
 resume5:
-         // sort loop inputs
+         /* sort loop inputs */
          project_y1 = DSP4_READ_WORD(0x00);
          plane = DSP4_READ_WORD(0x02);
          project_centerx = DSP4_READ_WORD(0x04);
@@ -1086,21 +1071,21 @@ resume5:
          project_focaly = DSP4_READ_WORD(0x0a);
          sprite_offset = DSP4_READ_WORD(0x0c);
 
-         // determine distances into virtual world
+         /* determine distances into virtual world */
          segments = 0x33 - project_y1;
          project_x = project_focalx * plane / view_plane;
          project_y = project_focaly * plane / view_plane;
 
-         // prepare memory
+         /* prepare memory */
          sprite_x = center_x + project_x - project_centerx;
          sprite_y = viewport_bottom - segments + project_y;
          far_plane = plane;
       }
 
-      // default sprite size: 16x16
+      /* default sprite size: 16x16 */
       sprite_size = true;
 
-      // convert tile data to OAM
+      /* convert tile data to OAM */
 
       do
       {
@@ -1110,18 +1095,18 @@ resume5:
 resume6:
          command = DSP4_READ_WORD(0);
 
-         // opcode termination
+         /* opcode termination */
          if(command == 0x8000)
             goto terminate;
 
-         // toggle sprite size
+         /* toggle sprite size */
          if (command == 0x0000)
          {
             sprite_size = !sprite_size;
             continue;
          }
 
-         // new sprite information
+         /* new sprite information */
          command >>= 8;
          if (command != 0x20 && command != 0x40 && command != 0x60 && command != 0xa0 && command != 0xc0 && command != 0xe0)
             break;
@@ -1130,77 +1115,76 @@ resume6:
          DSP4.in_index = 2;
          DSP4_WAIT(7);
 
-         /////////////////////////////////////
-         // process tile data
+         /* process tile data */
 
 resume7:
-         // sprite deltas
+         /* sprite deltas */
          sp_dy = DSP4_READ_WORD(2);
          sp_dx = DSP4_READ_WORD(4);
 
-         // update coordinates
+         /* update coordinates */
          sp_y = sprite_y + sp_dy;
          sp_x = sprite_x + sp_dx;
 
-         // reject points outside the clipping window
+         /* reject points outside the clipping window */
          clip = false;
          if(sp_x < viewport_left || sp_x > viewport_right)
             clip = true;
          if(sp_y < viewport_top || sp_y > viewport_bottom)
             clip = true;
 
-         // track depth sorting
+         /* track depth sorting */
          if(far_plane <= multi_farplane[multi_index1] && sp_y >= project_y2)
             clip = true;
 
-         // don't draw offscreen coordinates
+         /* don't draw offscreen coordinates */
          DSP4.out_count = 0;
          if (!clip)
          {
             int16_t out_index = 0;
             int16_t offset = DSP4_READ_WORD(0);
 
-            // update sprite nametable/attribute information
+            /* update sprite nametable/attribute information */
             sp_oam = sprite_offset + offset;
             sp_msb = (sp_x < 0 || sp_x > 255);
 
-            // emit transparency information
+            /* emit transparency information */
             if((sprite_offset & 0x08) && ((sprite_type == 1 && sp_y >= 0xcc) || (sprite_type == 2 && sp_y >= 0xbb)))
             {
                DSP4.out_count = 6;
 
-               // one block of OAM data
+               /* one block of OAM data */
                DSP4_WRITE_WORD(0, 1);
 
-               // OAM: x,y,tile,no attr
+               /* OAM: x,y,tile,no attr */
                DSP4.output[2] = sp_x & 0xFF;
                DSP4.output[3] = (sp_y + 6) & 0xFF;
                DSP4_WRITE_WORD(4, 0xEE);
                out_index = 6;
 
-               // OAM: size,msb data
+               /* OAM: size,msb data */
                DSP4_Op06(sprite_size, (int8_t) sp_msb);
             }
 
-            // normal data
+            /* normal data */
             DSP4.out_count += 8;
 
-            // one block of OAM data
+            /* one block of OAM data */
             DSP4_WRITE_WORD(out_index + 0, 1);
 
-            // OAM: x,y,tile,attr
+            /* OAM: x,y,tile,attr */
             DSP4.output[out_index + 2] = sp_x & 0xFF;
             DSP4.output[out_index + 3] = sp_y & 0xFF;
             DSP4_WRITE_WORD(out_index + 4, sp_oam);
 
-            // no following OAM data
+            /* no following OAM data */
             DSP4_WRITE_WORD(out_index + 6, 0);
 
-            // OAM: size,msb data
+            /* OAM: size,msb data */
             DSP4_Op06(sprite_size, (int8_t) sp_msb);
          }
 
-         // no sprite information
+         /* no sprite information */
          if (DSP4.out_count == 0)
          {
             DSP4.out_count = 2;
@@ -1208,15 +1192,14 @@ resume7:
          }
       } while (1);
 
-      /////////////////////////////////////
-      // special cases: plane == 0x0000
+      /* special cases: plane == 0x0000 */
 
-      // special vehicle case
+      /* special vehicle case */
       if (command == 0x90)
       {
          sprite_type = 1;
 
-         // shift bytes
+         /* shift bytes */
          DSP4.parameters[2] = DSP4.parameters[0];
          DSP4.parameters[3] = DSP4.parameters[1];
          DSP4.parameters[0] = 0;
@@ -1224,7 +1207,7 @@ resume7:
 
          goto sprite_found;
       }
-      else if (command != 0x00 && command != 0xff) // special terrain case
+      else if (command != 0x00 && command != 0xff) /* special terrain case */
       {
          sprite_type = 2;
 
diff --git a/source/getset.h b/source/getset.h
index 1435348..a5fd6f3 100644
--- a/source/getset.h
+++ b/source/getset.h
@@ -11,9 +11,11 @@
 #include "obc1.h"
 #include "seta.h"
 
+#include <retro_inline.h>
+
 extern uint8_t OpenBus;
 
-inline uint8_t S9xGetByte(uint32_t Address)
+INLINE uint8_t S9xGetByte(uint32_t Address)
 {
    int32_t block;
    uint8_t* GetAddress = Memory.Map [block = (Address >> MEMMAP_SHIFT) & MEMMAP_MASK];
@@ -65,15 +67,17 @@ inline uint8_t S9xGetByte(uint32_t Address)
    }
 }
 
-inline uint16_t S9xGetWord(uint32_t Address)
+INLINE uint16_t S9xGetWord(uint32_t Address)
 {
+   int32_t block;
+   uint8_t* GetAddress;
    if ((Address & 0x0fff) == 0x0fff)
    {
       OpenBus = S9xGetByte(Address);
       return OpenBus | (S9xGetByte(Address + 1) << 8);
    }
-   int32_t block;
-   uint8_t* GetAddress = Memory.Map [block = (Address >> MEMMAP_SHIFT) & MEMMAP_MASK];
+
+   GetAddress = Memory.Map [block = (Address >> MEMMAP_SHIFT) & MEMMAP_MASK];
 
    if ((intptr_t) GetAddress != MAP_CPU || !CPU.InDMA)
       CPU.Cycles += (Memory.MemorySpeed [block] << 1);
@@ -134,11 +138,11 @@ inline uint16_t S9xGetWord(uint32_t Address)
    }
 }
 
-inline void S9xSetByte(uint8_t Byte, uint32_t Address)
+INLINE void S9xSetByte(uint8_t Byte, uint32_t Address)
 {
-   CPU.WaitAddress = NULL;
    int32_t block;
    uint8_t* SetAddress = Memory.WriteMap [block = ((Address >> MEMMAP_SHIFT) & MEMMAP_MASK)];
+   CPU.WaitAddress = NULL;
 
    if ((intptr_t) SetAddress != MAP_CPU || !CPU.InDMA)
       CPU.Cycles += Memory.MemorySpeed [block];
@@ -205,8 +209,11 @@ inline void S9xSetByte(uint8_t Byte, uint32_t Address)
    }
 }
 
-inline void S9xSetWord(uint16_t Word, uint32_t Address)
+INLINE void S9xSetWord(uint16_t Word, uint32_t Address)
 {
+   int32_t block;
+   uint8_t* SetAddress;
+
    if ((Address & 0x0FFF) == 0x0FFF)
    {
       S9xSetByte(Word & 0x00FF, Address);
@@ -215,8 +222,7 @@ inline void S9xSetWord(uint16_t Word, uint32_t Address)
    }
 
    CPU.WaitAddress = NULL;
-   int32_t block;
-   uint8_t* SetAddress = Memory.WriteMap [block = ((Address >> MEMMAP_SHIFT) & MEMMAP_MASK)];
+   SetAddress = Memory.WriteMap [block = ((Address >> MEMMAP_SHIFT) & MEMMAP_MASK)];
 
    if ((intptr_t) SetAddress != MAP_CPU || !CPU.InDMA)
       CPU.Cycles += Memory.MemorySpeed [block] << 1;
@@ -307,7 +313,7 @@ inline void S9xSetWord(uint16_t Word, uint32_t Address)
    }
 }
 
-inline uint8_t* GetBasePointer(uint32_t Address)
+INLINE uint8_t* GetBasePointer(uint32_t Address)
 {
    uint8_t* GetAddress = Memory.Map [(Address >> MEMMAP_SHIFT) & MEMMAP_MASK];
    if (GetAddress >= (uint8_t*) MAP_LAST)
@@ -341,7 +347,7 @@ inline uint8_t* GetBasePointer(uint32_t Address)
    }
 }
 
-inline uint8_t* S9xGetMemPointer(uint32_t Address)
+INLINE uint8_t* S9xGetMemPointer(uint32_t Address)
 {
    uint8_t* GetAddress = Memory.Map [(Address >> MEMMAP_SHIFT) & MEMMAP_MASK];
    if (GetAddress >= (uint8_t*) MAP_LAST)
@@ -378,7 +384,7 @@ inline uint8_t* S9xGetMemPointer(uint32_t Address)
    }
 }
 
-inline void S9xSetPCBase(uint32_t Address)
+INLINE void S9xSetPCBase(uint32_t Address)
 {
    int32_t block;
    uint8_t* GetAddress = Memory.Map [block = (Address >> MEMMAP_SHIFT) & MEMMAP_MASK];
diff --git a/source/gfx.c b/source/gfx.c
index c47661a..f3b59a5 100644
--- a/source/gfx.c
+++ b/source/gfx.c
@@ -1158,8 +1158,10 @@ static void DrawBackgroundOffset(uint32_t BGMode, uint32_t bg, uint8_t Z1, uint8
    int32_t OffsetMask;
    int32_t OffsetShift;
    int32_t VOffsetOffset = BGMode == 4 ? 0 : 32;
-   uint8_t depths [2] = {Z1, Z2};
+   uint8_t depths [2];
 
+   depths[0] = Z1;
+   depths[1] = Z2;
    BG.StartPalette = 0;
    BPS0 = (uint16_t*) &Memory.VRAM[PPU.BG[2].SCBase << 1];
 
diff --git a/source/sa1.c b/source/sa1.c
index e190b5c..b17b562 100644
--- a/source/sa1.c
+++ b/source/sa1.c
@@ -455,7 +455,7 @@ void S9xSetSA1(uint8_t byte, uint32_t address)
    case 0x2237:
       Memory.FillRAM [address] = byte;
       if ((Memory.FillRAM [0x2230] & 0xa4) == 0x84)
-         S9xSA1DMA(); // Normal DMA to BW-RAM
+         S9xSA1DMA(); /* Normal DMA to BW-RAM */
       break;
    case 0x223f:
       SA1.VirtualBitmapFormat = (byte & 0x80) ? 2 : 4;
@@ -508,8 +508,8 @@ void S9xSetSA1(uint8_t byte, uint32_t address)
          break;
       default: /* cumulative sum */
          SA1.sum += (int16_t) SA1.op1 * (int16_t) SA1.op2;
-         SA1.overflow = (SA1.sum >= (1ULL << 40));
-         SA1.sum &= (1ULL << 40) - 1;
+         SA1.overflow = (SA1.sum >= (((uint64_t) 1) << 40));
+         SA1.sum &= (((uint64_t) 1) << 40) - 1;
          SA1.op2 = 0;
          break;
       }
diff --git a/source/srtc.c b/source/srtc.c
index e86b6b2..0bfa7d9 100644
--- a/source/srtc.c
+++ b/source/srtc.c
@@ -251,6 +251,7 @@ void S9xUpdateSrtcTime(void)
 /**********************************************************************************************/
 void S9xSetSRTC(uint8_t data, uint16_t Address)
 {
+   (void) Address;
    data &= 0x0F; /* Data is only 4-bits, mask out unused bits. */
 
    if (data >= 0xD) /* It's an RTC command */
@@ -319,6 +320,7 @@ void S9xSetSRTC(uint8_t data, uint16_t Address)
 /**********************************************************************************************/
 uint8_t S9xGetSRTC(uint16_t Address)
 {
+   (void) Address;
    if (rtc.mode == MODE_READ)
    {
       if (rtc.index < 0)
diff --git a/source/tile.c b/source/tile.c
index 3c6b43f..aa0cfaf 100644
--- a/source/tile.c
+++ b/source/tile.c
@@ -257,61 +257,77 @@ static void WRITE_4PIXELS16_FLIPPEDx2x2(int32_t Offset, uint8_t* Pixels, uint16_
 void DrawTile16(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
 {
    uint8_t* bp;
-   TILE_PREAMBLE();
+   TILE_PREAMBLE_VARS();
+   TILE_PREAMBLE_CODE();
    RENDER_TILE(WRITE_4PIXELS16, WRITE_4PIXELS16_FLIPPED, 4);
 }
 
 void DrawClippedTile16(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width, uint32_t StartLine, uint32_t LineCount)
 {
    uint8_t* bp;
-   TILE_PREAMBLE();
-   TILE_CLIP_PREAMBLE();
-   RENDER_CLIPPED_TILE(WRITE_4PIXELS16, WRITE_4PIXELS16_FLIPPED, 4);
+   TILE_PREAMBLE_VARS();
+   TILE_CLIP_PREAMBLE_VARS();
+   RENDER_CLIPPED_TILE_VARS();
+   TILE_PREAMBLE_CODE();
+   TILE_CLIP_PREAMBLE_CODE();
+   RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16, WRITE_4PIXELS16_FLIPPED, 4);
 }
 
 void DrawTile16HalfWidth(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
 {
    uint8_t* bp;
-   TILE_PREAMBLE();
+   TILE_PREAMBLE_VARS();
+   TILE_PREAMBLE_CODE();
    RENDER_TILE(WRITE_4PIXELS16_HALFWIDTH, WRITE_4PIXELS16_FLIPPED_HALFWIDTH, 2);
 }
 
 void DrawClippedTile16HalfWidth(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width, uint32_t StartLine, uint32_t LineCount)
 {
    uint8_t* bp;
-   TILE_PREAMBLE();
-   TILE_CLIP_PREAMBLE();
-   RENDER_CLIPPED_TILE(WRITE_4PIXELS16_HALFWIDTH, WRITE_4PIXELS16_FLIPPED_HALFWIDTH, 2);
+   TILE_PREAMBLE_VARS();
+   TILE_CLIP_PREAMBLE_VARS();
+   RENDER_CLIPPED_TILE_VARS();
+   TILE_PREAMBLE_CODE();
+   TILE_CLIP_PREAMBLE_CODE();
+   RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16_HALFWIDTH, WRITE_4PIXELS16_FLIPPED_HALFWIDTH, 2);
 }
 
 void DrawTile16x2(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
 {
    uint8_t* bp;
-   TILE_PREAMBLE();
+   TILE_PREAMBLE_VARS();
+   TILE_PREAMBLE_CODE();
    RENDER_TILE(WRITE_4PIXELS16x2, WRITE_4PIXELS16_FLIPPEDx2, 8);
 }
 
 void DrawClippedTile16x2(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width, uint32_t StartLine, uint32_t LineCount)
 {
    uint8_t* bp;
-   TILE_PREAMBLE();
-   TILE_CLIP_PREAMBLE();
-   RENDER_CLIPPED_TILE(WRITE_4PIXELS16x2, WRITE_4PIXELS16_FLIPPEDx2, 8);
+   TILE_PREAMBLE_VARS();
+   TILE_CLIP_PREAMBLE_VARS();
+   RENDER_CLIPPED_TILE_VARS();
+   TILE_PREAMBLE_CODE();
+   TILE_CLIP_PREAMBLE_CODE();
+   RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16x2, WRITE_4PIXELS16_FLIPPEDx2, 8);
 }
 
 void DrawTile16x2x2(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
 {
    uint8_t* bp;
-   TILE_PREAMBLE();
+   TILE_PREAMBLE_VARS();
+   TILE_PREAMBLE_CODE();
    RENDER_TILE(WRITE_4PIXELS16x2x2, WRITE_4PIXELS16_FLIPPEDx2x2, 8);
 }
 
 void DrawClippedTile16x2x2(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width, uint32_t StartLine, uint32_t LineCount)
 {
    uint8_t* bp;
-   TILE_PREAMBLE();
-   TILE_CLIP_PREAMBLE();
-   RENDER_CLIPPED_TILE(WRITE_4PIXELS16x2x2, WRITE_4PIXELS16_FLIPPEDx2x2, 8);
+   TILE_PREAMBLE_VARS();
+   TILE_CLIP_PREAMBLE_VARS();
+   RENDER_CLIPPED_TILE_VARS();
+   TILE_PREAMBLE_CODE();
+   TILE_CLIP_PREAMBLE_CODE();
+   RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16x2x2, WRITE_4PIXELS16_FLIPPEDx2x2, 8);
 }
 
 void DrawLargePixel16(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Pixels, uint32_t StartLine, uint32_t LineCount)
@@ -319,7 +335,8 @@ void DrawLargePixel16(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32
    uint16_t pixel;
    uint16_t *sp;
    uint8_t *Depth;
-   TILE_PREAMBLE();
+   TILE_PREAMBLE_VARS();
+   TILE_PREAMBLE_CODE();
    sp = (uint16_t*) GFX.S + Offset;
    Depth = GFX.DB + Offset;
    RENDER_TILE_LARGE(ScreenColors [pixel], PLOT_PIXEL);
@@ -330,7 +347,8 @@ void DrawLargePixel16HalfWidth(uint32_t Tile, int32_t Offset, uint32_t StartPixe
    uint16_t pixel;
    uint16_t *sp;
    uint8_t *Depth;
-   TILE_PREAMBLE();
+   TILE_PREAMBLE_VARS();
+   TILE_PREAMBLE_CODE();
    sp = (uint16_t*) GFX.S + Offset;
    Depth = GFX.DB + Offset;
    RENDER_TILE_LARGE_HALFWIDTH(ScreenColors [pixel], PLOT_PIXEL);
@@ -563,12 +581,13 @@ static void WRITE_4PIXELS16_FLIPPED_SUB1_2(int32_t Offset, uint8_t* Pixels, uint
 
 void DrawTile16Add(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
 {
-   TILE_PREAMBLE();
    uint8_t* bp;
-   uint8_t  Pixel;
+   uint8_t Pixel;
    uint16_t* Screen = (uint16_t*) GFX.S + Offset;
-   uint8_t*  Depth = GFX.ZBuffer + Offset;
-   uint8_t*  SubDepth = GFX.SubZBuffer + Offset;
+   uint8_t* Depth = GFX.ZBuffer + Offset;
+   uint8_t* SubDepth = GFX.SubZBuffer + Offset;
+   TILE_PREAMBLE_VARS();
+   TILE_PREAMBLE_CODE();
 
    switch (Tile & (V_FLIP | H_FLIP))
    {
@@ -683,55 +702,70 @@ void DrawTile16Add(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t L
 
 void DrawClippedTile16Add(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width, uint32_t StartLine, uint32_t LineCount)
 {
-   TILE_PREAMBLE();
    uint8_t* bp;
-   TILE_CLIP_PREAMBLE();
-   RENDER_CLIPPED_TILE(WRITE_4PIXELS16_ADD, WRITE_4PIXELS16_FLIPPED_ADD, 4);
+   TILE_PREAMBLE_VARS();
+   TILE_CLIP_PREAMBLE_VARS();
+   RENDER_CLIPPED_TILE_VARS();
+   TILE_PREAMBLE_CODE();
+   TILE_CLIP_PREAMBLE_CODE();
+   RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16_ADD, WRITE_4PIXELS16_FLIPPED_ADD, 4);
 }
 
 void DrawTile16Add1_2(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
 {
-   TILE_PREAMBLE();
    uint8_t* bp;
+   TILE_PREAMBLE_VARS();
+   TILE_PREAMBLE_CODE();
    RENDER_TILE(WRITE_4PIXELS16_ADD1_2, WRITE_4PIXELS16_FLIPPED_ADD1_2, 4);
 }
 
 void DrawClippedTile16Add1_2(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width, uint32_t StartLine, uint32_t LineCount)
 {
-   TILE_PREAMBLE();
    uint8_t* bp;
-   TILE_CLIP_PREAMBLE();
-   RENDER_CLIPPED_TILE(WRITE_4PIXELS16_ADD1_2, WRITE_4PIXELS16_FLIPPED_ADD1_2, 4);
+   TILE_PREAMBLE_VARS();
+   TILE_CLIP_PREAMBLE_VARS();
+   RENDER_CLIPPED_TILE_VARS();
+   TILE_PREAMBLE_CODE();
+   TILE_CLIP_PREAMBLE_CODE();
+   RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16_ADD1_2, WRITE_4PIXELS16_FLIPPED_ADD1_2, 4);
 }
 
 void DrawTile16Sub(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
 {
-   TILE_PREAMBLE();
    uint8_t* bp;
+   TILE_PREAMBLE_VARS();
+   TILE_PREAMBLE_CODE();
    RENDER_TILE(WRITE_4PIXELS16_SUB, WRITE_4PIXELS16_FLIPPED_SUB, 4);
 }
 
 void DrawClippedTile16Sub(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width,  uint32_t StartLine, uint32_t LineCount)
 {
-   TILE_PREAMBLE();
    uint8_t* bp;
-   TILE_CLIP_PREAMBLE();
-   RENDER_CLIPPED_TILE(WRITE_4PIXELS16_SUB, WRITE_4PIXELS16_FLIPPED_SUB, 4);
+   TILE_PREAMBLE_VARS();
+   TILE_CLIP_PREAMBLE_VARS();
+   RENDER_CLIPPED_TILE_VARS();
+   TILE_PREAMBLE_CODE();
+   TILE_CLIP_PREAMBLE_CODE();
+   RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16_SUB, WRITE_4PIXELS16_FLIPPED_SUB, 4);
 }
 
 void DrawTile16Sub1_2(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
 {
-   TILE_PREAMBLE();
    uint8_t* bp;
+   TILE_PREAMBLE_VARS();
+   TILE_PREAMBLE_CODE();
    RENDER_TILE(WRITE_4PIXELS16_SUB1_2, WRITE_4PIXELS16_FLIPPED_SUB1_2, 4);
 }
 
 void DrawClippedTile16Sub1_2(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width, uint32_t StartLine, uint32_t LineCount)
 {
-   TILE_PREAMBLE();
    uint8_t* bp;
-   TILE_CLIP_PREAMBLE();
-   RENDER_CLIPPED_TILE(WRITE_4PIXELS16_SUB1_2, WRITE_4PIXELS16_FLIPPED_SUB1_2, 4);
+   TILE_PREAMBLE_VARS();
+   TILE_CLIP_PREAMBLE_VARS();
+   RENDER_CLIPPED_TILE_VARS();
+   TILE_PREAMBLE_CODE();
+   TILE_CLIP_PREAMBLE_CODE();
+   RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16_SUB1_2, WRITE_4PIXELS16_FLIPPED_SUB1_2, 4);
 }
 
 static void WRITE_4PIXELS16_ADDF1_2(int32_t Offset, uint8_t* Pixels, uint16_t* ScreenColors)
@@ -812,40 +846,49 @@ static void WRITE_4PIXELS16_FLIPPED_SUBF1_2(int32_t Offset, uint8_t* Pixels, uin
 
 void DrawTile16FixedAdd1_2(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
 {
-   TILE_PREAMBLE();
    uint8_t* bp;
+   TILE_PREAMBLE_VARS();
+   TILE_PREAMBLE_CODE();
    RENDER_TILE(WRITE_4PIXELS16_ADDF1_2, WRITE_4PIXELS16_FLIPPED_ADDF1_2, 4);
 }
 
 void DrawClippedTile16FixedAdd1_2(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width,  uint32_t StartLine, uint32_t LineCount)
 {
-   TILE_PREAMBLE();
    uint8_t* bp;
-   TILE_CLIP_PREAMBLE();
-   RENDER_CLIPPED_TILE(WRITE_4PIXELS16_ADDF1_2, WRITE_4PIXELS16_FLIPPED_ADDF1_2, 4);
+   TILE_PREAMBLE_VARS();
+   TILE_CLIP_PREAMBLE_VARS();
+   RENDER_CLIPPED_TILE_VARS();
+   TILE_PREAMBLE_CODE();
+   TILE_CLIP_PREAMBLE_CODE();
+   RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16_ADDF1_2, WRITE_4PIXELS16_FLIPPED_ADDF1_2, 4);
 }
 
 void DrawTile16FixedSub1_2(uint32_t Tile, int32_t Offset, uint32_t StartLine, uint32_t LineCount)
 {
-   TILE_PREAMBLE();
    uint8_t* bp;
+   TILE_PREAMBLE_VARS();
+   TILE_PREAMBLE_CODE();
    RENDER_TILE(WRITE_4PIXELS16_SUBF1_2, WRITE_4PIXELS16_FLIPPED_SUBF1_2, 4);
 }
 
 void DrawClippedTile16FixedSub1_2(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Width, uint32_t StartLine, uint32_t LineCount)
 {
-   TILE_PREAMBLE();
    uint8_t* bp;
-   TILE_CLIP_PREAMBLE();
-   RENDER_CLIPPED_TILE(WRITE_4PIXELS16_SUBF1_2, WRITE_4PIXELS16_FLIPPED_SUBF1_2, 4);
+   TILE_PREAMBLE_VARS();
+   TILE_CLIP_PREAMBLE_VARS();
+   RENDER_CLIPPED_TILE_VARS();
+   TILE_PREAMBLE_CODE();
+   TILE_CLIP_PREAMBLE_CODE();
+   RENDER_CLIPPED_TILE_CODE(WRITE_4PIXELS16_SUBF1_2, WRITE_4PIXELS16_FLIPPED_SUBF1_2, 4);
 }
 
 void DrawLargePixel16Add(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Pixels, uint32_t StartLine, uint32_t LineCount)
 {
-   TILE_PREAMBLE();
    uint16_t* sp = (uint16_t*) GFX.S + Offset;
    uint8_t*  Depth = GFX.ZBuffer + Offset;
    uint16_t pixel;
+   TILE_PREAMBLE_VARS();
+   TILE_PREAMBLE_CODE();
 
 #define LARGE_ADD_PIXEL(s, p) \
 (Depth [z + GFX.DepthDelta] ? (Depth [z + GFX.DepthDelta] != 1 ? \
@@ -857,10 +900,11 @@ void DrawLargePixel16Add(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uin
 
 void DrawLargePixel16Add1_2(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Pixels, uint32_t StartLine, uint32_t LineCount)
 {
-   TILE_PREAMBLE();
    uint16_t* sp = (uint16_t*) GFX.S + Offset;
    uint8_t*  Depth = GFX.ZBuffer + Offset;
    uint16_t pixel;
+   TILE_PREAMBLE_VARS();
+   TILE_PREAMBLE_CODE();
 
 #define LARGE_ADD_PIXEL1_2(s, p) \
 ((uint16_t) (Depth [z + GFX.DepthDelta] ? (Depth [z + GFX.DepthDelta] != 1 ? \
@@ -872,10 +916,11 @@ void DrawLargePixel16Add1_2(uint32_t Tile, int32_t Offset, uint32_t StartPixel,
 
 void DrawLargePixel16Sub(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Pixels, uint32_t StartLine, uint32_t LineCount)
 {
-   TILE_PREAMBLE();
    uint16_t* sp = (uint16_t*) GFX.S + Offset;
    uint8_t*  Depth = GFX.ZBuffer + Offset;
    uint16_t pixel;
+   TILE_PREAMBLE_VARS();
+   TILE_PREAMBLE_CODE();
 
 #define LARGE_SUB_PIXEL(s, p) \
 (Depth [z + GFX.DepthDelta] ? (Depth [z + GFX.DepthDelta] != 1 ? \
@@ -887,10 +932,11 @@ void DrawLargePixel16Sub(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uin
 
 void DrawLargePixel16Sub1_2(uint32_t Tile, int32_t Offset, uint32_t StartPixel, uint32_t Pixels, uint32_t StartLine, uint32_t LineCount)
 {
-   TILE_PREAMBLE();
    uint16_t* sp = (uint16_t*) GFX.S + Offset;
    uint8_t*  Depth = GFX.ZBuffer + Offset;
    uint16_t pixel;
+   TILE_PREAMBLE_VARS();
+   TILE_PREAMBLE_CODE();
 
 #define LARGE_SUB_PIXEL1_2(s, p) \
 (Depth [z + GFX.DepthDelta] ? (Depth [z + GFX.DepthDelta] != 1 ? \
diff --git a/source/tile.h b/source/tile.h
index ca9f854..1dbc1fa 100644
--- a/source/tile.h
+++ b/source/tile.h
@@ -3,15 +3,18 @@
 #ifndef _TILE_H_
 #define _TILE_H_
 
-#define TILE_PREAMBLE() \
+#define TILE_PREAMBLE_VARS() \
     uint32_t l; \
     uint16_t *ScreenColors; \
     uint8_t *pCache; \
-    uint32_t TileAddr = BG.TileAddress + ((Tile & 0x3ff) << BG.TileShift); \
+    uint32_t TileNumber; \
+    uint32_t TileAddr
+
+#define TILE_PREAMBLE_CODE() \
+    TileAddr = BG.TileAddress + ((Tile & 0x3ff) << BG.TileShift); \
     if ((Tile & 0x1ff) >= 256) \
        TileAddr += BG.NameSelect; \
     TileAddr &= 0xffff; \
-    uint32_t TileNumber; \
     pCache = &BG.Buffer[(TileNumber = (TileAddr >> BG.TileShift)) << 6]; \
     if (!BG.Buffered [TileNumber]) \
        BG.Buffered[TileNumber] = ConvertTile (pCache, TileAddr); \
@@ -73,12 +76,14 @@
        break; \
     }
 
-#define TILE_CLIP_PREAMBLE() \
+#define TILE_CLIP_PREAMBLE_VARS() \
     uint32_t d1; \
-    uint32_t d2; \
+    uint32_t d2
+
+#define TILE_CLIP_PREAMBLE_CODE() \
     if (StartPixel < 4) \
     { \
-    d1 = HeadMask [StartPixel]; \
+       d1 = HeadMask [StartPixel]; \
        if (StartPixel + Width < 4) \
           d1 &= TailMask [StartPixel + Width]; \
     } \
@@ -95,8 +100,10 @@
     else \
        d2 = 0
 
-#define RENDER_CLIPPED_TILE(NORMAL, FLIPPED, N) \
-    uint32_t dd; \
+#define RENDER_CLIPPED_TILE_VARS() \
+    uint32_t dd
+
+#define RENDER_CLIPPED_TILE_CODE(NORMAL, FLIPPED, N) \
     switch (Tile & (V_FLIP | H_FLIP)) \
     { \
     case 0: \