[C++] проблемы при сборке octave-forge-communications

template <class T>
inline bool
mx_inline_all_finite (size_t n, const T* x)  throw ()
{
  for (size_t i = 0; i < n; i++)
    {
      if (! xfinite (x[i]))
        return false;
    }

  return true;
}

template <class ArrayType, class T>
inline ArrayType
do_mx_red_op (const Array<T>& src, int dim,
              void (*mx_red_op) (const T *, typename ArrayType::element_type *,
                                 octave_idx_type, octave_idx_type, octave_idx_type))
{
  octave_idx_type l, n, u;
  dim_vector dims = src.dims ();
  // M*b inconsistency: sum([]) = 0 etc.
  if (dims.length () == 2 && dims(0) == 0 && dims(1) == 0)
    dims (1) = 1;

  get_extent_triplet (dims, dim, l, n, u);

  // Reduction operation reduces the array size.
  if (dim < dims.length ()) dims(dim) = 1;
  dims.chop_trailing_singletons ();

  ArrayType ret (dims);
  mx_red_op (src.data (), ret.fortran_vec (), l, n, u);

  return ret;
}

grep mx_inline_all mx-inlines-3.4.0.cc 
mx_inline_all_finite (size_t n, const T* x)  throw ()
mx_inline_all_real (size_t n, const std::complex<T>* x) throw ()
OP_RED_FCN (mx_inline_all, T, bool, OP_RED_ALLC, true)
OP_RED_FCN2 (mx_inline_all_r, T, bool, OP_RED_ALLR, true)
OP_ROW_SHORT_CIRCUIT (mx_inline_all, xis_false, true)
OP_RED_FCNN (mx_inline_all, T, bool)

#define OP_RED_FCN(F, TSRC, TRES, OP, ZERO) \
template <class T> \
inline TRES \
F (const TSRC* v, octave_idx_type n) \
{ \
  TRES ac = ZERO; \
  for (octave_idx_type i = 0; i < n; i++) \
    OP(ac, v[i]); \
  return ac; \
}

#define OP_RED_FCN2(F, TSRC, TRES, OP, ZERO) \
template <class T> \
inline void \
F (const TSRC* v, TRES *r, octave_idx_type m, octave_idx_type n) \
{ \
  for (octave_idx_type i = 0; i < m; i++) \
    r[i] = ZERO; \
  for (octave_idx_type j = 0; j < n; j++) \
    { \
      for (octave_idx_type i = 0; i < m; i++) \
        OP(r[i], v[i]); \
      v += m; \
    } \
}

#define OP_ROW_SHORT_CIRCUIT(F, PRED, ZERO) \
template <class T> \
inline void \
F (const T* v, bool *r, octave_idx_type m, octave_idx_type n) \
{ \
  if (n <= 8) \
    return F ## _r (v, r, m, n); \
  \
  /* FIXME: it may be sub-optimal to allocate the buffer here. */ \
  OCTAVE_LOCAL_BUFFER (octave_idx_type, iact, m); \
  for (octave_idx_type i = 0; i < m; i++) iact[i] = i; \
  octave_idx_type nact = m; \
  for (octave_idx_type j = 0; j < n; j++) \
    { \
      octave_idx_type k = 0; \
      for (octave_idx_type i = 0; i < nact; i++) \
        { \
          octave_idx_type ia = iact[i]; \
          if (! PRED (v[ia])) \
            iact[k++] = ia; \
        } \
      nact = k; \
      v += m; \
    } \
  for (octave_idx_type i = 0; i < m; i++) r[i] = ! ZERO; \
  for (octave_idx_type i = 0; i < nact; i++) r[iact[i]] = ZERO; \
}

#define OP_RED_FCNN(F, TSRC, TRES) \
template <class T> \
inline void \
F (const TSRC *v, TRES *r, octave_idx_type l, \
   octave_idx_type n, octave_idx_type u) \
{ \
  if (l == 1) \
    { \
      for (octave_idx_type i = 0; i < u; i++) \
        { \
          r[i] = F<T> (v, n); \
          v += n; \
        } \
    } \
  else \
    { \
      for (octave_idx_type i = 0; i < u; i++) \
        { \
          F (v, r, l, n); \
          v += l*n; \
          r += l; \
        } \
    } \
}

template <class T> mx_inline_all (const T* v, octave_idx_type n);
template <class T> mx_inline_all (const T* v, bool *r, octave_idx_type m, octave_idx_type n);
template <class T> mx_inline_all (const T* v, bool *r, octave_idx_type m, octave_idx_type n);
template <class T> mx_inline_all (const T* v, bool *r, octave_idx_type l, octave_idx_type n, octave_idx_type u);

boolMatrix
galois::all (int dim) const
{
  return do_mx_red_op<boolMatrix> (*this, dim, mx_inline_all);
}

#include <vector>
#include <iostream>

template <class T>
inline bool func(const int*, int)
{
  return true;
}

template <class T>
inline void func(const int *, int *, int, int, int) {
}
  
template <class R, class T>
inline std::vector<R>
do_mx_red_op (const std::vector<T>& src, int dim,
              void (*mx_red_op) (const T*, R*, int,
                                 int, int))
{
  return std::vector<R>();
}

int main() {
  std::vector<int> v;
  
  std::vector<int> res = do_mx_red_op<int>(v, 5, func<int>);

  return 0;
}

boolMatrix
galois::all (int dim) const
{
  return do_mx_red_op<bool> (*this, dim, mx_inline_all);
}