ssssh: deal with warnings about integers and unused parameters

include/FluidSCWrapper.hpp

@@ -76,7 +76,7 @@ public:
   }
     
   RealTime()
-    : mControlsIterator{mInBuf + mSpecialIndex + 1,mNumInputs - mSpecialIndex - 1}
+    : mControlsIterator{mInBuf + mSpecialIndex + 1,static_cast<size_t>(static_cast<ptrdiff_t>(mNumInputs) - mSpecialIndex - 1)}
     , mParams{Wrapper::Client::getParameterDescriptors()}
     , mClient{Wrapper::setParams(mParams,mWorld->mVerbosity > 0, mWorld, mControlsIterator,true)}
   {}
@@ -102,19 +102,19 @@ public:
     mAudioInputs.reserve(mClient.audioChannelsIn());
     mOutputs.reserve(std::max(mClient.audioChannelsOut(), mClient.controlChannelsOut()));
 
-    for (size_t i = 0; i < mClient.audioChannelsIn(); ++i)
+    for (int i = 0; i < static_cast<int>(mClient.audioChannelsIn()); ++i)
     {
       mInputConnections.emplace_back(isAudioRateIn(i));
       mAudioInputs.emplace_back(nullptr, 0, 0);
     }
 
-    for (size_t i = 0; i < mClient.audioChannelsOut(); ++i)
+    for (int i = 0; i < static_cast<int>(mClient.audioChannelsOut()); ++i)
     {
       mOutputConnections.emplace_back(true);
       mOutputs.emplace_back(nullptr, 0, 0);
     }
 
-    for (size_t i = 0; i < mClient.controlChannelsOut(); ++i) { mOutputs.emplace_back(nullptr, 0, 0); }
+    for (int i = 0; i < static_cast<int>(mClient.controlChannelsOut()); ++i) { mOutputs.emplace_back(nullptr, 0, 0); }
 
     set_calc_function<RealTime, &RealTime::next>();
     Wrapper::getInterfaceTable()->fClearUnitOutputs(this, 1);
@@ -135,9 +135,9 @@ public:
     }
     for (size_t i = 0; i < mClient.audioChannelsOut(); ++i)
     {
-      if (mOutputConnections[i]) mOutputs[i].reset(out(i), 0, fullBufferSize());
+      if (mOutputConnections[i]) mOutputs[i].reset(out(static_cast<int>(i)), 0, fullBufferSize());
     }
-    for (size_t i = 0; i < mClient.controlChannelsOut(); ++i) { mOutputs[i].reset(out(i), 0, 1); }
+    for (size_t i = 0; i < mClient.controlChannelsOut(); ++i) { mOutputs[i].reset(out(static_cast<int>(i)), 0, 1); }
     mClient.process(mAudioInputs, mOutputs);
   }
 
@@ -202,7 +202,7 @@ public:
     if (msgSize) { args->getb(completionMessage.data(), msgSize); }
 
     world->ft->fDoAsynchronousCommand(world, replyAddr, Wrapper::getName(), w, process, exchangeBuffers, tidyUp, destroy,
-                                      msgSize, completionMessage.data());
+                                      static_cast<int>(msgSize), completionMessage.data());
   }
 
   static bool process(World *world, void *data) { return static_cast<Wrapper *>(data)->process(world); }
@@ -336,16 +336,17 @@ class FluidSCWrapper : public impl::FluidSCWrapperBase<C>
 
     auto fromArgs(World *w, ArgType args, BufferT::type, int)
     {
-      typename LongT::type bufnum = fromArgs(w, args, LongT::type(), -1);
+      typename LongT::type bufnum = static_cast<LongT::type>(fromArgs(w, args, LongT::type(), -1));
       return BufferT::type(bufnum >= 0 ? new SCBufferAdaptor(bufnum, w) : nullptr);
     }
     
     typename T::type operator()(World *w, ArgType args)
     {
       ParamLiteralConvertor<T, argSize> a;
+      using LiteralType = typename ParamLiteralConvertor<T, argSize>::LiteralType;
       
       for (size_t i = 0; i < argSize; i++)
-        a[i] = fromArgs(w, args, a[0], 0);
+        a[i] = static_cast<LiteralType>(fromArgs(w, args, a[0], 0));
       
       return a.value();
     }

include/SCBufferAdaptor.hpp

@@ -25,11 +25,11 @@ struct NRTBuf {
       : mBuffer(b)
   {
   }
-  NRTBuf(World *world, long bufnum, bool rt = false)
+  NRTBuf(World *world, uint32 bufnum, bool rt = false)
       : NRTBuf(rt ? World_GetBuf(world, bufnum)
                   : World_GetNRTBuf(world, bufnum))
   {
-    if (mBuffer && !mBuffer->samplerate)
+    if (mBuffer && !static_cast<bool>(mBuffer->samplerate))
       mBuffer->samplerate = world->mFullRate.mSampleRate;
   }
 
@@ -64,8 +64,8 @@ public:
   SCBufferAdaptor& operator=(SCBufferAdaptor&&) = default;
 
 
-  SCBufferAdaptor(long bufnum,World *world, bool rt = false)
+  SCBufferAdaptor(intptr_t bufnum,World *world, bool rt = false)
-      : NRTBuf(world, bufnum, rt)
+      : NRTBuf(world, static_cast<uint32>(bufnum), rt)
       , mBufnum(bufnum)
       , mWorld(world)
   {
@@ -78,7 +78,7 @@ public:
 
   void assignToRT(World *rtWorld)
   {
-    SndBuf *rtBuf = World_GetBuf(rtWorld, mBufnum);
+    SndBuf *rtBuf = World_GetBuf(rtWorld, static_cast<uint32>(mBufnum));
     *rtBuf        = *mBuffer;
     rtWorld->mSndBufUpdates[mBufnum].writes++;
   }
@@ -130,15 +130,15 @@ public:
 
   size_t numFrames() const override
   {
-    return valid() ? this->mBuffer->frames : 0;
+    return valid() ? static_cast<size_t>(this->mBuffer->frames) : 0u;
   }
 
   size_t numChans() const override
   {
-    return valid() ? this->mBuffer->channels / mRank : 0;
+    return valid() ? static_cast<size_t>(this->mBuffer->channels) / mRank : 0u;
   }
 
-  size_t rank() const override { return valid() ? mRank : 0; }
+  size_t rank() const override { return valid() ? mRank : 0u; }
 
   double sampleRate() const override { return valid() ? mBuffer->samplerate : 0; }
 
@@ -147,17 +147,17 @@ public:
     SndBuf *thisThing = mBuffer;
     mOldData          = thisThing->data;
     mRank             = rank;
-    mWorld->ft->fBufAlloc(mBuffer, channels * rank, frames, sampleRate);
+    mWorld->ft->fBufAlloc(mBuffer, static_cast<int>(channels * rank), static_cast<int>(frames), sampleRate);
   }
 
-  int bufnum() { return mBufnum; }
+  intptr_t bufnum() { return mBufnum; }
   void realTime(bool rt) { mRealTime = rt;  }
 
 protected:
 
   bool  mRealTime{false};
   float *mOldData{0};
-  long   mBufnum;
+  intptr_t   mBufnum;
   World *mWorld;
   size_t mRank{1};
 };