Format script improvements and use strict name checks (zeldaret#1275)

* Prioritize using clang-tidy 6 and improve format.sh

* Use clang-tidy-6.0 when available since it's better at applying 'readability-inconsistent-declaration-parameter-name'
* Add -m32 and -Wno-everything to compiler options to avoid unwanted errors and warnings
* Remove -fsyntax-only since it serves no purpose in the context of clang-tidy

* Apply clang-tidy fixes for argument names

* Run format.sh again

* Use 'Strict' option instead of relying on clang-tidy 6

* Run format script

* Add --fix-notes to clang-tidy options for version 13+

Author: Roman971

.clang-tidy

@@ -3,3 +3,7 @@ WarningsAsErrors: ''
 HeaderFilterRegex: '(src|include)\/.*\.h$'
 FormatStyle: 'file'
 CheckOptions:
+  # Require argument names to match exactly (instead of allowing a name to be a prefix/suffix of another)
+  # Note: 'true' is expected by clang-tidy 12+ but '1' is used for compatibility with older versions
+  - key: readability-inconsistent-declaration-parameter-name.Strict
+    value: 1

assets/xml/textures/backgrounds.xml

@@ -243,4 +243,4 @@
         <Texture Name="gZoraShopBg2TLUT" OutName="zora_shop_tlut2" Format="rgba16" Width="16" Height="16" Offset="0x200"/>
     </File>
 
-</Root>
+</Root>

format.sh

@@ -1,9 +1,20 @@
 #!/usr/bin/env bash
 
+# Clang-Format version and options (see .clang-format for rules applied)
+# Version 11 is used when available for more consistency between contributors
 FORMAT_VER="11"
 FORMAT_OPTS="-i -style=file"
+
+# Clang-Tidy options (see .clang-tidy for checks enabled)
 TIDY_OPTS="-p . --fix --fix-errors"
-COMPILER_OPTS="-fno-builtin -fsyntax-only -std=gnu90 -Iinclude -Isrc -Ibuild -I. -D_LANGUAGE_C -DNON_MATCHING"
+
+# Compiler options used with Clang-Tidy
+# Normal warnings are disabled with -Wno-everything to focus only on tidying
+INCLUDES="-Iinclude -Isrc -Ibuild -I."
+DEFINES="-D_LANGUAGE_C -DNON_MATCHING"
+COMPILER_OPTS="-fno-builtin -std=gnu90 -m32 -Wno-everything ${INCLUDES} ${DEFINES}"
+
+TIDY_VERSION_REGEX="LLVM version ([0-9]+)"
 
 # https://backreference.org/2010/05/23/sanitizing-files-with-no-trailing-newline/index.html
 # "gets the last character of the file pipes it into read, which will exit with
@@ -34,18 +45,28 @@ else
     fi
 fi
 
-if [ ! $(command -v clang-tidy) ]
+if [ $(command -v clang-tidy) ]
 then
+    CLANG_TIDY="clang-tidy"
+else
     echo "clang-tidy not found. Exiting."
     exit 1
 fi
 
+# Try to detect the clang-tidy version and add --fix-notes for version 13+
+# This is used to ensure all fixes are applied properly in recent versions
+if [[ $(${CLANG_TIDY} --version) =~ $TIDY_VERSION_REGEX ]]; then
+    if (( ${BASH_REMATCH[1]} >= 13 )); then
+        TIDY_OPTS="${TIDY_OPTS} --fix-notes"
+    fi
+fi
+
 if (( $# > 0 )); then
     echo "Formatting file(s) $*"
     echo "Running clang-format..."
     ${CLANG_FORMAT} ${FORMAT_OPTS} "$@"
     echo "Running clang-tidy..."
-    clang-tidy ${TIDY_OPTS} "$@" -- ${COMPILER_OPTS} &> /dev/null
+    ${CLANG_TIDY} ${TIDY_OPTS} "$@" -- ${COMPILER_OPTS} &> /dev/null
     echo "Adding missing final new lines..."
     add_final_newline "$@"
     echo "Done formatting file(s) $*"
@@ -56,7 +77,7 @@ echo "Formatting C files. This will take a bit"
 echo "Running clang-format..."
 ${CLANG_FORMAT} ${FORMAT_OPTS} src/**/*.c
 echo "Running clang-tidy..."
-clang-tidy ${TIDY_OPTS} src/**/*.c -- ${COMPILER_OPTS} &> /dev/null
+${CLANG_TIDY} ${TIDY_OPTS} src/**/*.c -- ${COMPILER_OPTS} &> /dev/null
 echo "Adding missing final new lines..."
 find src/ -type f -name "*.c" -exec bash -c 'add_final_newline "$@"' bash {} +
 find assets/xml/ -type f -name "*.xml" -exec bash -c 'add_final_newline "$@"' bash {} +

include/functions.h

@@ -795,7 +795,7 @@ void CollisionCheck_SpawnRedBlood(PlayState* play, Vec3f* v);
 void CollisionCheck_SpawnWaterDroplets(PlayState* play, Vec3f* v);
 void CollisionCheck_SpawnShieldParticles(PlayState* play, Vec3f* v);
 void CollisionCheck_SpawnShieldParticlesMetal(PlayState* play, Vec3f* v);
-void CollisionCheck_SpawnShieldParticlesMetalSound(PlayState* play, Vec3f* v, Vec3f* actorPos);
+void CollisionCheck_SpawnShieldParticlesMetalSound(PlayState* play, Vec3f* v, Vec3f* pos);
 void CollisionCheck_SpawnShieldParticlesMetal2(PlayState* play, Vec3f* v);
 void CollisionCheck_SpawnShieldParticlesWood(PlayState* play, Vec3f* v, Vec3f* actorPos);
 s32 CollisionCheck_CylSideVsLineSeg(f32 radius, f32 height, f32 offset, Vec3f* actorPos, Vec3f* itemPos,
@@ -842,7 +842,7 @@ void func_8006D0EC(PlayState* play, Player* player);
 void func_8006D684(PlayState* play, Player* player);
 void func_8006DC68(PlayState* play, Player* player);
 void func_8006DD9C(Actor* actor, Vec3f* arg1, s16 arg2);
-s32 Jpeg_Decode(void* data, void* zbuffer, void* workBuff, u32 workSize);
+s32 Jpeg_Decode(void* data, void* zbuffer, void* work, u32 workSize);
 void KaleidoSetup_Update(PlayState* play);
 void KaleidoSetup_Init(PlayState* play);
 void KaleidoSetup_Destroy(PlayState* play);
@@ -853,7 +853,7 @@ void Font_LoadOrderedFont(Font* font);
 s32 Environment_ZBufValToFixedPoint(s32 zBufferVal);
 u16 Environment_GetPixelDepth(s32 x, s32 y);
 void Environment_GraphCallback(GraphicsContext* gfxCtx, void* param);
-void Environment_Init(PlayState* play, EnvironmentContext* envCtx, s32 unused);
+void Environment_Init(PlayState* play2, EnvironmentContext* envCtx, s32 unused);
 u8 Environment_SmoothStepToU8(u8* pvalue, u8 target, u8 scale, u8 step, u8 minStep);
 u8 Environment_SmoothStepToS8(s8* pvalue, s8 target, u8 scale, u8 step, u8 minStep);
 f32 Environment_LerpWeight(u16 max, u16 min, u16 val);
@@ -986,8 +986,8 @@ VecSph* OLib_Vec3fToVecSph(VecSph* dest, Vec3f* vec);
 VecSph* OLib_Vec3fToVecSphGeo(VecSph* dest, Vec3f* vec);
 VecSph* OLib_Vec3fDiffToVecSphGeo(VecSph* dest, Vec3f* a, Vec3f* b);
 Vec3f* OLib_Vec3fDiffRad(Vec3f* dest, Vec3f* a, Vec3f* b);
-s16 OnePointCutscene_Init(PlayState* play, s16 csId, s16 timer, Actor* actor, s16 camId);
-s16 OnePointCutscene_EndCutscene(PlayState* play, s16 camId);
+s16 OnePointCutscene_Init(PlayState* play, s16 csId, s16 timer, Actor* actor, s16 parentCamId);
+s16 OnePointCutscene_EndCutscene(PlayState* play, s16 subCamId);
 s32 OnePointCutscene_Attention(PlayState* play, Actor* actor);
 s32 OnePointCutscene_AttentionSetSfx(PlayState* play, Actor* actor, s32 sfxId);
 void OnePointCutscene_EnableAttention(void);
@@ -1099,7 +1099,7 @@ s16 Quake_Callback4(QuakeRequest* req, ShakeInfo* shake);
 s16 Quake_Callback5(QuakeRequest* req, ShakeInfo* shake);
 s16 Quake_Callback6(QuakeRequest* req, ShakeInfo* shake);
 s16 Quake_GetFreeIndex(void);
-QuakeRequest* Quake_AddImpl(Camera* cam, u32 callbackIdx);
+QuakeRequest* Quake_AddImpl(Camera* camera, u32 callbackIdx);
 void Quake_Remove(QuakeRequest* req);
 QuakeRequest* Quake_GetRequest(s16 idx);
 QuakeRequest* Quake_SetValue(s16 idx, s16 valueType, s16 value);
@@ -1109,7 +1109,7 @@ s16 Quake_GetCountdown(s16 idx);
 u32 Quake_SetQuakeValues(s16 idx, s16 y, s16 x, s16 zoom, s16 rotZ);
 u32 Quake_SetUnkValues(s16 idx, s16 arg1, SubQuakeRequest14 arg2);
 void Quake_Init(void);
-s16 Quake_Add(Camera* cam, u32 callbackIdx);
+s16 Quake_Add(Camera* camera, u32 callbackIdx);
 u32 Quake_RemoveFromIdx(s16 idx);
 s16 Quake_Calc(Camera* camera, QuakeCamCalc* camData);
 Gfx* Gfx_SetFog(Gfx* gfx, s32 r, s32 g, s32 b, s32 a, s32 near, s32 far);
@@ -1289,7 +1289,7 @@ s32 Skin_ApplyAnimTransformations(Skin* skin, MtxF* limbMatrices, Actor* actor,
 void SkinMatrix_Vec3fMtxFMultXYZW(MtxF* mf, Vec3f* src, Vec3f* xyzDest, f32* wDest);
 void SkinMatrix_Vec3fMtxFMultXYZ(MtxF* mf, Vec3f* src, Vec3f* dest);
 void SkinMatrix_MtxFMtxFMult(MtxF* mfA, MtxF* mfB, MtxF* dest);
-void SkinMatrix_GetClear(MtxF** mf);
+void SkinMatrix_GetClear(MtxF** mfp);
 void SkinMatrix_MtxFCopy(MtxF* src, MtxF* dest);
 s32 SkinMatrix_Invert(MtxF* src, MtxF* dest);
 void SkinMatrix_SetScale(MtxF* mf, f32 x, f32 y, f32 z);
@@ -1305,10 +1305,10 @@ void Sram_InitNewSave(void);
 void Sram_InitDebugSave(void);
 void Sram_OpenSave(SramContext* sramCtx);
 void Sram_WriteSave(SramContext* sramCtx);
-void Sram_VerifyAndLoadAllSaves(FileChooseContext* fileChoose, SramContext* sramCtx);
-void Sram_InitSave(FileChooseContext* fileChoose, SramContext* sramCtx);
-void Sram_EraseSave(FileChooseContext* fileChoose, SramContext* sramCtx);
-void Sram_CopySave(FileChooseContext* fileChoose, SramContext* sramCtx);
+void Sram_VerifyAndLoadAllSaves(FileChooseContext* fileChooseCtx, SramContext* sramCtx);
+void Sram_InitSave(FileChooseContext* fileChooseCtx, SramContext* sramCtx);
+void Sram_EraseSave(FileChooseContext* fileChooseCtx, SramContext* sramCtx);
+void Sram_CopySave(FileChooseContext* fileChooseCtx, SramContext* sramCtx);
 void Sram_WriteSramHeader(SramContext* sramCtx);
 void Sram_InitSram(GameState* gameState, SramContext* sramCtx);
 void Sram_Alloc(GameState* gameState, SramContext* sramCtx);
@@ -1329,8 +1329,8 @@ void func_800AA178(u32);
 View* View_New(GraphicsContext* gfxCtx);
 void View_Free(View* view);
 void View_Init(View*, GraphicsContext*);
-void View_LookAt(View* view, Vec3f* eye, Vec3f* lookAt, Vec3f* up);
-void View_LookAtUnsafe(View* view, Vec3f* eye, Vec3f* lookAt, Vec3f* up);
+void View_LookAt(View* view, Vec3f* eye, Vec3f* at, Vec3f* up);
+void View_LookAtUnsafe(View* view, Vec3f* eye, Vec3f* at, Vec3f* up);
 void View_SetScale(View* view, f32 scale);
 void View_GetScale(View* view, f32* scale);
 void View_SetPerspective(View* view, f32 fovy, f32 zNear, f32 zFar);
@@ -1350,9 +1350,9 @@ void View_Apply(View* view, s32 mask);
 s32 View_ApplyOrthoToOverlay(View* view);
 s32 View_ApplyPerspectiveToOverlay(View* view);
 s32 View_UpdateViewingMatrix(View* view);
-s32 View_ApplyTo(View* view, s32 mask, Gfx** p);
+s32 View_ApplyTo(View* view, s32 mask, Gfx** gfxp);
 s32 View_ErrorCheckEyePosition(f32 eyeX, f32 eyeY, f32 eyeZ);
-void ViMode_LogPrint(OSViMode* viMode);
+void ViMode_LogPrint(OSViMode* osViMode);
 void ViMode_Configure(ViMode* viMode, s32 mode, s32 type, s32 unk_70, s32 unk_74, s32 unk_78, s32 unk_7C, s32 width,
                       s32 height, s32 unk_left, s32 unk_right, s32 unk_top, s32 unk_bottom);
 void ViMode_Save(ViMode* viMode);
@@ -1382,22 +1382,22 @@ TransitionUnk* TransitionUnk_Init(TransitionUnk* this, s32 row, s32 col);
 void TransitionUnk_SetData(TransitionUnk* this);
 void TransitionUnk_Draw(TransitionUnk* this, Gfx**);
 void func_800B23E8(TransitionUnk* this);
-void TransitionTriforce_Start(void* this);
-void* TransitionTriforce_Init(void* this);
-void TransitionTriforce_Destroy(void* this);
-void TransitionTriforce_Update(void* this, s32 updateRate);
-void TransitionTriforce_SetColor(void* this, u32 color);
-void TransitionTriforce_SetType(void* this, s32 type);
-void TransitionTriforce_Draw(void* this, Gfx** gfxP);
-s32 TransitionTriforce_IsDone(void* this);
-void TransitionWipe_Start(void* this);
-void* TransitionWipe_Init(void* this);
-void TransitionWipe_Destroy(void* this);
-void TransitionWipe_Update(void* this, s32 updateRate);
-void TransitionWipe_Draw(void* this, Gfx** gfxP);
-s32 TransitionWipe_IsDone(void* this);
-void TransitionWipe_SetType(void* this, s32 type);
-void TransitionWipe_SetColor(void* this, u32 color);
+void TransitionTriforce_Start(void* thisx);
+void* TransitionTriforce_Init(void* thisx);
+void TransitionTriforce_Destroy(void* thisx);
+void TransitionTriforce_Update(void* thisx, s32 updateRate);
+void TransitionTriforce_SetColor(void* thisx, u32 color);
+void TransitionTriforce_SetType(void* thisx, s32 type);
+void TransitionTriforce_Draw(void* thisx, Gfx** gfxP);
+s32 TransitionTriforce_IsDone(void* thisx);
+void TransitionWipe_Start(void* thisx);
+void* TransitionWipe_Init(void* thisx);
+void TransitionWipe_Destroy(void* thisx);
+void TransitionWipe_Update(void* thisx, s32 updateRate);
+void TransitionWipe_Draw(void* thisx, Gfx** gfxP);
+s32 TransitionWipe_IsDone(void* thisx);
+void TransitionWipe_SetType(void* thisx, s32 type);
+void TransitionWipe_SetColor(void* thisx, u32 color);
 void TransitionCircle_Start(void* thisx);
 void* TransitionCircle_Init(void* thisx);
 void TransitionCircle_Destroy(void* thisx);
@@ -1406,15 +1406,15 @@ void TransitionCircle_Draw(void* thisx, Gfx** gfxP);
 s32 TransitionCircle_IsDone(void* thisx);
 void TransitionCircle_SetType(void* thisx, s32 type);
 void TransitionCircle_SetColor(void* thisx, u32 color);
-void TransitionCircle_SetUnkColor(void* thisx, u32 color);
-void TransitionFade_Start(void* this);
-void* TransitionFade_Init(void* this);
-void TransitionFade_Destroy(void* this);
-void TransitionFade_Update(void* this, s32 updateRate);
-void TransitionFade_Draw(void* this, Gfx** gfxP);
-s32 TransitionFade_IsDone(void* this);
-void TransitionFade_SetColor(void* this, u32 color);
-void TransitionFade_SetType(void* this, s32 type);
+void TransitionCircle_SetUnkColor(void* thisx, u32 unkColor);
+void TransitionFade_Start(void* thisx);
+void* TransitionFade_Init(void* thisx);
+void TransitionFade_Destroy(void* thisx);
+void TransitionFade_Update(void* thisx, s32 updateRate);
+void TransitionFade_Draw(void* thisx, Gfx** gfxP);
+s32 TransitionFade_IsDone(void* thisx);
+void TransitionFade_SetColor(void* thisx, u32 color);
+void TransitionFade_SetType(void* thisx, s32 type);
 void ShrinkWindow_SetVal(s32 value);
 u32 ShrinkWindow_GetVal(void);
 void ShrinkWindow_SetCurrentVal(s32 currentVal);
@@ -1612,21 +1612,21 @@ void ListAlloc_Free(ListAlloc* this, void* data);
 void ListAlloc_FreeAll(ListAlloc* this);
 void Main_LogSystemHeap(void);
 void Main(void* arg);
-OSMesgQueue* PadMgr_LockSerialMesgQueue(PadMgr* padmgr);
-void PadMgr_UnlockSerialMesgQueue(PadMgr* padmgr, OSMesgQueue* serialEventQueue);
-void PadMgr_LockPadData(PadMgr* padmgr);
-void PadMgr_UnlockPadData(PadMgr* padmgr);
-void PadMgr_RumbleControl(PadMgr* padmgr);
-void PadMgr_RumbleStop(PadMgr* padmgr);
-void PadMgr_RumbleReset(PadMgr* padmgr);
-void PadMgr_RumbleSet(PadMgr* padmgr, u8* ctrlrRumbles);
-void PadMgr_ProcessInputs(PadMgr* padmgr);
-void PadMgr_HandleRetraceMsg(PadMgr* padmgr);
-void PadMgr_HandlePreNMI(PadMgr* padmgr);
+OSMesgQueue* PadMgr_LockSerialMesgQueue(PadMgr* padMgr);
+void PadMgr_UnlockSerialMesgQueue(PadMgr* padMgr, OSMesgQueue* serialEventQueue);
+void PadMgr_LockPadData(PadMgr* padMgr);
+void PadMgr_UnlockPadData(PadMgr* padMgr);
+void PadMgr_RumbleControl(PadMgr* padMgr);
+void PadMgr_RumbleStop(PadMgr* padMgr);
+void PadMgr_RumbleReset(PadMgr* padMgr);
+void PadMgr_RumbleSet(PadMgr* padMgr, u8* ctrlrRumbles);
+void PadMgr_ProcessInputs(PadMgr* padMgr);
+void PadMgr_HandleRetraceMsg(PadMgr* padMgr);
+void PadMgr_HandlePreNMI(PadMgr* padMgr);
 // This function must remain commented out, because it is called incorrectly in
 // fault.c (actual bug in game), and the compiler notices and won't compile it
 // void PadMgr_RequestPadData(PadMgr* padmgr, Input* inputs, s32 mode);
-void PadMgr_Init(PadMgr* padmgr, OSMesgQueue* serialEventQueue, IrqMgr* irqMgr, OSId id, OSPri priority, void* stack);
+void PadMgr_Init(PadMgr* padMgr, OSMesgQueue* serialEventQueue, IrqMgr* irqMgr, OSId id, OSPri priority, void* stack);
 void SpeedMeter_InitImpl(SpeedMeter* this, u32 arg1, u32 y);
 void SpeedMeter_Init(SpeedMeter* this);
 void SpeedMeter_Destroy(SpeedMeter* this);
@@ -1875,7 +1875,7 @@ Note* Audio_AllocNote(SequenceLayer* layer);
 void Audio_NoteInitAll(void);
 void Audio_SequenceChannelProcessSound(SequenceChannel* channel, s32 recalculateVolume, s32 applyBend);
 void Audio_SequencePlayerProcessSound(SequencePlayer* seqPlayer);
-f32 Audio_GetPortamentoFreqScale(Portamento* p);
+f32 Audio_GetPortamentoFreqScale(Portamento* portamento);
 s16 Audio_GetVibratoPitchChange(VibratoState* vib);
 f32 Audio_GetVibratoFreqScale(VibratoState* vib);
 void Audio_NoteVibratoUpdate(Note* note);
@@ -2019,7 +2019,7 @@ void* Overlay_AllocateAndLoad(uintptr_t vRomStart, uintptr_t vRomEnd, void* vRam
 void MtxConv_F2L(Mtx* m1, MtxF* m2);
 void MtxConv_L2F(MtxF* m1, Mtx* m2);
 void Overlay_Relocate(void* allocatedVRamAddress, OverlayRelocationSection* overlayInfo, void* vRamStart);
-s32 Overlay_Load(uintptr_t vRomStart, uintptr_t vRomEnd, void* vRamStart, void* vRamEnd, void* allocatedVRamAddress);
+s32 Overlay_Load(uintptr_t vRomStart, uintptr_t vRomEnd, void* vRamStart, void* vRamEnd, void* allocatedVRamAddr);
 // ? func_800FC800(?);
 // ? func_800FC83C(?);
 // ? func_800FCAB4(?);
@@ -2195,7 +2195,7 @@ void guPositionF(f32 mf[4][4], f32 rot, f32 pitch, f32 yaw, f32 scale, f32 x, f3
 void guPosition(Mtx*, f32, f32, f32, f32, f32, f32, f32);
 OSYieldResult osSpTaskYielded(OSTask* task);
 void guRotateF(f32 m[4][4], f32 a, f32 x, f32 y, f32 z);
-void guRotate(Mtx*, f32 angle, f32 x, f32 y, f32 z);
+void guRotate(Mtx*, f32 a, f32 x, f32 y, f32 z);
 s32 osAiSetFrequency(u32 frequency);
 OSThread* __osGetActiveQueue(void);
 void guNormalize(f32* x, f32* y, f32* z);
@@ -2207,7 +2207,7 @@ void guOrthoF(f32[4][4], f32, f32, f32, f32, f32, f32, f32);
 void guOrtho(Mtx*, f32, f32, f32, f32, f32, f32, f32);
 f32 cosf(f32);
 s16 coss(u16);
-void osViSetEvent(OSMesgQueue* mq, OSMesg m, u32 retraceCount);
+void osViSetEvent(OSMesgQueue* mq, OSMesg msg, u32 retraceCount);
 s32 osPfsIsPlug(OSMesgQueue* mq, u8* pattern);
 void __osPfsRequestData(u8 poll);
 void __osPfsGetInitData(u8* pattern, OSContStatus* contData);

src/code/audio_heap.c

@@ -1371,7 +1371,7 @@ void AudioHeap_ChangeStorage(StorageChange* change, Sample* sample) {
     }
 }
 
-void AudioHeap_ApplySampleBankCacheInternal(s32 apply, s32 id);
+void AudioHeap_ApplySampleBankCacheInternal(s32 apply, s32 sampleBankId);
 
 void AudioHeap_DiscardSampleBank(s32 sampleBankId) {
     AudioHeap_ApplySampleBankCacheInternal(false, sampleBankId);

src/code/audio_load.c

@@ -27,22 +27,22 @@ typedef struct {
 typedef void SoundFontData;
 
 /* forward declarations */
-s32 AudioLoad_SyncInitSeqPlayerInternal(s32 playerIdx, s32 seqId, s32 skipTicks);
+s32 AudioLoad_SyncInitSeqPlayerInternal(s32 playerIdx, s32 seqId, s32 arg2);
 SoundFontData* AudioLoad_SyncLoadFont(u32 fontId);
 Sample* AudioLoad_GetFontSample(s32 fontId, s32 instId);
 void AudioLoad_ProcessAsyncLoads(s32 resetStatus);
 void AudioLoad_ProcessAsyncLoadUnkMedium(AudioAsyncLoad* asyncLoad, s32 resetStatus);
 void AudioLoad_ProcessAsyncLoad(AudioAsyncLoad* asyncLoad, s32 resetStatus);
 void AudioLoad_RelocateFontAndPreloadSamples(s32 fontId, SoundFontData* fontData, SampleBankRelocInfo* sampleBankReloc,
-                                             s32 async);
+                                             s32 isAsync);
 void AudioLoad_RelocateSample(TunedSample* tunedSample, SoundFontData* fontData, SampleBankRelocInfo* sampleBankReloc);
 void AudioLoad_DiscardFont(s32 fontId);
 u32 AudioLoad_TrySyncLoadSampleBank(u32 sampleBankId, u32* outMedium, s32 noLoad);
-void* AudioLoad_SyncLoad(u32 tableType, u32 tableId, s32* didAllocate);
-u32 AudioLoad_GetRealTableIndex(s32 tableType, u32 tableId);
+void* AudioLoad_SyncLoad(u32 tableType, u32 id, s32* didAllocate);
+u32 AudioLoad_GetRealTableIndex(s32 tableType, u32 id);
 void* AudioLoad_SearchCaches(s32 tableType, s32 id);
 AudioTable* AudioLoad_GetLoadTable(s32 tableType);
-void AudioLoad_SyncDma(u32 devAddr, u8* addr, u32 size, s32 medium);
+void AudioLoad_SyncDma(u32 devAddr, u8* ramAddr, u32 size, s32 medium);
 void AudioLoad_SyncDmaUnkMedium(u32 devAddr, u8* addr, u32 size, s32 unkMediumParam);
 s32 AudioLoad_Dma(OSIoMesg* mesg, u32 priority, s32 direction, u32 devAddr, void* ramAddr, u32 size,
                   OSMesgQueue* reqQueue, s32 medium, const char* dmaFuncType);

src/overlays/actors/ovl_Arrow_Fire/z_arrow_fire.c

@@ -12,7 +12,7 @@
 void ArrowFire_Init(Actor* thisx, PlayState* play);
 void ArrowFire_Destroy(Actor* thisx, PlayState* play);
 void ArrowFire_Update(Actor* thisx, PlayState* play);
-void ArrowFire_Draw(Actor* thisx, PlayState* play);
+void ArrowFire_Draw(Actor* thisx, PlayState* play2);
 
 void ArrowFire_Charge(ArrowFire* this, PlayState* play);
 void ArrowFire_Fly(ArrowFire* this, PlayState* play);

src/overlays/actors/ovl_Bg_Bowl_Wall/z_bg_bowl_wall.c

@@ -15,7 +15,7 @@
 void BgBowlWall_Init(Actor* thisx, PlayState* play);
 void BgBowlWall_Destroy(Actor* thisx, PlayState* play);
 void BgBowlWall_Update(Actor* thisx, PlayState* play);
-void BgBowlWall_Draw(Actor* thisx, PlayState* play);
+void BgBowlWall_Draw(Actor* thisx, PlayState* play2);
 
 void BgBowlWall_SpawnBullseyes(BgBowlWall* this, PlayState* play);
 void BgBowlWall_WaitForHit(BgBowlWall* this, PlayState* play);