fix: restore Linux link of FFT_CPU<float> and harden parse_expression

Two issues from code review of the Windows-port commits:

1. FFT_CPU<float> undefined references on Linux (regression). The port removed
   __attribute__((weak)) from the FFT virtuals (it left null vtable slots on
   PE/MinGW and crashed). But the real FFT_CPU<float> methods live in
   fft_cpu_float.cpp, which is compiled only when ENABLE_FLOAT_FFTW=ON. With
   weak gone and float off (the Linux default), the FFT_CPU<float> vtable --
   still emitted wherever the class is constructed (FFT_Bundle) -- referenced
   undefined symbols:
     undefined reference to `ModuleBase::FFT_CPU<float>::setupFFT()' ...
   Provide trivial FFT_CPU<float> method definitions in the always-compiled
   fft_cpu.cpp, guarded by `#if !defined(__ENABLE_FLOAT_FFTW)`, so every vtable
   slot is valid on any ABI without weak and without pulling in libfftw3f. The
   float CPU path stays unreachable at runtime (FFT_Bundle::setupFFT
   WARNING_QUITs for single/mixing CPU FFT unless the macro is set). When the
   macro is on, the stubs are excluded and fft_cpu_float.cpp supplies the real
   definitions -- no duplicate symbols. Verified by linking the float vtable TU
   against fft_cpu.o in both macro states (off: links via stubs; on: links via
   fft_cpu_float.o), and that dropping both reproduces the reported errors.

2. parse_expression (input_conv.h) could push indeterminate values into vec.
   If std::regex_search found no match, sub_str stayed empty and was parsed
   anyway; in the non-multiplication branch `T occ` was uninitialized and the
   `convert >> occ` extraction was unchecked. Now: a no-match token is an input
   error (WARNING_QUIT), occ is value-initialized, and a failed extraction
   fails fast. Consistent with the other expression parsers.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: ErjieWu

source/source_base/module_fft/fft_cpu.cpp

@@ -508,13 +508,38 @@ void FFT_CPU<double>::fftxyc2r(std::complex<double> *in,double *out) const
     }
 }
 
-template <> double* 
+template <> double*
 FFT_CPU<double>::get_rspace_data() const {return d_rspace;}
-template <> std::complex<double>* 
+template <> std::complex<double>*
 FFT_CPU<double>::get_auxr_data()   const {return z_auxr;}
-template <> std::complex<double>* 
+template <> std::complex<double>*
 FFT_CPU<double>::get_auxg_data()   const {return z_auxg;}
 
+#if !defined(__ENABLE_FLOAT_FFTW)
+// When single-precision FFTW is disabled, the real FFT_CPU<float> methods
+// (in fft_cpu_float.cpp) are not compiled -- but the FFT_CPU<float> vtable is
+// still emitted wherever the class is constructed (e.g. FFT_Bundle::setupFFT,
+// and the explicit ctor/dtor instantiations below). Provide trivial
+// definitions so every vtable slot is valid on any linker/ABI. This replaces
+// the former __attribute__((weak)) declarations, which relied on the ELF
+// linker resolving undefined weak symbols to null -- a behaviour PE/MinGW does
+// not share (it left null vtable slots and crashed on first dispatch). The
+// float CPU path is never taken at runtime without __ENABLE_FLOAT_FFTW:
+// FFT_Bundle::setupFFT calls WARNING_QUIT for a single/mixing CPU FFT first.
+template <> void FFT_CPU<float>::setupFFT() {}
+template <> void FFT_CPU<float>::cleanFFT() {}
+template <> void FFT_CPU<float>::clear() {}
+template <> float* FFT_CPU<float>::get_rspace_data() const { return nullptr; }
+template <> std::complex<float>* FFT_CPU<float>::get_auxr_data() const { return nullptr; }
+template <> std::complex<float>* FFT_CPU<float>::get_auxg_data() const { return nullptr; }
+template <> void FFT_CPU<float>::fftxyfor(std::complex<float>*, std::complex<float>*) const {}
+template <> void FFT_CPU<float>::fftxybac(std::complex<float>*, std::complex<float>*) const {}
+template <> void FFT_CPU<float>::fftzfor(std::complex<float>*, std::complex<float>*) const {}
+template <> void FFT_CPU<float>::fftzbac(std::complex<float>*, std::complex<float>*) const {}
+template <> void FFT_CPU<float>::fftxyr2c(float*, std::complex<float>*) const {}
+template <> void FFT_CPU<float>::fftxyc2r(std::complex<float>*, float*) const {}
+#endif
+
 template FFT_CPU<float>::FFT_CPU();
 template FFT_CPU<float>::~FFT_CPU();
 template FFT_CPU<double>::FFT_CPU();

source/source_io/module_parameter/input_conv.h

@@ -91,13 +91,22 @@ void parse_expression(const std::string& fn, std::vector<T>& vec)
             sub_str = match[0].str();
         }
 
+        // A token that matches nothing is invalid input. Fail fast instead of
+        // feeding an empty string to the parsers below, which would push an
+        // indeterminate value into vec.
+        if (sub_str.empty())
+        {
+            ModuleBase::WARNING_QUIT("Input_Conv::parse_expression",
+                                     "invalid token in expression: \"" + str[i] + "\"");
+        }
+
         // Check if the substring contains multiplication (e.g., "2*3.14")
         if (sub_str.find('*') != std::string::npos)
         {
             size_t pos = sub_str.find("*");
             int num = stoi(sub_str.substr(0, pos));
             assert(num >= 0);
-            T occ = stof(sub_str.substr(pos + 1, sub_str.size()));
+            T occ = static_cast<T>(stof(sub_str.substr(pos + 1, sub_str.size())));
 
             // Add the value to the vector `num` times
             for (size_t k = 0; k != num; k++)
@@ -107,11 +116,17 @@ void parse_expression(const std::string& fn, std::vector<T>& vec)
         }
         else
         {
-            // Handle scientific notation and convert to T
+            // Handle scientific notation and convert to T. Initialize occ and
+            // check the extraction so a malformed token fails fast rather than
+            // pushing an indeterminate value.
             std::stringstream convert;
             convert << sub_str;
-            T occ;
-            convert >> occ;
+            T occ{};
+            if (!(convert >> occ))
+            {
+                ModuleBase::WARNING_QUIT("Input_Conv::parse_expression",
+                                         "failed to parse number: \"" + sub_str + "\"");
+            }
             vec.emplace_back(occ);
         }
     }