Replace restrict with RESTRICT

39 files changed, 193 insertions, 193 deletions

diff --git a/Alc/ALu.c b/Alc/ALu.c
index 03abb116..efa78110 100644
--- a/Alc/ALu.c
+++ b/Alc/ALu.c
@@ -80,7 +80,7 @@ extern inline size_t clampz(size_t val, size_t min, size_t max);
 extern inline ALfloat lerp(ALfloat val1, ALfloat val2, ALfloat mu);
 extern inline ALfloat cubic(ALfloat val1, ALfloat val2, ALfloat val3, ALfloat val4, ALfloat mu);
 
-extern inline void aluVectorSet(aluVector *restrict vector, ALfloat x, ALfloat y, ALfloat z, ALfloat w);
+extern inline void aluVectorSet(aluVector *RESTRICT vector, ALfloat x, ALfloat y, ALfloat z, ALfloat w);
 
 extern inline void aluMatrixfSetRow(aluMatrixf *matrix, ALuint row,
                                     ALfloat m0, ALfloat m1, ALfloat m2, ALfloat m3);
@@ -1563,12 +1563,12 @@ static void ProcessParamUpdates(ALCcontext *ctx, const struct ALeffectslotArray
 }
 
 
-static void ApplyStablizer(FrontStablizer *Stablizer, ALfloat (*restrict Buffer)[BUFFERSIZE],
+static void ApplyStablizer(FrontStablizer *Stablizer, ALfloat (*RESTRICT Buffer)[BUFFERSIZE],
                            int lidx, int ridx, int cidx, ALsizei SamplesToDo,
                            ALsizei NumChannels)
 {
-    ALfloat (*restrict lsplit)[BUFFERSIZE] = ASSUME_ALIGNED(Stablizer->LSplit, 16);
-    ALfloat (*restrict rsplit)[BUFFERSIZE] = ASSUME_ALIGNED(Stablizer->RSplit, 16);
+    ALfloat (*RESTRICT lsplit)[BUFFERSIZE] = ASSUME_ALIGNED(Stablizer->LSplit, 16);
+    ALfloat (*RESTRICT rsplit)[BUFFERSIZE] = ASSUME_ALIGNED(Stablizer->RSplit, 16);
     ALsizei i;
 
     /* Apply an all-pass to all channels, except the front-left and front-
@@ -1611,18 +1611,18 @@ static void ApplyStablizer(FrontStablizer *Stablizer, ALfloat (*restrict Buffer)
     }
 }
 
-static void ApplyDistanceComp(ALfloat (*restrict Samples)[BUFFERSIZE], DistanceComp *distcomp,
-                              ALfloat *restrict Values, ALsizei SamplesToDo, ALsizei numchans)
+static void ApplyDistanceComp(ALfloat (*RESTRICT Samples)[BUFFERSIZE], DistanceComp *distcomp,
+                              ALfloat *RESTRICT Values, ALsizei SamplesToDo, ALsizei numchans)
 {
     ALsizei i, c;
 
     Values = ASSUME_ALIGNED(Values, 16);
     for(c = 0;c < numchans;c++)
     {
-        ALfloat *restrict inout = ASSUME_ALIGNED(Samples[c], 16);
+        ALfloat *RESTRICT inout = ASSUME_ALIGNED(Samples[c], 16);
         const ALfloat gain = distcomp[c].Gain;
         const ALsizei base = distcomp[c].Length;
-        ALfloat *restrict distbuf = ASSUME_ALIGNED(distcomp[c].Buffer, 16);
+        ALfloat *RESTRICT distbuf = ASSUME_ALIGNED(distcomp[c].Buffer, 16);
 
         if(base == 0)
         {
@@ -1654,7 +1654,7 @@ static void ApplyDistanceComp(ALfloat (*restrict Samples)[BUFFERSIZE], DistanceC
     }
 }
 
-static void ApplyDither(ALfloat (*restrict Samples)[BUFFERSIZE], ALuint *dither_seed,
+static void ApplyDither(ALfloat (*RESTRICT Samples)[BUFFERSIZE], ALuint *dither_seed,
                         const ALfloat quant_scale, const ALsizei SamplesToDo,
                         const ALsizei numchans)
 {
@@ -1671,7 +1671,7 @@ static void ApplyDither(ALfloat (*restrict Samples)[BUFFERSIZE], ALuint *dither_
      */
     for(c = 0;c < numchans;c++)
     {
-        ALfloat *restrict samples = Samples[c];
+        ALfloat *RESTRICT samples = Samples[c];
         for(i = 0;i < SamplesToDo;i++)
         {
             ALfloat val = samples[i] * quant_scale;
@@ -1712,7 +1712,7 @@ DECL_TEMPLATE(ALuint, Conv_ALint, 2147483648u)
 #undef DECL_TEMPLATE
 
 #define DECL_TEMPLATE(T, A)                                                   \
-static void Write##A(const ALfloat (*restrict InBuffer)[BUFFERSIZE],          \
+static void Write##A(const ALfloat (*RESTRICT InBuffer)[BUFFERSIZE],          \
                      ALvoid *OutBuffer, ALsizei Offset, ALsizei SamplesToDo,  \
                      ALsizei numchans)                                        \
 {                                                                             \
@@ -1723,8 +1723,8 @@ static void Write##A(const ALfloat (*restrict InBuffer)[BUFFERSIZE],          \
                                                                               \
     for(j = 0;j < numchans;j++)                                               \
     {                                                                         \
-        const ALfloat *restrict in = ASSUME_ALIGNED(InBuffer[j], 16);         \
-        T *restrict out = (T*)OutBuffer + Offset*numchans + j;                \
+        const ALfloat *RESTRICT in = ASSUME_ALIGNED(InBuffer[j], 16);         \
+        T *RESTRICT out = (T*)OutBuffer + Offset*numchans + j;                \
                                                                               \
         for(i = 0;i < SamplesToDo;i++)                                        \
             out[i*numchans] = Conv_##T(in[i]);                                \
diff --git a/Alc/backends/jack.c b/Alc/backends/jack.c
index fdbe93f2..899d5a55 100644
--- a/Alc/backends/jack.c
+++ b/Alc/backends/jack.c
@@ -266,7 +266,7 @@ static int ALCjackPlayback_process(jack_nframes_t numframes, void *arg)
     todo = minu(numframes, data[0].len);
     for(c = 0;c < numchans;c++)
     {
-        const ALfloat *restrict in = ((ALfloat*)data[0].buf) + c;
+        const ALfloat *RESTRICT in = ((ALfloat*)data[0].buf) + c;
         for(i = 0;(jack_nframes_t)i < todo;i++)
             out[c][i] = in[i*numchans];
         out[c] += todo;
@@ -278,7 +278,7 @@ static int ALCjackPlayback_process(jack_nframes_t numframes, void *arg)
     {
         for(c = 0;c < numchans;c++)
         {
-            const ALfloat *restrict in = ((ALfloat*)data[1].buf) + c;
+            const ALfloat *RESTRICT in = ((ALfloat*)data[1].buf) + c;
             for(i = 0;(jack_nframes_t)i < todo;i++)
                 out[c][i] = in[i*numchans];
             out[c] += todo;
diff --git a/Alc/bformatdec.c b/Alc/bformatdec.c
index 5233d06f..91eb8ca8 100644
--- a/Alc/bformatdec.c
+++ b/Alc/bformatdec.c
@@ -304,7 +304,7 @@ void bformatdec_reset(BFormatDec *dec, const AmbDecConf *conf, ALsizei chancount
 }
 
 
-void bformatdec_process(struct BFormatDec *dec, ALfloat (*restrict OutBuffer)[BUFFERSIZE], ALsizei OutChannels, const ALfloat (*restrict InSamples)[BUFFERSIZE], ALsizei SamplesToDo)
+void bformatdec_process(struct BFormatDec *dec, ALfloat (*RESTRICT OutBuffer)[BUFFERSIZE], ALsizei OutChannels, const ALfloat (*RESTRICT InSamples)[BUFFERSIZE], ALsizei SamplesToDo)
 {
     ALsizei chan, i;
 
@@ -350,7 +350,7 @@ void bformatdec_process(struct BFormatDec *dec, ALfloat (*restrict OutBuffer)[BU
 }
 
 
-void bformatdec_upSample(struct BFormatDec *dec, ALfloat (*restrict OutBuffer)[BUFFERSIZE], const ALfloat (*restrict InSamples)[BUFFERSIZE], ALsizei InChannels, ALsizei SamplesToDo)
+void bformatdec_upSample(struct BFormatDec *dec, ALfloat (*RESTRICT OutBuffer)[BUFFERSIZE], const ALfloat (*RESTRICT InSamples)[BUFFERSIZE], ALsizei InChannels, ALsizei SamplesToDo)
 {
     ALsizei i;
 
@@ -473,7 +473,7 @@ void ambiup_reset(struct AmbiUpsampler *ambiup, const ALCdevice *device, ALfloat
     }
 }
 
-void ambiup_process(struct AmbiUpsampler *ambiup, ALfloat (*restrict OutBuffer)[BUFFERSIZE], ALsizei OutChannels, const ALfloat (*restrict InSamples)[BUFFERSIZE], ALsizei SamplesToDo)
+void ambiup_process(struct AmbiUpsampler *ambiup, ALfloat (*RESTRICT OutBuffer)[BUFFERSIZE], ALsizei OutChannels, const ALfloat (*RESTRICT InSamples)[BUFFERSIZE], ALsizei SamplesToDo)
 {
     ALsizei i, j;
 
diff --git a/Alc/bformatdec.h b/Alc/bformatdec.h
index 2d7d1d62..3c081807 100644
--- a/Alc/bformatdec.h
+++ b/Alc/bformatdec.h
@@ -39,10 +39,10 @@ void bformatdec_free(struct BFormatDec **dec);
 void bformatdec_reset(struct BFormatDec *dec, const struct AmbDecConf *conf, ALsizei chancount, ALuint srate, const ALsizei chanmap[MAX_OUTPUT_CHANNELS]);
 
 /* Decodes the ambisonic input to the given output channels. */
-void bformatdec_process(struct BFormatDec *dec, ALfloat (*restrict OutBuffer)[BUFFERSIZE], ALsizei OutChannels, const ALfloat (*restrict InSamples)[BUFFERSIZE], ALsizei SamplesToDo);
+void bformatdec_process(struct BFormatDec *dec, ALfloat (*RESTRICT OutBuffer)[BUFFERSIZE], ALsizei OutChannels, const ALfloat (*RESTRICT InSamples)[BUFFERSIZE], ALsizei SamplesToDo);
 
 /* Up-samples a first-order input to the decoder's configuration. */
-void bformatdec_upSample(struct BFormatDec *dec, ALfloat (*restrict OutBuffer)[BUFFERSIZE], const ALfloat (*restrict InSamples)[BUFFERSIZE], ALsizei InChannels, ALsizei SamplesToDo);
+void bformatdec_upSample(struct BFormatDec *dec, ALfloat (*RESTRICT OutBuffer)[BUFFERSIZE], const ALfloat (*RESTRICT InSamples)[BUFFERSIZE], ALsizei InChannels, ALsizei SamplesToDo);
 
 
 /* Stand-alone first-order upsampler. Kept here because it shares some stuff
@@ -52,6 +52,6 @@ struct AmbiUpsampler *ambiup_alloc();
 void ambiup_free(struct AmbiUpsampler **ambiup);
 void ambiup_reset(struct AmbiUpsampler *ambiup, const ALCdevice *device, ALfloat w_scale, ALfloat xyz_scale);
 
-void ambiup_process(struct AmbiUpsampler *ambiup, ALfloat (*restrict OutBuffer)[BUFFERSIZE], ALsizei OutChannels, const ALfloat (*restrict InSamples)[BUFFERSIZE], ALsizei SamplesToDo);
+void ambiup_process(struct AmbiUpsampler *ambiup, ALfloat (*RESTRICT OutBuffer)[BUFFERSIZE], ALsizei OutChannels, const ALfloat (*RESTRICT InSamples)[BUFFERSIZE], ALsizei SamplesToDo);
 
 #endif /* BFORMATDEC_H */
diff --git a/Alc/bs2b.c b/Alc/bs2b.c
index e235e547..e0ce3249 100644
--- a/Alc/bs2b.c
+++ b/Alc/bs2b.c
@@ -129,7 +129,7 @@ void bs2b_clear(struct bs2b *bs2b)
     memset(&bs2b->last_sample, 0, sizeof(bs2b->last_sample));
 } /* bs2b_clear */
 
-void bs2b_cross_feed(struct bs2b *bs2b, float *restrict Left, float *restrict Right, int SamplesToDo)
+void bs2b_cross_feed(struct bs2b *bs2b, float *RESTRICT Left, float *RESTRICT Right, int SamplesToDo)
 {
     float lsamples[128][2];
     float rsamples[128][2];
diff --git a/Alc/converter.c b/Alc/converter.c
index ef2eb9af..5080f302 100644
--- a/Alc/converter.c
+++ b/Alc/converter.c
@@ -72,7 +72,7 @@ static inline ALfloat Sample_ALfloat(ALfloat val)
 { return val; }
 
 #define DECL_TEMPLATE(T)                                                      \
-static inline void Load_##T(ALfloat *restrict dst, const T *restrict src,     \
+static inline void Load_##T(ALfloat *RESTRICT dst, const T *RESTRICT src,     \
                             ALint srcstep, ALsizei samples)                   \
 {                                                                             \
     ALsizei i;                                                                \
@@ -138,7 +138,7 @@ static inline ALfloat ALfloat_Sample(ALfloat val)
 { return val; }
 
 #define DECL_TEMPLATE(T)                                                      \
-static inline void Store_##T(T *restrict dst, const ALfloat *restrict src,    \
+static inline void Store_##T(T *RESTRICT dst, const ALfloat *RESTRICT src,    \
                              ALint dststep, ALsizei samples)                  \
 {                                                                             \
     ALsizei i;                                                                \
@@ -235,8 +235,8 @@ ALsizei SampleConverterInput(SampleConverter *converter, const ALvoid **src, ALs
     START_MIXER_MODE();
     while(pos < dstframes && *srcframes > 0)
     {
-        ALfloat *restrict SrcData = ASSUME_ALIGNED(converter->mSrcSamples, 16);
-        ALfloat *restrict DstData = ASSUME_ALIGNED(converter->mDstSamples, 16);
+        ALfloat *RESTRICT SrcData = ASSUME_ALIGNED(converter->mSrcSamples, 16);
+        ALfloat *RESTRICT DstData = ASSUME_ALIGNED(converter->mDstSamples, 16);
         ALint prepcount = converter->mSrcPrepCount;
         ALsizei DataPosFrac = converter->mFracOffset;
         ALuint64 DataSize64;
@@ -377,14 +377,14 @@ void DestroyChannelConverter(ChannelConverter **converter)
 
 
 #define DECL_TEMPLATE(T)                                                       \
-static void Mono2Stereo##T(ALfloat *restrict dst, const T *src, ALsizei frames)\
+static void Mono2Stereo##T(ALfloat *RESTRICT dst, const T *src, ALsizei frames)\
 {                                                                              \
     ALsizei i;                                                                 \
     for(i = 0;i < frames;i++)                                                  \
         dst[i*2 + 1] = dst[i*2 + 0] = Sample_##T(src[i]) * 0.707106781187f;    \
 }                                                                              \
                                                                                \
-static void Stereo2Mono##T(ALfloat *restrict dst, const T *src, ALsizei frames)\
+static void Stereo2Mono##T(ALfloat *RESTRICT dst, const T *src, ALsizei frames)\
 {                                                                              \
     ALsizei i;                                                                 \
     for(i = 0;i < frames;i++)                                                  \
diff --git a/Alc/effects/autowah.c b/Alc/effects/autowah.c
index ba1180ef..f65f1be6 100644
--- a/Alc/effects/autowah.c
+++ b/Alc/effects/autowah.c
@@ -69,7 +69,7 @@ typedef struct ALautowahState {
 static ALvoid ALautowahState_Destruct(ALautowahState *state);
 static ALboolean ALautowahState_deviceUpdate(ALautowahState *state, ALCdevice *device);
 static ALvoid ALautowahState_update(ALautowahState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALautowahState_process(ALautowahState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
+static ALvoid ALautowahState_process(ALautowahState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
 DECLARE_DEFAULT_ALLOCATORS(ALautowahState)
 
 DEFINE_ALEFFECTSTATE_VTABLE(ALautowahState);
@@ -134,7 +134,7 @@ static ALvoid ALautowahState_update(ALautowahState *state, const ALCcontext *con
                         state->Chans[i].TargetGains);
 }
 
-static ALvoid ALautowahState_process(ALautowahState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+static ALvoid ALautowahState_process(ALautowahState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
 {
     const ALfloat attack_rate = state->AttackRate;
     const ALfloat release_rate = state->ReleaseRate;
diff --git a/Alc/effects/chorus.c b/Alc/effects/chorus.c
index f2861cf5..725189b3 100644
--- a/Alc/effects/chorus.c
+++ b/Alc/effects/chorus.c
@@ -66,7 +66,7 @@ typedef struct ALchorusState {
 static ALvoid ALchorusState_Destruct(ALchorusState *state);
 static ALboolean ALchorusState_deviceUpdate(ALchorusState *state, ALCdevice *Device);
 static ALvoid ALchorusState_update(ALchorusState *state, const ALCcontext *Context, const ALeffectslot *Slot, const ALeffectProps *props);
-static ALvoid ALchorusState_process(ALchorusState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
+static ALvoid ALchorusState_process(ALchorusState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
 DECLARE_DEFAULT_ALLOCATORS(ALchorusState)
 
 DEFINE_ALEFFECTSTATE_VTABLE(ALchorusState);
@@ -188,7 +188,7 @@ static ALvoid ALchorusState_update(ALchorusState *state, const ALCcontext *Conte
     }
 }
 
-static void GetTriangleDelays(ALint *restrict delays, ALsizei offset, const ALsizei lfo_range,
+static void GetTriangleDelays(ALint *RESTRICT delays, ALsizei offset, const ALsizei lfo_range,
                               const ALfloat lfo_scale, const ALfloat depth, const ALsizei delay,
                               const ALsizei todo)
 {
@@ -200,7 +200,7 @@ static void GetTriangleDelays(ALint *restrict delays, ALsizei offset, const ALsi
     }
 }
 
-static void GetSinusoidDelays(ALint *restrict delays, ALsizei offset, const ALsizei lfo_range,
+static void GetSinusoidDelays(ALint *RESTRICT delays, ALsizei offset, const ALsizei lfo_range,
                               const ALfloat lfo_scale, const ALfloat depth, const ALsizei delay,
                               const ALsizei todo)
 {
@@ -213,12 +213,12 @@ static void GetSinusoidDelays(ALint *restrict delays, ALsizei offset, const ALsi
 }
 
 
-static ALvoid ALchorusState_process(ALchorusState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+static ALvoid ALchorusState_process(ALchorusState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
 {
     const ALsizei bufmask = state->BufferLength-1;
     const ALfloat feedback = state->feedback;
     const ALsizei avgdelay = (state->delay + (FRACTIONONE>>1)) >> FRACTIONBITS;
-    ALfloat *restrict delaybuf = state->SampleBuffer;
+    ALfloat *RESTRICT delaybuf = state->SampleBuffer;
     ALsizei offset = state->offset;
     ALsizei i, c;
     ALsizei base;
diff --git a/Alc/effects/compressor.c b/Alc/effects/compressor.c
index 2b4a76b0..d9b9f1e0 100644
--- a/Alc/effects/compressor.c
+++ b/Alc/effects/compressor.c
@@ -50,7 +50,7 @@ typedef struct ALcompressorState {
 static ALvoid ALcompressorState_Destruct(ALcompressorState *state);
 static ALboolean ALcompressorState_deviceUpdate(ALcompressorState *state, ALCdevice *device);
 static ALvoid ALcompressorState_update(ALcompressorState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALcompressorState_process(ALcompressorState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
+static ALvoid ALcompressorState_process(ALcompressorState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
 DECLARE_DEFAULT_ALLOCATORS(ALcompressorState)
 
 DEFINE_ALEFFECTSTATE_VTABLE(ALcompressorState);
@@ -102,7 +102,7 @@ static ALvoid ALcompressorState_update(ALcompressorState *state, const ALCcontex
         ComputePanGains(&device->FOAOut, IdentityMatrixf.m[i], slot->Params.Gain, state->Gain[i]);
 }
 
-static ALvoid ALcompressorState_process(ALcompressorState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+static ALvoid ALcompressorState_process(ALcompressorState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
 {
     ALsizei i, j, k;
     ALsizei base;
diff --git a/Alc/effects/dedicated.c b/Alc/effects/dedicated.c
index 0e1fd389..59c13b77 100644
--- a/Alc/effects/dedicated.c
+++ b/Alc/effects/dedicated.c
@@ -39,7 +39,7 @@ typedef struct ALdedicatedState {
 static ALvoid ALdedicatedState_Destruct(ALdedicatedState *state);
 static ALboolean ALdedicatedState_deviceUpdate(ALdedicatedState *state, ALCdevice *device);
 static ALvoid ALdedicatedState_update(ALdedicatedState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALdedicatedState_process(ALdedicatedState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
+static ALvoid ALdedicatedState_process(ALdedicatedState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
 DECLARE_DEFAULT_ALLOCATORS(ALdedicatedState)
 
 DEFINE_ALEFFECTSTATE_VTABLE(ALdedicatedState);
@@ -107,7 +107,7 @@ static ALvoid ALdedicatedState_update(ALdedicatedState *state, const ALCcontext
     }
 }
 
-static ALvoid ALdedicatedState_process(ALdedicatedState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+static ALvoid ALdedicatedState_process(ALdedicatedState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
 {
     MixSamples(SamplesIn[0], NumChannels, SamplesOut, state->CurrentGains,
                state->TargetGains, SamplesToDo, 0, SamplesToDo);
diff --git a/Alc/effects/distortion.c b/Alc/effects/distortion.c
index de8da4fe..f2a70bff 100644
--- a/Alc/effects/distortion.c
+++ b/Alc/effects/distortion.c
@@ -48,7 +48,7 @@ typedef struct ALdistortionState {
 static ALvoid ALdistortionState_Destruct(ALdistortionState *state);
 static ALboolean ALdistortionState_deviceUpdate(ALdistortionState *state, ALCdevice *device);
 static ALvoid ALdistortionState_update(ALdistortionState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALdistortionState_process(ALdistortionState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
+static ALvoid ALdistortionState_process(ALdistortionState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
 DECLARE_DEFAULT_ALLOCATORS(ALdistortionState)
 
 DEFINE_ALEFFECTSTATE_VTABLE(ALdistortionState);
@@ -107,9 +107,9 @@ static ALvoid ALdistortionState_update(ALdistortionState *state, const ALCcontex
     ComputePanGains(&device->Dry, coeffs, slot->Params.Gain*props->Distortion.Gain, state->Gain);
 }
 
-static ALvoid ALdistortionState_process(ALdistortionState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+static ALvoid ALdistortionState_process(ALdistortionState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
 {
-    ALfloat (*restrict buffer)[BUFFERSIZE] = state->Buffer;
+    ALfloat (*RESTRICT buffer)[BUFFERSIZE] = state->Buffer;
     const ALfloat fc = state->edge_coeff;
     ALsizei base;
     ALsizei i, k;
diff --git a/Alc/effects/echo.c b/Alc/effects/echo.c
index 4570fcb1..5c323986 100644
--- a/Alc/effects/echo.c
+++ b/Alc/effects/echo.c
@@ -58,7 +58,7 @@ typedef struct ALechoState {
 static ALvoid ALechoState_Destruct(ALechoState *state);
 static ALboolean ALechoState_deviceUpdate(ALechoState *state, ALCdevice *Device);
 static ALvoid ALechoState_update(ALechoState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALechoState_process(ALechoState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
+static ALvoid ALechoState_process(ALechoState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
 DECLARE_DEFAULT_ALLOCATORS(ALechoState)
 
 DEFINE_ALEFFECTSTATE_VTABLE(ALechoState);
@@ -148,12 +148,12 @@ static ALvoid ALechoState_update(ALechoState *state, const ALCcontext *context,
     ComputePanGains(&device->Dry, coeffs, slot->Params.Gain, state->Gains[1].Target);
 }
 
-static ALvoid ALechoState_process(ALechoState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+static ALvoid ALechoState_process(ALechoState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
 {
     const ALsizei mask = state->BufferLength-1;
     const ALsizei tap1 = state->Tap[0].delay;
     const ALsizei tap2 = state->Tap[1].delay;
-    ALfloat *restrict delaybuf = state->SampleBuffer;
+    ALfloat *RESTRICT delaybuf = state->SampleBuffer;
     ALsizei offset = state->Offset;
     ALfloat z1, z2, in, out;
     ALsizei base;
diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c
index 17106127..c62f8e80 100644
--- a/Alc/effects/equalizer.c
+++ b/Alc/effects/equalizer.c
@@ -90,7 +90,7 @@ typedef struct ALequalizerState {
 static ALvoid ALequalizerState_Destruct(ALequalizerState *state);
 static ALboolean ALequalizerState_deviceUpdate(ALequalizerState *state, ALCdevice *device);
 static ALvoid ALequalizerState_update(ALequalizerState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALequalizerState_process(ALequalizerState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
+static ALvoid ALequalizerState_process(ALequalizerState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
 DECLARE_DEFAULT_ALLOCATORS(ALequalizerState)
 
 DEFINE_ALEFFECTSTATE_VTABLE(ALequalizerState);
@@ -176,9 +176,9 @@ static ALvoid ALequalizerState_update(ALequalizerState *state, const ALCcontext
                         state->Chans[i].TargetGains);
 }
 
-static ALvoid ALequalizerState_process(ALequalizerState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+static ALvoid ALequalizerState_process(ALequalizerState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
 {
-    ALfloat (*restrict temps)[BUFFERSIZE] = state->SampleBuffer;
+    ALfloat (*RESTRICT temps)[BUFFERSIZE] = state->SampleBuffer;
     ALsizei c;
 
     for(c = 0;c < MAX_EFFECT_CHANNELS;c++)
diff --git a/Alc/effects/fshifter.c b/Alc/effects/fshifter.c
index 7d72472a..6ada7dfa 100644
--- a/Alc/effects/fshifter.c
+++ b/Alc/effects/fshifter.c
@@ -64,7 +64,7 @@ typedef struct ALfshifterState {
 static ALvoid ALfshifterState_Destruct(ALfshifterState *state);
 static ALboolean ALfshifterState_deviceUpdate(ALfshifterState *state, ALCdevice *device);
 static ALvoid ALfshifterState_update(ALfshifterState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALfshifterState_process(ALfshifterState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
+static ALvoid ALfshifterState_process(ALfshifterState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
 DECLARE_DEFAULT_ALLOCATORS(ALfshifterState)
 
 DEFINE_ALEFFECTSTATE_VTABLE(ALfshifterState);
@@ -147,10 +147,10 @@ static ALvoid ALfshifterState_update(ALfshifterState *state, const ALCcontext *c
     ComputePanGains(&device->Dry, coeffs, slot->Params.Gain, state->TargetGains);
 }
 
-static ALvoid ALfshifterState_process(ALfshifterState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+static ALvoid ALfshifterState_process(ALfshifterState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
 {
     static const ALcomplex complex_zero = { 0.0, 0.0 };
-    ALfloat *restrict BufferOut = state->BufferOut;
+    ALfloat *RESTRICT BufferOut = state->BufferOut;
     ALsizei j, k, base;
 
     for(base = 0;base < SamplesToDo;)
diff --git a/Alc/effects/modulator.c b/Alc/effects/modulator.c
index e368adb8..dd3d1981 100644
--- a/Alc/effects/modulator.c
+++ b/Alc/effects/modulator.c
@@ -51,7 +51,7 @@ typedef struct ALmodulatorState {
 static ALvoid ALmodulatorState_Destruct(ALmodulatorState *state);
 static ALboolean ALmodulatorState_deviceUpdate(ALmodulatorState *state, ALCdevice *device);
 static ALvoid ALmodulatorState_update(ALmodulatorState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALmodulatorState_process(ALmodulatorState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
+static ALvoid ALmodulatorState_process(ALmodulatorState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
 DECLARE_DEFAULT_ALLOCATORS(ALmodulatorState)
 
 DEFINE_ALEFFECTSTATE_VTABLE(ALmodulatorState);
@@ -82,7 +82,7 @@ static inline ALfloat One(ALsizei UNUSED(index))
 }
 
 #define DECL_TEMPLATE(func)                                                   \
-static void Modulate##func(ALfloat *restrict dst, ALsizei index,              \
+static void Modulate##func(ALfloat *RESTRICT dst, ALsizei index,              \
                            const ALsizei step, ALsizei todo)                  \
 {                                                                             \
     ALsizei i;                                                                \
@@ -162,7 +162,7 @@ static ALvoid ALmodulatorState_update(ALmodulatorState *state, const ALCcontext
                         state->Chans[i].TargetGains);
 }
 
-static ALvoid ALmodulatorState_process(ALmodulatorState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+static ALvoid ALmodulatorState_process(ALmodulatorState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
 {
     const ALsizei step = state->step;
     ALsizei base;
diff --git a/Alc/effects/null.c b/Alc/effects/null.c
index e57359e3..6eaa001f 100644
--- a/Alc/effects/null.c
+++ b/Alc/effects/null.c
@@ -17,7 +17,7 @@ typedef struct ALnullState {
 static ALvoid ALnullState_Destruct(ALnullState *state);
 static ALboolean ALnullState_deviceUpdate(ALnullState *state, ALCdevice *device);
 static ALvoid ALnullState_update(ALnullState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALnullState_process(ALnullState *state, ALsizei samplesToDo, const ALfloat (*restrict samplesIn)[BUFFERSIZE], ALfloat (*restrict samplesOut)[BUFFERSIZE], ALsizei mumChannels);
+static ALvoid ALnullState_process(ALnullState *state, ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], ALsizei mumChannels);
 static void *ALnullState_New(size_t size);
 static void ALnullState_Delete(void *ptr);
 
@@ -64,7 +64,7 @@ static ALvoid ALnullState_update(ALnullState* UNUSED(state), const ALCcontext* U
  * input to the output buffer. The result should be added to the output buffer,
  * not replace it.
  */
-static ALvoid ALnullState_process(ALnullState* UNUSED(state), ALsizei UNUSED(samplesToDo), const ALfloatBUFFERSIZE*restrict UNUSED(samplesIn), ALfloatBUFFERSIZE*restrict UNUSED(samplesOut), ALsizei UNUSED(numChannels))
+static ALvoid ALnullState_process(ALnullState* UNUSED(state), ALsizei UNUSED(samplesToDo), const ALfloatBUFFERSIZE*RESTRICT UNUSED(samplesIn), ALfloatBUFFERSIZE*RESTRICT UNUSED(samplesOut), ALsizei UNUSED(numChannels))
 {
 }
 
diff --git a/Alc/effects/pshifter.c b/Alc/effects/pshifter.c
index ed18e9a8..35168eab 100644
--- a/Alc/effects/pshifter.c
+++ b/Alc/effects/pshifter.c
@@ -82,7 +82,7 @@ typedef struct ALpshifterState {
 static ALvoid ALpshifterState_Destruct(ALpshifterState *state);
 static ALboolean ALpshifterState_deviceUpdate(ALpshifterState *state, ALCdevice *device);
 static ALvoid ALpshifterState_update(ALpshifterState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALpshifterState_process(ALpshifterState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
+static ALvoid ALpshifterState_process(ALpshifterState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
 DECLARE_DEFAULT_ALLOCATORS(ALpshifterState)
 
 DEFINE_ALEFFECTSTATE_VTABLE(ALpshifterState);
@@ -211,7 +211,7 @@ static ALvoid ALpshifterState_update(ALpshifterState *state, const ALCcontext *c
     ComputePanGains(&device->Dry, coeffs, slot->Params.Gain, state->TargetGains);
 }
 
-static ALvoid ALpshifterState_process(ALpshifterState *state, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+static ALvoid ALpshifterState_process(ALpshifterState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
 {
     /* Pitch shifter engine based on the work of Stephan Bernsee.
      * http://blogs.zynaptiq.com/bernsee/pitch-shifting-using-the-ft/
@@ -219,7 +219,7 @@ static ALvoid ALpshifterState_process(ALpshifterState *state, ALsizei SamplesToD
 
     static const ALdouble expected = M_PI*2.0 / OVERSAMP;
     const ALdouble freq_per_bin = state->FreqPerBin;
-    ALfloat *restrict bufferOut = state->BufferOut;
+    ALfloat *RESTRICT bufferOut = state->BufferOut;
     ALsizei count = state->count;
     ALsizei i, j, k;
 
diff --git a/Alc/effects/reverb.c b/Alc/effects/reverb.c
index 8ebc089e..ad4aae5c 100644
--- a/Alc/effects/reverb.c
+++ b/Alc/effects/reverb.c
@@ -334,7 +334,7 @@ typedef struct ReverbState {
 static ALvoid ReverbState_Destruct(ReverbState *State);
 static ALboolean ReverbState_deviceUpdate(ReverbState *State, ALCdevice *Device);
 static ALvoid ReverbState_update(ReverbState *State, const ALCcontext *Context, const ALeffectslot *Slot, const ALeffectProps *props);
-static ALvoid ReverbState_process(ReverbState *State, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
+static ALvoid ReverbState_process(ReverbState *State, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
 DECLARE_DEFAULT_ALLOCATORS(ReverbState)
 
 DEFINE_ALEFFECTSTATE_VTABLE(ReverbState);
@@ -1069,7 +1069,7 @@ static inline ALfloat FadedDelayLineOut(const DelayLineI *Delay, const ALsizei o
 
 
 static inline void DelayLineIn(const DelayLineI *Delay, ALsizei offset, const ALsizei c,
-                               const ALfloat *restrict in, ALsizei count)
+                               const ALfloat *RESTRICT in, ALsizei count)
 {
     ALsizei i;
     for(i = 0;i < count;i++)
@@ -1114,7 +1114,7 @@ static inline void DelayLineIn(const DelayLineI *Delay, ALsizei offset, const AL
  * Where D is a diagonal matrix (of x), and S is a triangular matrix (of y)
  * whose combination of signs are being iterated.
  */
-static inline void VectorPartialScatter(ALfloat *restrict out, const ALfloat *restrict in,
+static inline void VectorPartialScatter(ALfloat *RESTRICT out, const ALfloat *RESTRICT in,
                                         const ALfloat xCoeff, const ALfloat yCoeff)
 {
     out[0] = xCoeff*in[0] + yCoeff*(          in[1] + -in[2] + in[3]);
@@ -1128,7 +1128,7 @@ static inline void VectorPartialScatter(ALfloat *restrict out, const ALfloat *re
 /* Utilizes the above, but reverses the input channels. */
 static inline void VectorScatterRevDelayIn(const DelayLineI *Delay, ALint offset,
                                            const ALfloat xCoeff, const ALfloat yCoeff,
-                                           const ALfloat (*restrict in)[MAX_UPDATE_SAMPLES],
+                                           const ALfloat (*RESTRICT in)[MAX_UPDATE_SAMPLES],
                                            const ALsizei count)
 {
     const DelayLineI delay = *Delay;
@@ -1154,7 +1154,7 @@ static inline void VectorScatterRevDelayIn(const DelayLineI *Delay, ALint offset
  * Two static specializations are used for transitional (cross-faded) delay
  * line processing and non-transitional processing.
  */
-static void VectorAllpass_Unfaded(ALfloat (*restrict samples)[MAX_UPDATE_SAMPLES], ALsizei offset,
+static void VectorAllpass_Unfaded(ALfloat (*RESTRICT samples)[MAX_UPDATE_SAMPLES], ALsizei offset,
                                   const ALfloat xCoeff, const ALfloat yCoeff, ALsizei todo,
                                   VecAllpass *Vap)
 {
@@ -1184,7 +1184,7 @@ static void VectorAllpass_Unfaded(ALfloat (*restrict samples)[MAX_UPDATE_SAMPLES
         ++offset;
     }
 }
-static void VectorAllpass_Faded(ALfloat (*restrict samples)[MAX_UPDATE_SAMPLES], ALsizei offset,
+static void VectorAllpass_Faded(ALfloat (*RESTRICT samples)[MAX_UPDATE_SAMPLES], ALsizei offset,
                                 const ALfloat xCoeff, const ALfloat yCoeff, ALfloat fade,
                                 ALsizei todo, VecAllpass *Vap)
 {
@@ -1243,9 +1243,9 @@ static void VectorAllpass_Faded(ALfloat (*restrict samples)[MAX_UPDATE_SAMPLES],
  * line processing and non-transitional processing.
  */
 static void EarlyReflection_Unfaded(ReverbState *State, ALsizei offset, const ALsizei todo,
-                                    ALfloat (*restrict out)[MAX_UPDATE_SAMPLES])
+                                    ALfloat (*RESTRICT out)[MAX_UPDATE_SAMPLES])
 {
-    ALfloat (*restrict temps)[MAX_UPDATE_SAMPLES] = State->TempSamples;
+    ALfloat (*RESTRICT temps)[MAX_UPDATE_SAMPLES] = State->TempSamples;
     const DelayLineI early_delay = State->Early.Delay;
     const DelayLineI main_delay = State->Delay;
     const ALfloat mixX = State->MixX;
@@ -1294,9 +1294,9 @@ static void EarlyReflection_Unfaded(ReverbState *State, ALsizei offset, const AL
     VectorScatterRevDelayIn(&main_delay, late_feed_tap, mixX, mixY, out, todo);
 }
 static void EarlyReflection_Faded(ReverbState *State, ALsizei offset, const ALsizei todo,
-                                  const ALfloat fade, ALfloat (*restrict out)[MAX_UPDATE_SAMPLES])
+                                  const ALfloat fade, ALfloat (*RESTRICT out)[MAX_UPDATE_SAMPLES])
 {
-    ALfloat (*restrict temps)[MAX_UPDATE_SAMPLES] = State->TempSamples;
+    ALfloat (*RESTRICT temps)[MAX_UPDATE_SAMPLES] = State->TempSamples;
     const DelayLineI early_delay = State->Early.Delay;
     const DelayLineI main_delay = State->Delay;
     const ALfloat mixX = State->MixX;
@@ -1355,7 +1355,7 @@ static void EarlyReflection_Faded(ReverbState *State, ALsizei offset, const ALsi
 }
 
 /* Applies the two T60 damping filter sections. */
-static inline void LateT60Filter(ALfloat *restrict samples, const ALsizei todo, T60Filter *filter)
+static inline void LateT60Filter(ALfloat *RESTRICT samples, const ALsizei todo, T60Filter *filter)
 {
     ALfloat temp[MAX_UPDATE_SAMPLES];
     BiquadFilter_process(&filter->HFFilter, temp, samples, todo);
@@ -1377,9 +1377,9 @@ static inline void LateT60Filter(ALfloat *restrict samples, const ALsizei todo,
  * processing and one for non-transitional processing.
  */
 static void LateReverb_Unfaded(ReverbState *State, ALsizei offset, const ALsizei todo,
-                               ALfloat (*restrict out)[MAX_UPDATE_SAMPLES])
+                               ALfloat (*RESTRICT out)[MAX_UPDATE_SAMPLES])
 {
-    ALfloat (*restrict temps)[MAX_UPDATE_SAMPLES] = State->TempSamples;
+    ALfloat (*RESTRICT temps)[MAX_UPDATE_SAMPLES] = State->TempSamples;
     const DelayLineI late_delay = State->Late.Delay;
     const DelayLineI main_delay = State->Delay;
     const ALfloat mixX = State->MixX;
@@ -1415,9 +1415,9 @@ static void LateReverb_Unfaded(ReverbState *State, ALsizei offset, const ALsizei
     VectorScatterRevDelayIn(&late_delay, offset, mixX, mixY, out, todo);
 }
 static void LateReverb_Faded(ReverbState *State, ALsizei offset, const ALsizei todo,
-                             const ALfloat fade, ALfloat (*restrict out)[MAX_UPDATE_SAMPLES])
+                             const ALfloat fade, ALfloat (*RESTRICT out)[MAX_UPDATE_SAMPLES])
 {
-    ALfloat (*restrict temps)[MAX_UPDATE_SAMPLES] = State->TempSamples;
+    ALfloat (*RESTRICT temps)[MAX_UPDATE_SAMPLES] = State->TempSamples;
     const DelayLineI late_delay = State->Late.Delay;
     const DelayLineI main_delay = State->Delay;
     const ALfloat mixX = State->MixX;
@@ -1466,10 +1466,10 @@ static void LateReverb_Faded(ReverbState *State, ALsizei offset, const ALsizei t
     VectorScatterRevDelayIn(&late_delay, offset, mixX, mixY, temps, todo);
 }
 
-static ALvoid ReverbState_process(ReverbState *State, ALsizei SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+static ALvoid ReverbState_process(ReverbState *State, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
 {
-    ALfloat (*restrict afmt)[MAX_UPDATE_SAMPLES] = State->TempSamples;
-    ALfloat (*restrict samples)[MAX_UPDATE_SAMPLES] = State->MixSamples;
+    ALfloat (*RESTRICT afmt)[MAX_UPDATE_SAMPLES] = State->TempSamples;
+    ALfloat (*RESTRICT samples)[MAX_UPDATE_SAMPLES] = State->MixSamples;
     ALsizei fadeCount = State->FadeCount;
     ALsizei offset = State->Offset;
     ALsizei base, c;
diff --git a/Alc/filters/filter.c b/Alc/filters/filter.c
index 2b370f89..d05b0cae 100644
--- a/Alc/filters/filter.c
+++ b/Alc/filters/filter.c
@@ -8,7 +8,7 @@
 #include "defs.h"
 
 extern inline void BiquadFilter_clear(BiquadFilter *filter);
-extern inline void BiquadFilter_copyParams(BiquadFilter *restrict dst, const BiquadFilter *restrict src);
+extern inline void BiquadFilter_copyParams(BiquadFilter *RESTRICT dst, const BiquadFilter *RESTRICT src);
 extern inline void BiquadFilter_passthru(BiquadFilter *filter, ALsizei numsamples);
 extern inline ALfloat calc_rcpQ_from_slope(ALfloat gain, ALfloat slope);
 extern inline ALfloat calc_rcpQ_from_bandwidth(ALfloat f0norm, ALfloat bandwidth);
@@ -94,7 +94,7 @@ void BiquadFilter_setParams(BiquadFilter *filter, BiquadType type, ALfloat gain,
 }
 
 
-void BiquadFilter_processC(BiquadFilter *filter, ALfloat *restrict dst, const ALfloat *restrict src, ALsizei numsamples)
+void BiquadFilter_processC(BiquadFilter *filter, ALfloat *RESTRICT dst, const ALfloat *RESTRICT src, ALsizei numsamples)
 {
     const ALfloat a1 = filter->a1;
     const ALfloat a2 = filter->a2;
diff --git a/Alc/filters/nfc.c b/Alc/filters/nfc.c
index 8869d1d0..8d61bb37 100644
--- a/Alc/filters/nfc.c
+++ b/Alc/filters/nfc.c
@@ -222,7 +222,7 @@ void NfcFilterAdjust(NfcFilter *nfc, const float w0)
 }
 
 
-void NfcFilterProcess1(NfcFilter *nfc, float *restrict dst, const float *restrict src, const int count)
+void NfcFilterProcess1(NfcFilter *nfc, float *RESTRICT dst, const float *RESTRICT src, const int count)
 {
     const float gain = nfc->first.gain;
     const float b1 = nfc->first.b1;
@@ -243,7 +243,7 @@ void NfcFilterProcess1(NfcFilter *nfc, float *restrict dst, const float *restric
     nfc->first.z[0] = z1;
 }
 
-void NfcFilterProcess2(NfcFilter *nfc, float *restrict dst, const float *restrict src, const int count)
+void NfcFilterProcess2(NfcFilter *nfc, float *RESTRICT dst, const float *RESTRICT src, const int count)
 {
     const float gain = nfc->second.gain;
     const float b1 = nfc->second.b1;
@@ -269,7 +269,7 @@ void NfcFilterProcess2(NfcFilter *nfc, float *restrict dst, const float *restric
     nfc->second.z[1] = z2;
 }
 
-void NfcFilterProcess3(NfcFilter *nfc, float *restrict dst, const float *restrict src, const int count)
+void NfcFilterProcess3(NfcFilter *nfc, float *RESTRICT dst, const float *RESTRICT src, const int count)
 {
     const float gain = nfc->third.gain;
     const float b1 = nfc->third.b1;
diff --git a/Alc/filters/splitter.c b/Alc/filters/splitter.c
index e99f4b95..6aed7493 100644
--- a/Alc/filters/splitter.c
+++ b/Alc/filters/splitter.c
@@ -27,7 +27,7 @@ void bandsplit_clear(BandSplitter *splitter)
     splitter->hp_z1 = 0.0f;
 }
 
-void bandsplit_process(BandSplitter *splitter, ALfloat *restrict hpout, ALfloat *restrict lpout,
+void bandsplit_process(BandSplitter *splitter, ALfloat *RESTRICT hpout, ALfloat *RESTRICT lpout,
                        const ALfloat *input, ALsizei count)
 {
     ALfloat lp_coeff, hp_coeff, lp_y, hp_y, d;
@@ -86,7 +86,7 @@ void splitterap_clear(SplitterAllpass *splitter)
     splitter->z1 = 0.0f;
 }
 
-void splitterap_process(SplitterAllpass *splitter, ALfloat *restrict samples, ALsizei count)
+void splitterap_process(SplitterAllpass *splitter, ALfloat *RESTRICT samples, ALsizei count)
 {
     ALfloat coeff, in, out;
     ALfloat z1;
diff --git a/Alc/filters/splitter.h b/Alc/filters/splitter.h
index a788bc3e..b2dc9b4a 100644
--- a/Alc/filters/splitter.h
+++ b/Alc/filters/splitter.h
@@ -14,7 +14,7 @@ typedef struct BandSplitter {
 
 void bandsplit_init(BandSplitter *splitter, ALfloat f0norm);
 void bandsplit_clear(BandSplitter *splitter);
-void bandsplit_process(BandSplitter *splitter, ALfloat *restrict hpout, ALfloat *restrict lpout,
+void bandsplit_process(BandSplitter *splitter, ALfloat *RESTRICT hpout, ALfloat *RESTRICT lpout,
                        const ALfloat *input, ALsizei count);
 
 /* The all-pass portion of the band splitter. Applies the same phase shift
@@ -27,7 +27,7 @@ typedef struct SplitterAllpass {
 
 void splitterap_init(SplitterAllpass *splitter, ALfloat f0norm);
 void splitterap_clear(SplitterAllpass *splitter);
-void splitterap_process(SplitterAllpass *splitter, ALfloat *restrict samples, ALsizei count);
+void splitterap_process(SplitterAllpass *splitter, ALfloat *RESTRICT samples, ALsizei count);
 
 
 typedef struct FrontStablizer {
diff --git a/Alc/hrtf.c b/Alc/hrtf.c
index ddbd3a28..ce602ee1 100644
--- a/Alc/hrtf.c
+++ b/Alc/hrtf.c
@@ -103,7 +103,7 @@ static ALsizei CalcAzIndex(ALsizei azcount, ALfloat az, ALfloat *mu)
  * and azimuth in radians. The coefficients are normalized.
  */
 void GetHrtfCoeffs(const struct Hrtf *Hrtf, ALfloat elevation, ALfloat azimuth, ALfloat spread,
-                   ALfloat (*restrict coeffs)[2], ALsizei *delays)
+                   ALfloat (*RESTRICT coeffs)[2], ALsizei *delays)
 {
     ALsizei evidx, azidx, idx[4];
     ALsizei evoffset;
@@ -183,7 +183,7 @@ void GetHrtfCoeffs(const struct Hrtf *Hrtf, ALfloat elevation, ALfloat azimuth,
     }
     for(c = 0;c < 4;c++)
     {
-        const ALfloat (*restrict srccoeffs)[2] = ASSUME_ALIGNED(Hrtf->coeffs+idx[c], 16);
+        const ALfloat (*RESTRICT srccoeffs)[2] = ASSUME_ALIGNED(Hrtf->coeffs+idx[c], 16);
         for(i = 0;i < Hrtf->irSize;i++)
         {
             coeffs[i][0] += srccoeffs[i][0] * blend[c];
@@ -193,7 +193,7 @@ void GetHrtfCoeffs(const struct Hrtf *Hrtf, ALfloat elevation, ALfloat azimuth,
 }
 
 
-void BuildBFormatHrtf(const struct Hrtf *Hrtf, DirectHrtfState *state, ALsizei NumChannels, const struct AngularPoint *AmbiPoints, const ALfloat (*restrict AmbiMatrix)[MAX_AMBI_COEFFS], ALsizei AmbiCount, const ALfloat *restrict AmbiOrderHFGain)
+void BuildBFormatHrtf(const struct Hrtf *Hrtf, DirectHrtfState *state, ALsizei NumChannels, const struct AngularPoint *AmbiPoints, const ALfloat (*RESTRICT AmbiMatrix)[MAX_AMBI_COEFFS], ALsizei AmbiCount, const ALfloat *RESTRICT AmbiOrderHFGain)
 {
 /* Set this to 2 for dual-band HRTF processing. May require a higher quality
  * band-splitter, or better calculation of the new IR length to deal with the
@@ -202,7 +202,7 @@ void BuildBFormatHrtf(const struct Hrtf *Hrtf, DirectHrtfState *state, ALsizei N
 #define NUM_BANDS 2
     BandSplitter splitter;
     ALdouble (*tmpres)[HRIR_LENGTH][2];
-    ALsizei *restrict idx;
+    ALsizei *RESTRICT idx;
     ALsizei min_delay = HRTF_HISTORY_LENGTH;
     ALsizei max_delay = 0;
     ALfloat temps[3][HRIR_LENGTH];
diff --git a/Alc/mastering.c b/Alc/mastering.c
index 52ff5b23..dd4ed7e1 100644
--- a/Alc/mastering.c
+++ b/Alc/mastering.c
@@ -83,8 +83,8 @@ static ALfloat UpdateSlidingHold(SlidingHold *Hold, const ALsizei i, const ALflo
 {
     const ALsizei mask = BUFFERSIZE - 1;
     const ALsizei length = Hold->Length;
-    ALfloat *restrict values = Hold->Values;
-    ALsizei *restrict expiries = Hold->Expiries;
+    ALfloat *RESTRICT values = Hold->Values;
+    ALsizei *RESTRICT expiries = Hold->Expiries;
     ALsizei lowerIndex = Hold->LowerIndex;
     ALsizei upperIndex = Hold->UpperIndex;
 
@@ -122,7 +122,7 @@ static ALfloat UpdateSlidingHold(SlidingHold *Hold, const ALsizei i, const ALflo
 static void ShiftSlidingHold(SlidingHold *Hold, const ALsizei n)
 {
     const ALsizei lowerIndex = Hold->LowerIndex;
-    ALsizei *restrict expiries = Hold->Expiries;
+    ALsizei *RESTRICT expiries = Hold->Expiries;
     ALsizei i = Hold->UpperIndex;
 
     if(lowerIndex < i)
@@ -140,11 +140,11 @@ static void ShiftSlidingHold(SlidingHold *Hold, const ALsizei n)
 /* Multichannel compression is linked via the absolute maximum of all
  * channels.
  */
-static void LinkChannels(Compressor *Comp, const ALsizei SamplesToDo, ALfloat (*restrict OutBuffer)[BUFFERSIZE])
+static void LinkChannels(Compressor *Comp, const ALsizei SamplesToDo, ALfloat (*RESTRICT OutBuffer)[BUFFERSIZE])
 {
     const ALsizei index = Comp->LookAhead;
     const ALsizei numChans = Comp->NumChans;
-    ALfloat *restrict sideChain = Comp->SideChain;
+    ALfloat *RESTRICT sideChain = Comp->SideChain;
     ALsizei c, i;
 
     ASSUME(SamplesToDo > 0);
@@ -173,8 +173,8 @@ static void CrestDetector(Compressor *Comp, const ALsizei SamplesToDo)
 {
     const ALfloat a_crest = Comp->CrestCoeff;
     const ALsizei index = Comp->LookAhead;
-    const ALfloat *restrict sideChain = Comp->SideChain;
-    ALfloat *restrict crestFactor = Comp->CrestFactor;
+    const ALfloat *RESTRICT sideChain = Comp->SideChain;
+    ALfloat *RESTRICT crestFactor = Comp->CrestFactor;
     ALfloat y2_peak = Comp->LastPeakSq;
     ALfloat y2_rms = Comp->LastRmsSq;
     ALsizei i;
@@ -202,7 +202,7 @@ static void CrestDetector(Compressor *Comp, const ALsizei SamplesToDo)
 static void PeakDetector(Compressor *Comp, const ALsizei SamplesToDo)
 {
     const ALsizei index = Comp->LookAhead;
-    ALfloat *restrict sideChain = Comp->SideChain;
+    ALfloat *RESTRICT sideChain = Comp->SideChain;
     ALsizei i;
 
     ASSUME(SamplesToDo > 0);
@@ -223,7 +223,7 @@ static void PeakDetector(Compressor *Comp, const ALsizei SamplesToDo)
 static void PeakHoldDetector(Compressor *Comp, const ALsizei SamplesToDo)
 {
     const ALsizei index = Comp->LookAhead;
-    ALfloat *restrict sideChain = Comp->SideChain;
+    ALfloat *RESTRICT sideChain = Comp->SideChain;
     SlidingHold *hold = Comp->Hold;
     ALsizei i;
 
@@ -260,8 +260,8 @@ static void GainCompressor(Compressor *Comp, const ALsizei SamplesToDo)
     const ALfloat release = Comp->Release;
     const ALfloat c_est = Comp->GainEstimate;
     const ALfloat a_adp = Comp->AdaptCoeff;
-    const ALfloat *restrict crestFactor = Comp->CrestFactor;
-    ALfloat *restrict sideChain = Comp->SideChain;
+    const ALfloat *RESTRICT crestFactor = Comp->CrestFactor;
+    ALfloat *RESTRICT sideChain = Comp->SideChain;
     ALfloat postGain = Comp->PostGain;
     ALfloat knee = Comp->Knee;
     ALfloat t_att = attack;
@@ -353,13 +353,13 @@ static void GainCompressor(Compressor *Comp, const ALsizei SamplesToDo)
  * reaching the offending impulse.  This is best used when operating as a
  * limiter.
  */
-static void SignalDelay(Compressor *Comp, const ALsizei SamplesToDo, ALfloat (*restrict OutBuffer)[BUFFERSIZE])
+static void SignalDelay(Compressor *Comp, const ALsizei SamplesToDo, ALfloat (*RESTRICT OutBuffer)[BUFFERSIZE])
 {
     const ALsizei mask = BUFFERSIZE - 1;
     const ALsizei numChans = Comp->NumChans;
     const ALsizei indexIn = Comp->DelayIndex;
     const ALsizei indexOut = Comp->DelayIndex - Comp->LookAhead;
-    ALfloat (*restrict delay)[BUFFERSIZE] = Comp->Delay;
+    ALfloat (*RESTRICT delay)[BUFFERSIZE] = Comp->Delay;
     ALsizei c, i;
 
     ASSUME(SamplesToDo > 0);
@@ -481,11 +481,11 @@ Compressor* CompressorInit(const ALsizei NumChans, const ALuint SampleRate,
     return Comp;
 }
 
-void ApplyCompression(Compressor *Comp, const ALsizei SamplesToDo, ALfloat (*restrict OutBuffer)[BUFFERSIZE])
+void ApplyCompression(Compressor *Comp, const ALsizei SamplesToDo, ALfloat (*RESTRICT OutBuffer)[BUFFERSIZE])
 {
     const ALsizei numChans = Comp->NumChans;
     const ALfloat preGain = Comp->PreGain;
-    ALfloat *restrict sideChain;
+    ALfloat *RESTRICT sideChain;
     ALsizei c, i;
 
     ASSUME(SamplesToDo > 0);
diff --git a/Alc/mastering.h b/Alc/mastering.h
index b68b0de1..17f5e8be 100644
--- a/Alc/mastering.h
+++ b/Alc/mastering.h
@@ -42,7 +42,7 @@ struct Compressor* CompressorInit(const ALsizei NumChans, const ALuint SampleRat
     const ALfloat AttackTime, const ALfloat ReleaseTime);
 
 void ApplyCompression(struct Compressor *Comp, const ALsizei SamplesToDo,
-                      ALfloat (*restrict OutBuffer)[BUFFERSIZE]);
+                      ALfloat (*RESTRICT OutBuffer)[BUFFERSIZE]);
 
 ALsizei GetCompressorLookAhead(const struct Compressor *Comp);
 
diff --git a/Alc/mixer/defs.h b/Alc/mixer/defs.h
index 8f6e3755..acb8a8c2 100644
--- a/Alc/mixer/defs.h
+++ b/Alc/mixer/defs.h
@@ -12,57 +12,57 @@ struct MixHrtfParams;
 struct HrtfState;
 
 /* C resamplers */
-const ALfloat *Resample_copy_C(const InterpState *state, const ALfloat *restrict src, ALsizei frac, ALint increment, ALfloat *restrict dst, ALsizei dstlen);
-const ALfloat *Resample_point_C(const InterpState *state, const ALfloat *restrict src, ALsizei frac, ALint increment, ALfloat *restrict dst, ALsizei dstlen);
-const ALfloat *Resample_lerp_C(const InterpState *state, const ALfloat *restrict src, ALsizei frac, ALint increment, ALfloat *restrict dst, ALsizei dstlen);
-const ALfloat *Resample_cubic_C(const InterpState *state, const ALfloat *restrict src, ALsizei frac, ALint increment, ALfloat *restrict dst, ALsizei dstlen);
-const ALfloat *Resample_bsinc_C(const InterpState *state, const ALfloat *restrict src, ALsizei frac, ALint increment, ALfloat *restrict dst, ALsizei dstlen);
+const ALfloat *Resample_copy_C(const InterpState *state, const ALfloat *RESTRICT src, ALsizei frac, ALint increment, ALfloat *RESTRICT dst, ALsizei dstlen);
+const ALfloat *Resample_point_C(const InterpState *state, const ALfloat *RESTRICT src, ALsizei frac, ALint increment, ALfloat *RESTRICT dst, ALsizei dstlen);
+const ALfloat *Resample_lerp_C(const InterpState *state, const ALfloat *RESTRICT src, ALsizei frac, ALint increment, ALfloat *RESTRICT dst, ALsizei dstlen);
+const ALfloat *Resample_cubic_C(const InterpState *state, const ALfloat *RESTRICT src, ALsizei frac, ALint increment, ALfloat *RESTRICT dst, ALsizei dstlen);
+const ALfloat *Resample_bsinc_C(const InterpState *state, const ALfloat *RESTRICT src, ALsizei frac, ALint increment, ALfloat *RESTRICT dst, ALsizei dstlen);
 
 
 /* C mixers */
-void MixHrtf_C(ALfloat *restrict LeftOut, ALfloat *restrict RightOut,
+void MixHrtf_C(ALfloat *RESTRICT LeftOut, ALfloat *RESTRICT RightOut,
                const ALfloat *data, ALsizei Offset, ALsizei OutPos,
                const ALsizei IrSize, struct MixHrtfParams *hrtfparams,
                struct HrtfState *hrtfstate, ALsizei BufferSize);
-void MixHrtfBlend_C(ALfloat *restrict LeftOut, ALfloat *restrict RightOut,
+void MixHrtfBlend_C(ALfloat *RESTRICT LeftOut, ALfloat *RESTRICT RightOut,
                     const ALfloat *data, ALsizei Offset, ALsizei OutPos,
                     const ALsizei IrSize, const HrtfParams *oldparams,
                     MixHrtfParams *newparams, HrtfState *hrtfstate,
                     ALsizei BufferSize);
-void MixDirectHrtf_C(ALfloat *restrict LeftOut, ALfloat *restrict RightOut,
+void MixDirectHrtf_C(ALfloat *RESTRICT LeftOut, ALfloat *RESTRICT RightOut,
                      const ALfloat *data, ALsizei Offset, const ALsizei IrSize,
-                     const ALfloat (*restrict Coeffs)[2], ALfloat (*restrict Values)[2],
+                     const ALfloat (*RESTRICT Coeffs)[2], ALfloat (*RESTRICT Values)[2],
                      ALsizei BufferSize);
-void Mix_C(const ALfloat *data, ALsizei OutChans, ALfloat (*restrict OutBuffer)[BUFFERSIZE],
+void Mix_C(const ALfloat *data, ALsizei OutChans, ALfloat (*RESTRICT OutBuffer)[BUFFERSIZE],
            ALfloat *CurrentGains, const ALfloat *TargetGains, ALsizei Counter, ALsizei OutPos,
            ALsizei BufferSize);
 void MixRow_C(ALfloat *OutBuffer, const ALfloat *Gains,
-              const ALfloat (*restrict data)[BUFFERSIZE], ALsizei InChans,
+              const ALfloat (*RESTRICT data)[BUFFERSIZE], ALsizei InChans,
               ALsizei InPos, ALsizei BufferSize);
 
 /* SSE mixers */
-void MixHrtf_SSE(ALfloat *restrict LeftOut, ALfloat *restrict RightOut,
+void MixHrtf_SSE(ALfloat *RESTRICT LeftOut, ALfloat *RESTRICT RightOut,
                  const ALfloat *data, ALsizei Offset, ALsizei OutPos,
                  const ALsizei IrSize, struct MixHrtfParams *hrtfparams,
                  struct HrtfState *hrtfstate, ALsizei BufferSize);
-void MixHrtfBlend_SSE(ALfloat *restrict LeftOut, ALfloat *restrict RightOut,
+void MixHrtfBlend_SSE(ALfloat *RESTRICT LeftOut, ALfloat *RESTRICT RightOut,
                       const ALfloat *data, ALsizei Offset, ALsizei OutPos,
                       const ALsizei IrSize, const HrtfParams *oldparams,
                       MixHrtfParams *newparams, HrtfState *hrtfstate,
                       ALsizei BufferSize);
-void MixDirectHrtf_SSE(ALfloat *restrict LeftOut, ALfloat *restrict RightOut,
+void MixDirectHrtf_SSE(ALfloat *RESTRICT LeftOut, ALfloat *RESTRICT RightOut,
                        const ALfloat *data, ALsizei Offset, const ALsizei IrSize,
-                       const ALfloat (*restrict Coeffs)[2], ALfloat (*restrict Values)[2],
+                       const ALfloat (*RESTRICT Coeffs)[2], ALfloat (*RESTRICT Values)[2],
                        ALsizei BufferSize);
-void Mix_SSE(const ALfloat *data, ALsizei OutChans, ALfloat (*restrict OutBuffer)[BUFFERSIZE],
+void Mix_SSE(const ALfloat *data, ALsizei OutChans, ALfloat (*RESTRICT OutBuffer)[BUFFERSIZE],
              ALfloat *CurrentGains, const ALfloat *TargetGains, ALsizei Counter, ALsizei OutPos,
              ALsizei BufferSize);
 void MixRow_SSE(ALfloat *OutBuffer, const ALfloat *Gains,
-                const ALfloat (*restrict data)[BUFFERSIZE], ALsizei InChans,
+                const ALfloat (*RESTRICT data)[BUFFERSIZE], ALsizei InChans,
                 ALsizei InPos, ALsizei BufferSize);
 
 /* SSE resamplers */
-inline void InitiatePositionArrays(ALsizei frac, ALint increment, ALsizei *restrict frac_arr, ALsizei *restrict pos_arr, ALsizei size)
+inline void InitiatePositionArrays(ALsizei frac, ALint increment, ALsizei *RESTRICT frac_arr, ALsizei *RESTRICT pos_arr, ALsizei size)
 {
     ALsizei i;
 
@@ -76,44 +76,44 @@ inline void InitiatePositionArrays(ALsizei frac, ALint increment, ALsizei *restr
     }
 }
 
-const ALfloat *Resample_lerp_SSE2(const InterpState *state, const ALfloat *restrict src,
-                                  ALsizei frac, ALint increment, ALfloat *restrict dst,
+const ALfloat *Resample_lerp_SSE2(const InterpState *state, const ALfloat *RESTRICT src,
+                                  ALsizei frac, ALint increment, ALfloat *RESTRICT dst,
                                   ALsizei numsamples);
-const ALfloat *Resample_lerp_SSE41(const InterpState *state, const ALfloat *restrict src,
-                                   ALsizei frac, ALint increment, ALfloat *restrict dst,
+const ALfloat *Resample_lerp_SSE41(const InterpState *state, const ALfloat *RESTRICT src,
+                                   ALsizei frac, ALint increment, ALfloat *RESTRICT dst,
                                    ALsizei numsamples);
 
-const ALfloat *Resample_bsinc_SSE(const InterpState *state, const ALfloat *restrict src,
-                                  ALsizei frac, ALint increment, ALfloat *restrict dst,
+const ALfloat *Resample_bsinc_SSE(const InterpState *state, const ALfloat *RESTRICT src,
+                                  ALsizei frac, ALint increment, ALfloat *RESTRICT dst,
                                   ALsizei dstlen);
 
 /* Neon mixers */
-void MixHrtf_Neon(ALfloat *restrict LeftOut, ALfloat *restrict RightOut,
+void MixHrtf_Neon(ALfloat *RESTRICT LeftOut, ALfloat *RESTRICT RightOut,
                   const ALfloat *data, ALsizei Offset, ALsizei OutPos,
                   const ALsizei IrSize, struct MixHrtfParams *hrtfparams,
                   struct HrtfState *hrtfstate, ALsizei BufferSize);
-void MixHrtfBlend_Neon(ALfloat *restrict LeftOut, ALfloat *restrict RightOut,
+void MixHrtfBlend_Neon(ALfloat *RESTRICT LeftOut, ALfloat *RESTRICT RightOut,
                        const ALfloat *data, ALsizei Offset, ALsizei OutPos,
                        const ALsizei IrSize, const HrtfParams *oldparams,
                        MixHrtfParams *newparams, HrtfState *hrtfstate,
                        ALsizei BufferSize);
-void MixDirectHrtf_Neon(ALfloat *restrict LeftOut, ALfloat *restrict RightOut,
+void MixDirectHrtf_Neon(ALfloat *RESTRICT LeftOut, ALfloat *RESTRICT RightOut,
                         const ALfloat *data, ALsizei Offset, const ALsizei IrSize,
-                        const ALfloat (*restrict Coeffs)[2], ALfloat (*restrict Values)[2],
+                        const ALfloat (*RESTRICT Coeffs)[2], ALfloat (*RESTRICT Values)[2],
                         ALsizei BufferSize);
-void Mix_Neon(const ALfloat *data, ALsizei OutChans, ALfloat (*restrict OutBuffer)[BUFFERSIZE],
+void Mix_Neon(const ALfloat *data, ALsizei OutChans, ALfloat (*RESTRICT OutBuffer)[BUFFERSIZE],
               ALfloat *CurrentGains, const ALfloat *TargetGains, ALsizei Counter, ALsizei OutPos,
               ALsizei BufferSize);
 void MixRow_Neon(ALfloat *OutBuffer, const ALfloat *Gains,
-                 const ALfloat (*restrict data)[BUFFERSIZE], ALsizei InChans,
+                 const ALfloat (*RESTRICT data)[BUFFERSIZE], ALsizei InChans,
                  ALsizei InPos, ALsizei BufferSize);
 
 /* Neon resamplers */
-const ALfloat *Resample_lerp_Neon(const InterpState *state, const ALfloat *restrict src,
-                                  ALsizei frac, ALint increment, ALfloat *restrict dst,
+const ALfloat *Resample_lerp_Neon(const InterpState *state, const ALfloat *RESTRICT src,
+                                  ALsizei frac, ALint increment, ALfloat *RESTRICT dst,
                                   ALsizei numsamples);
-const ALfloat *Resample_bsinc_Neon(const InterpState *state, const ALfloat *restrict src,
-                                   ALsizei frac, ALint increment, ALfloat *restrict dst,
+const ALfloat *Resample_bsinc_Neon(const InterpState *state, const ALfloat *RESTRICT src,
+                                   ALsizei frac, ALint increment, ALfloat *RESTRICT dst,
                                    ALsizei dstlen);
 
 #endif /* MIXER_DEFS_H */
diff --git a/Alc/mixer/hrtf_inc.c b/Alc/mixer/hrtf_inc.c
index 3ef22f24..21840abd 100644
--- a/Alc/mixer/hrtf_inc.c
+++ b/Alc/mixer/hrtf_inc.c
@@ -9,13 +9,13 @@
 #include "defs.h"
 
 
-static inline void ApplyCoeffs(ALsizei Offset, ALfloat (*restrict Values)[2],
+static inline void ApplyCoeffs(ALsizei Offset, ALfloat (*RESTRICT Values)[2],
                                const ALsizei irSize,
-                               const ALfloat (*restrict Coeffs)[2],
+                               const ALfloat (*RESTRICT Coeffs)[2],
                                ALfloat left, ALfloat right);
 
 
-void MixHrtf(ALfloat *restrict LeftOut, ALfloat *restrict RightOut,
+void MixHrtf(ALfloat *RESTRICT LeftOut, ALfloat *RESTRICT RightOut,
              const ALfloat *data, ALsizei Offset, ALsizei OutPos,
              const ALsizei IrSize, MixHrtfParams *hrtfparams, HrtfState *hrtfstate,
              ALsizei BufferSize)
@@ -54,7 +54,7 @@ void MixHrtf(ALfloat *restrict LeftOut, ALfloat *restrict RightOut,
     hrtfparams->Gain = gain + gainstep*stepcount;
 }
 
-void MixHrtfBlend(ALfloat *restrict LeftOut, ALfloat *restrict RightOut,
+void MixHrtfBlend(ALfloat *RESTRICT LeftOut, ALfloat *RESTRICT RightOut,
                   const ALfloat *data, ALsizei Offset, ALsizei OutPos,
                   const ALsizei IrSize, const HrtfParams *oldparams,
                   MixHrtfParams *newparams, HrtfState *hrtfstate,
@@ -103,9 +103,9 @@ void MixHrtfBlend(ALfloat *restrict LeftOut, ALfloat *restrict RightOut,
     newparams->Gain = newGain + newGainStep*stepcount;
 }
 
-void MixDirectHrtf(ALfloat *restrict LeftOut, ALfloat *restrict RightOut,
+void MixDirectHrtf(ALfloat *RESTRICT LeftOut, ALfloat *RESTRICT RightOut,
                    const ALfloat *data, ALsizei Offset, const ALsizei IrSize,
-                   const ALfloat (*restrict Coeffs)[2], ALfloat (*restrict Values)[2],
+                   const ALfloat (*RESTRICT Coeffs)[2], ALfloat (*RESTRICT Values)[2],
                    ALsizei BufferSize)
 {
     ALfloat insample;
diff --git a/Alc/mixer/mixer_c.c b/Alc/mixer/mixer_c.c
index 14d7c669..ea864dbc 100644
--- a/Alc/mixer/mixer_c.c
+++ b/Alc/mixer/mixer_c.c
@@ -9,13 +9,13 @@
 #include "defs.h"
 
 
-static inline ALfloat do_point(const InterpState* UNUSED(state), const ALfloat *restrict vals, ALsizei UNUSED(frac))
+static inline ALfloat do_point(const InterpState* UNUSED(state), const ALfloat *RESTRICT vals, ALsizei UNUSED(frac))
 { return vals[0]; }
-static inline ALfloat do_lerp(const InterpState* UNUSED(state), const ALfloat *restrict vals, ALsizei frac)
+static inline ALfloat do_lerp(const InterpState* UNUSED(state), const ALfloat *RESTRICT vals, ALsizei frac)
 { return lerp(vals[0], vals[1], frac * (1.0f/FRACTIONONE)); }
-static inline ALfloat do_cubic(const InterpState* UNUSED(state), const ALfloat *restrict vals, ALsizei frac)
+static inline ALfloat do_cubic(const InterpState* UNUSED(state), const ALfloat *RESTRICT vals, ALsizei frac)
 { return cubic(vals[0], vals[1], vals[2], vals[3], frac * (1.0f/FRACTIONONE)); }
-static inline ALfloat do_bsinc(const InterpState *state, const ALfloat *restrict vals, ALsizei frac)
+static inline ALfloat do_bsinc(const InterpState *state, const ALfloat *RESTRICT vals, ALsizei frac)
 {
     const ALfloat *fil, *scd, *phd, *spd;
     ALsizei j_f, pi;
@@ -42,8 +42,8 @@ static inline ALfloat do_bsinc(const InterpState *state, const ALfloat *restrict
 }
 
 const ALfloat *Resample_copy_C(const InterpState* UNUSED(state),
-  const ALfloat *restrict src, ALsizei UNUSED(frac), ALint UNUSED(increment),
-  ALfloat *restrict dst, ALsizei numsamples)
+  const ALfloat *RESTRICT src, ALsizei UNUSED(frac), ALint UNUSED(increment),
+  ALfloat *RESTRICT dst, ALsizei numsamples)
 {
 #if defined(HAVE_SSE) || defined(HAVE_NEON)
     /* Avoid copying the source data if it's aligned like the destination. */
@@ -56,8 +56,8 @@ const ALfloat *Resample_copy_C(const InterpState* UNUSED(state),
 
 #define DECL_TEMPLATE(Tag, Sampler, O)                                        \
 const ALfloat *Resample_##Tag##_C(const InterpState *state,                   \
-  const ALfloat *restrict src, ALsizei frac, ALint increment,                 \
-  ALfloat *restrict dst, ALsizei numsamples)                                  \
+  const ALfloat *RESTRICT src, ALsizei frac, ALint increment,                 \
+  ALfloat *RESTRICT dst, ALsizei numsamples)                                  \
 {                                                                             \
     const InterpState istate = *state;                                        \
     ALsizei i;                                                                \
@@ -84,9 +84,9 @@ DECL_TEMPLATE(bsinc, do_bsinc, istate.bsinc.l)
 #undef DECL_TEMPLATE
 
 
-static inline void ApplyCoeffs(ALsizei Offset, ALfloat (*restrict Values)[2],
+static inline void ApplyCoeffs(ALsizei Offset, ALfloat (*RESTRICT Values)[2],
                                const ALsizei IrSize,
-                               const ALfloat (*restrict Coeffs)[2],
+                               const ALfloat (*RESTRICT Coeffs)[2],
                                ALfloat left, ALfloat right)
 {
     ALsizei c;
@@ -104,7 +104,7 @@ static inline void ApplyCoeffs(ALsizei Offset, ALfloat (*restrict Values)[2],
 #include "hrtf_inc.c"
 
 
-void Mix_C(const ALfloat *data, ALsizei OutChans, ALfloat (*restrict OutBuffer)[BUFFERSIZE],
+void Mix_C(const ALfloat *data, ALsizei OutChans, ALfloat (*RESTRICT OutBuffer)[BUFFERSIZE],
            ALfloat *CurrentGains, const ALfloat *TargetGains, ALsizei Counter, ALsizei OutPos,
            ALsizei BufferSize)
 {
@@ -150,7 +150,7 @@ void Mix_C(const ALfloat *data, ALsizei OutChans, ALfloat (*restrict OutBuffer)[
  * transform. And as the matrices are more or less static once set up, no
  * stepping is necessary.
  */
-void MixRow_C(ALfloat *OutBuffer, const ALfloat *Gains, const ALfloat (*restrict data)[BUFFERSIZE], ALsizei InChans, ALsizei InPos, ALsizei BufferSize)
+void MixRow_C(ALfloat *OutBuffer, const ALfloat *Gains, const ALfloat (*RESTRICT data)[BUFFERSIZE], ALsizei InChans, ALsizei InPos, ALsizei BufferSize)
 {
     ALsizei c, i;
 
diff --git a/Alc/mixer/mixer_neon.c b/Alc/mixer/mixer_neon.c
index 9bf5521a..a035abc7 100644
--- a/Alc/mixer/mixer_neon.c
+++ b/Alc/mixer/mixer_neon.c
@@ -11,8 +11,8 @@
 
 
 const ALfloat *Resample_lerp_Neon(const InterpState* UNUSED(state),
-  const ALfloat *restrict src, ALsizei frac, ALint increment,
-  ALfloat *restrict dst, ALsizei numsamples)
+  const ALfloat *RESTRICT src, ALsizei frac, ALint increment,
+  ALfloat *RESTRICT dst, ALsizei numsamples)
 {
     const int32x4_t increment4 = vdupq_n_s32(increment*4);
     const float32x4_t fracOne4 = vdupq_n_f32(1.0f/FRACTIONONE);
@@ -67,8 +67,8 @@ const ALfloat *Resample_lerp_Neon(const InterpState* UNUSED(state),
 }
 
 const ALfloat *Resample_bsinc_Neon(const InterpState *state,
-  const ALfloat *restrict src, ALsizei frac, ALint increment,
-  ALfloat *restrict dst, ALsizei dstlen)
+  const ALfloat *RESTRICT src, ALsizei frac, ALint increment,
+  ALfloat *RESTRICT dst, ALsizei dstlen)
 {
     const ALfloat *const filter = state->bsinc.filter;
     const float32x4_t sf4 = vdupq_n_f32(state->bsinc.sf);
@@ -127,9 +127,9 @@ const ALfloat *Resample_bsinc_Neon(const InterpState *state,
 }
 
 
-static inline void ApplyCoeffs(ALsizei Offset, ALfloat (*restrict Values)[2],
+static inline void ApplyCoeffs(ALsizei Offset, ALfloat (*RESTRICT Values)[2],
                                const ALsizei IrSize,
-                               const ALfloat (*restrict Coeffs)[2],
+                               const ALfloat (*RESTRICT Coeffs)[2],
                                ALfloat left, ALfloat right)
 {
     ALsizei c;
@@ -163,7 +163,7 @@ static inline void ApplyCoeffs(ALsizei Offset, ALfloat (*restrict Values)[2],
 #include "hrtf_inc.c"
 
 
-void Mix_Neon(const ALfloat *data, ALsizei OutChans, ALfloat (*restrict OutBuffer)[BUFFERSIZE],
+void Mix_Neon(const ALfloat *data, ALsizei OutChans, ALfloat (*RESTRICT OutBuffer)[BUFFERSIZE],
               ALfloat *CurrentGains, const ALfloat *TargetGains, ALsizei Counter, ALsizei OutPos,
               ALsizei BufferSize)
 {
@@ -251,7 +251,7 @@ void Mix_Neon(const ALfloat *data, ALsizei OutChans, ALfloat (*restrict OutBuffe
     }
 }
 
-void MixRow_Neon(ALfloat *OutBuffer, const ALfloat *Gains, const ALfloat (*restrict data)[BUFFERSIZE], ALsizei InChans, ALsizei InPos, ALsizei BufferSize)
+void MixRow_Neon(ALfloat *OutBuffer, const ALfloat *Gains, const ALfloat (*RESTRICT data)[BUFFERSIZE], ALsizei InChans, ALsizei InPos, ALsizei BufferSize)
 {
     ALsizei c;
 
diff --git a/Alc/mixer/mixer_sse.c b/Alc/mixer/mixer_sse.c
index 725a5ebc..34055001 100644
--- a/Alc/mixer/mixer_sse.c
+++ b/Alc/mixer/mixer_sse.c
@@ -12,8 +12,8 @@
 #include "defs.h"
 
 
-const ALfloat *Resample_bsinc_SSE(const InterpState *state, const ALfloat *restrict src,
-                                  ALsizei frac, ALint increment, ALfloat *restrict dst,
+const ALfloat *Resample_bsinc_SSE(const InterpState *state, const ALfloat *RESTRICT src,
+                                  ALsizei frac, ALint increment, ALfloat *RESTRICT dst,
                                   ALsizei dstlen)
 {
     const ALfloat *const filter = state->bsinc.filter;
@@ -75,9 +75,9 @@ const ALfloat *Resample_bsinc_SSE(const InterpState *state, const ALfloat *restr
 }
 
 
-static inline void ApplyCoeffs(ALsizei Offset, ALfloat (*restrict Values)[2],
+static inline void ApplyCoeffs(ALsizei Offset, ALfloat (*RESTRICT Values)[2],
                                const ALsizei IrSize,
-                               const ALfloat (*restrict Coeffs)[2],
+                               const ALfloat (*RESTRICT Coeffs)[2],
                                ALfloat left, ALfloat right)
 {
     const __m128 lrlr = _mm_setr_ps(left, right, left, right);
@@ -135,7 +135,7 @@ static inline void ApplyCoeffs(ALsizei Offset, ALfloat (*restrict Values)[2],
 #include "hrtf_inc.c"
 
 
-void Mix_SSE(const ALfloat *data, ALsizei OutChans, ALfloat (*restrict OutBuffer)[BUFFERSIZE],
+void Mix_SSE(const ALfloat *data, ALsizei OutChans, ALfloat (*RESTRICT OutBuffer)[BUFFERSIZE],
              ALfloat *CurrentGains, const ALfloat *TargetGains, ALsizei Counter, ALsizei OutPos,
              ALsizei BufferSize)
 {
@@ -218,7 +218,7 @@ void Mix_SSE(const ALfloat *data, ALsizei OutChans, ALfloat (*restrict OutBuffer
     }
 }
 
-void MixRow_SSE(ALfloat *OutBuffer, const ALfloat *Gains, const ALfloat (*restrict data)[BUFFERSIZE], ALsizei InChans, ALsizei InPos, ALsizei BufferSize)
+void MixRow_SSE(ALfloat *OutBuffer, const ALfloat *Gains, const ALfloat (*RESTRICT data)[BUFFERSIZE], ALsizei InChans, ALsizei InPos, ALsizei BufferSize)
 {
     ALsizei c;
 
diff --git a/Alc/mixer/mixer_sse2.c b/Alc/mixer/mixer_sse2.c
index 9cbaeb0a..2432342f 100644
--- a/Alc/mixer/mixer_sse2.c
+++ b/Alc/mixer/mixer_sse2.c
@@ -28,8 +28,8 @@
 
 
 const ALfloat *Resample_lerp_SSE2(const InterpState* UNUSED(state),
-  const ALfloat *restrict src, ALsizei frac, ALint increment,
-  ALfloat *restrict dst, ALsizei numsamples)
+  const ALfloat *RESTRICT src, ALsizei frac, ALint increment,
+  ALfloat *RESTRICT dst, ALsizei numsamples)
 {
     const __m128i increment4 = _mm_set1_epi32(increment*4);
     const __m128 fracOne4 = _mm_set1_ps(1.0f/FRACTIONONE);
diff --git a/Alc/mixer/mixer_sse41.c b/Alc/mixer/mixer_sse41.c
index e92a3dd0..34b405f8 100644
--- a/Alc/mixer/mixer_sse41.c
+++ b/Alc/mixer/mixer_sse41.c
@@ -29,8 +29,8 @@
 
 
 const ALfloat *Resample_lerp_SSE41(const InterpState* UNUSED(state),
-  const ALfloat *restrict src, ALsizei frac, ALint increment,
-  ALfloat *restrict dst, ALsizei numsamples)
+  const ALfloat *RESTRICT src, ALsizei frac, ALint increment,
+  ALfloat *RESTRICT dst, ALsizei numsamples)
 {
     const __m128i increment4 = _mm_set1_epi32(increment*4);
     const __m128 fracOne4 = _mm_set1_ps(1.0f/FRACTIONONE);
diff --git a/Alc/mixvoice.c b/Alc/mixvoice.c
index d019b898..587f4a6b 100644
--- a/Alc/mixvoice.c
+++ b/Alc/mixvoice.c
@@ -45,7 +45,7 @@
 static_assert((INT_MAX>>FRACTIONBITS)/MAX_PITCH > BUFFERSIZE,
               "MAX_PITCH and/or BUFFERSIZE are too large for FRACTIONBITS!");
 
-extern inline void InitiatePositionArrays(ALsizei frac, ALint increment, ALsizei *restrict frac_arr, ALsizei *restrict pos_arr, ALsizei size);
+extern inline void InitiatePositionArrays(ALsizei frac, ALint increment, ALsizei *RESTRICT frac_arr, ALsizei *RESTRICT pos_arr, ALsizei size);
 
 
 /* BSinc24 requires up to 23 extra samples before the current position, and 24 after. */
@@ -228,7 +228,7 @@ static inline ALfloat Sample_ALalaw(ALalaw val)
 { return aLawDecompressionTable[val] * (1.0f/32768.0f); }
 
 #define DECL_TEMPLATE(T)                                                      \
-static inline void Load_##T(ALfloat *restrict dst, const T *restrict src,     \
+static inline void Load_##T(ALfloat *RESTRICT dst, const T *RESTRICT src,     \
                             ALint srcstep, ALsizei samples)                   \
 {                                                                             \
     ALsizei i;                                                                \
@@ -245,7 +245,7 @@ DECL_TEMPLATE(ALalaw)
 
 #undef DECL_TEMPLATE
 
-static void LoadSamples(ALfloat *restrict dst, const ALvoid *restrict src, ALint srcstep,
+static void LoadSamples(ALfloat *RESTRICT dst, const ALvoid *RESTRICT src, ALint srcstep,
                         enum FmtType srctype, ALsizei samples)
 {
 #define HANDLE_FMT(ET, ST) case ET: Load_##ST(dst, src, srcstep, samples); break
@@ -263,7 +263,7 @@ static void LoadSamples(ALfloat *restrict dst, const ALvoid *restrict src, ALint
 
 
 static const ALfloat *DoFilters(BiquadFilter *lpfilter, BiquadFilter *hpfilter,
-                                ALfloat *restrict dst, const ALfloat *restrict src,
+                                ALfloat *RESTRICT dst, const ALfloat *RESTRICT src,
                                 ALsizei numsamples, enum ActiveFilters type)
 {
     ALsizei i;
diff --git a/Alc/panning.c b/Alc/panning.c
index 79627e78..4328b30f 100644
--- a/Alc/panning.c
+++ b/Alc/panning.c
@@ -41,7 +41,7 @@
 extern inline void CalcDirectionCoeffs(const ALfloat dir[3], ALfloat spread, ALfloat coeffs[MAX_AMBI_COEFFS]);
 extern inline void CalcAngleCoeffs(ALfloat azimuth, ALfloat elevation, ALfloat spread, ALfloat coeffs[MAX_AMBI_COEFFS]);
 extern inline float ScaleAzimuthFront(float azimuth, float scale);
-extern inline void ComputePanGains(const MixParams *dry, const ALfloat*restrict coeffs, ALfloat ingain, ALfloat gains[MAX_OUTPUT_CHANNELS]);
+extern inline void ComputePanGains(const MixParams *dry, const ALfloat*RESTRICT coeffs, ALfloat ingain, ALfloat gains[MAX_OUTPUT_CHANNELS]);
 
 
 static const ALsizei FuMa2ACN[MAX_AMBI_COEFFS] = {
@@ -151,7 +151,7 @@ void CalcAmbiCoeffs(const ALfloat y, const ALfloat z, const ALfloat x, const ALf
 }
 
 
-void ComputePanningGainsMC(const ChannelConfig *chancoeffs, ALsizei numchans, ALsizei numcoeffs, const ALfloat*restrict coeffs, ALfloat ingain, ALfloat gains[MAX_OUTPUT_CHANNELS])
+void ComputePanningGainsMC(const ChannelConfig *chancoeffs, ALsizei numchans, ALsizei numcoeffs, const ALfloat*RESTRICT coeffs, ALfloat ingain, ALfloat gains[MAX_OUTPUT_CHANNELS])
 {
     ALsizei i, j;
 
@@ -166,7 +166,7 @@ void ComputePanningGainsMC(const ChannelConfig *chancoeffs, ALsizei numchans, AL
         gains[i] = 0.0f;
 }
 
-void ComputePanningGainsBF(const BFChannelConfig *chanmap, ALsizei numchans, const ALfloat*restrict coeffs, ALfloat ingain, ALfloat gains[MAX_OUTPUT_CHANNELS])
+void ComputePanningGainsBF(const BFChannelConfig *chanmap, ALsizei numchans, const ALfloat*RESTRICT coeffs, ALfloat ingain, ALfloat gains[MAX_OUTPUT_CHANNELS])
 {
     ALsizei i;
 
@@ -381,7 +381,7 @@ static const ChannelMap MonoCfg[1] = {
 };
 
 static void InitNearFieldCtrl(ALCdevice *device, ALfloat ctrl_dist, ALsizei order,
-                              const ALsizei *restrict chans_per_order)
+                              const ALsizei *RESTRICT chans_per_order)
 {
     const char *devname = alstr_get_cstr(device->DeviceName);
     ALsizei i;
@@ -845,8 +845,8 @@ static void InitHrtfPanning(ALCdevice *device)
     };
     static const ALsizei IndexMap[6] = { 0, 1, 2, 3, 4, 8 };
     static const ALsizei ChansPerOrder[MAX_AMBI_ORDER+1] = { 1, 3, 2, 0 };
-    const ALfloat (*restrict AmbiMatrix)[MAX_AMBI_COEFFS] = AmbiMatrixFOA;
-    const ALfloat *restrict AmbiOrderHFGain = AmbiOrderHFGainFOA;
+    const ALfloat (*RESTRICT AmbiMatrix)[MAX_AMBI_COEFFS] = AmbiMatrixFOA;
+    const ALfloat *RESTRICT AmbiOrderHFGain = AmbiOrderHFGainFOA;
     ALsizei count = 4;
     ALsizei i;
 
diff --git a/Alc/uhjfilter.c b/Alc/uhjfilter.c
index 42b0bc40..6ee6fdb0 100644
--- a/Alc/uhjfilter.c
+++ b/Alc/uhjfilter.c
@@ -16,7 +16,7 @@ static const ALfloat Filter2CoeffSqr[4] = {
     0.161758498368f, 0.733028932341f, 0.945349700329f, 0.990599156685f
 };
 
-static void allpass_process(AllPassState *state, ALfloat *restrict dst, const ALfloat *restrict src, const ALfloat aa, ALsizei todo)
+static void allpass_process(AllPassState *state, ALfloat *RESTRICT dst, const ALfloat *RESTRICT src, const ALfloat aa, ALsizei todo)
 {
     ALfloat z1 = state->z[0];
     ALfloat z2 = state->z[1];
@@ -55,7 +55,7 @@ static void allpass_process(AllPassState *state, ALfloat *restrict dst, const AL
  * know which is the intended result.
  */
 
-void EncodeUhj2(Uhj2Encoder *enc, ALfloat *restrict LeftOut, ALfloat *restrict RightOut, ALfloat (*restrict InSamples)[BUFFERSIZE], ALsizei SamplesToDo)
+void EncodeUhj2(Uhj2Encoder *enc, ALfloat *RESTRICT LeftOut, ALfloat *RESTRICT RightOut, ALfloat (*RESTRICT InSamples)[BUFFERSIZE], ALsizei SamplesToDo)
 {
     ALfloat D[MAX_UPDATE_SAMPLES], S[MAX_UPDATE_SAMPLES];
     ALfloat temp[2][MAX_UPDATE_SAMPLES];
diff --git a/Alc/uhjfilter.h b/Alc/uhjfilter.h
index e773e0a7..9ea1fb44 100644
--- a/Alc/uhjfilter.h
+++ b/Alc/uhjfilter.h
@@ -44,6 +44,6 @@ typedef struct Uhj2Encoder {
 /* Encodes a 2-channel UHJ (stereo-compatible) signal from a B-Format input
  * signal. The input must use FuMa channel ordering and scaling.
  */
-void EncodeUhj2(Uhj2Encoder *enc, ALfloat *restrict LeftOut, ALfloat *restrict RightOut, ALfloat (*restrict InSamples)[BUFFERSIZE], ALsizei SamplesToDo);
+void EncodeUhj2(Uhj2Encoder *enc, ALfloat *RESTRICT LeftOut, ALfloat *RESTRICT RightOut, ALfloat (*RESTRICT InSamples)[BUFFERSIZE], ALsizei SamplesToDo);
 
 #endif /* UHJFILTER_H */
diff --git a/OpenAL32/Include/alAuxEffectSlot.h b/OpenAL32/Include/alAuxEffectSlot.h
index 03ee97d6..97a3906d 100644
--- a/OpenAL32/Include/alAuxEffectSlot.h
+++ b/OpenAL32/Include/alAuxEffectSlot.h
@@ -30,7 +30,7 @@ struct ALeffectStateVtable {
 
     ALboolean (*const deviceUpdate)(ALeffectState *state, ALCdevice *device);
     void (*const update)(ALeffectState *state, const ALCcontext *context, const struct ALeffectslot *slot, const union ALeffectProps *props);
-    void (*const process)(ALeffectState *state, ALsizei samplesToDo, const ALfloat (*restrict samplesIn)[BUFFERSIZE], ALfloat (*restrict samplesOut)[BUFFERSIZE], ALsizei numChannels);
+    void (*const process)(ALeffectState *state, ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], ALsizei numChannels);
 
     void (*const Delete)(void *ptr);
 };
@@ -44,7 +44,7 @@ typedef ALfloat ALfloatBUFFERSIZE[BUFFERSIZE];
 DECLARE_THUNK(T, ALeffectState, void, Destruct)                               \
 DECLARE_THUNK1(T, ALeffectState, ALboolean, deviceUpdate, ALCdevice*)         \
 DECLARE_THUNK3(T, ALeffectState, void, update, const ALCcontext*, const ALeffectslot*, const ALeffectProps*) \
-DECLARE_THUNK4(T, ALeffectState, void, process, ALsizei, const ALfloatBUFFERSIZE*restrict, ALfloatBUFFERSIZE*restrict, ALsizei) \
+DECLARE_THUNK4(T, ALeffectState, void, process, ALsizei, const ALfloatBUFFERSIZE*RESTRICT, ALfloatBUFFERSIZE*RESTRICT, ALsizei) \
 static void T##_ALeffectState_Delete(void *ptr)                               \
 { return T##_Delete(STATIC_UPCAST(T, ALeffectState, (ALeffectState*)ptr)); }  \
                                                                               \
diff --git a/OpenAL32/Include/bs2b.h b/OpenAL32/Include/bs2b.h
index e845d906..13cdf9a6 100644
--- a/OpenAL32/Include/bs2b.h
+++ b/OpenAL32/Include/bs2b.h
@@ -85,7 +85,7 @@ int bs2b_get_srate(struct bs2b *bs2b);
 /* Clear buffer */
 void bs2b_clear(struct bs2b *bs2b);
 
-void bs2b_cross_feed(struct bs2b *bs2b, float *restrict Left, float *restrict Right, int SamplesToDo);
+void bs2b_cross_feed(struct bs2b *bs2b, float *RESTRICT Left, float *RESTRICT Right, int SamplesToDo);
 
 #ifdef __cplusplus
 }    /* extern "C" */
diff --git a/utils/makehrtf.c b/utils/makehrtf.c
index 0bd36849..eb174c8a 100644
--- a/utils/makehrtf.c
+++ b/utils/makehrtf.c
@@ -945,7 +945,7 @@ static inline uint dither_rng(uint *seed)
 
 // Performs a triangular probability density function dither. The input samples
 // should be normalized (-1 to +1).
-static void TpdfDither(double *restrict out, const double *restrict in, const double scale,
+static void TpdfDither(double *RESTRICT out, const double *RESTRICT in, const double scale,
                        const int count, const int step, uint *seed)
 {
     static const double PRNG_SCALE = 1.0 / UINT_MAX;