File 0001-Update-deprecated-functions-includes.patch of Package octave-forge-communications

Overview Repositories Revisions Requests Users Attributes Meta

File 0001-Update-deprecated-functions-includes.patch of Package octave-forge-communications

From 85d6f17062b764ad67e8a7a79276d888a572a00e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Stefan=20Br=C3=BCns?= <stefan.bruens@rwth-aachen.de>
Date: Wed, 13 Mar 2019 15:02:20 +0100
Subject: [PATCH] Update deprecated functions / includes

sed -i -e 's#config.h#oct.h#g' -e 's#gripes.h#errwarn.h#' \
       -e 's#empty_arg *(.*, *nr, *nc *)#arg.isempty()#' \
       -e 's#empty_arg *(.*, *nr1, *nc1 *)#args(0).isempty()#' \
       -e 's#gripe_$[^ ]\+$_galois#galois_err_\1#' \
       -e 's#gripe_square_matrix_required *($.*$)#err_square_matrix_required(\1, "arg")#' \
       -e 's#gripe_implicit_conversion#warn_implicit_conversion#' \
       -e 's#gripe_nonconformant#octave::err_nonconformant#' \
       -e 's#gripe_#err_#' *.{h,cc} configure.ac
---
 src/configure.ac   | 22 ++++++------
 src/galois-def.cc  | 30 ++++++++--------
 src/galois-def.h   | 50 +++++++++++++-------------
 src/galois.cc      | 88 +++++++++++++++++++++++-----------------------
 src/galois.h       |  2 +-
 src/galoisfield.cc | 10 +++---
 src/genqamdemod.cc |  2 +-
 src/gf.cc          | 42 +++++++++++-----------
 src/op-gm-gm.cc    |  2 +-
 src/op-gm-m.cc     |  2 +-
 src/op-gm-s.cc     |  2 +-
 src/op-m-gm.cc     |  2 +-
 src/op-s-gm.cc     |  2 +-
 src/ov-galois.cc   | 16 ++++-----
 14 files changed, 136 insertions(+), 136 deletions(-)

diff --git a/src/configure.ac b/src/configure.ac
index 5795a36..022ac4a 100644
--- a/src/configure.ac
+++ b/src/configure.ac
@@ -34,7 +34,7 @@ AC_CACHE_CHECK([for octave_hdf5_id type],
    CXXFLAGS="$CXXFLAGS $comm_CXXFLAGS"
    AC_LANG_PUSH(C++)
    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
-       #include <octave/config.h>
+       #include <octave/oct.h>
        #include <octave/ov-base.h>
        ]], [[
        octave_hdf5_id x;
@@ -48,31 +48,31 @@ if test $comm_cv_octave_hdf5_id_type = yes; then
   PKG_CPPFLAGS="$PKG_CPPFLAGS -DHAVE_OCTAVE_HDF5_ID_TYPE=1"
 fi
 
-AC_CACHE_CHECK([for octave_base_value::gripe_load and octave_base_value::gripe_save],
-  [comm_cv_octave_base_value_gripe_load_save],
+AC_CACHE_CHECK([for octave_base_value::err_load and octave_base_value::err_save],
+  [comm_cv_octave_base_value_err_load_save],
   [comm_save_CPPFLAGS=$CPPFLAGS
    comm_save_CXXFLAGS=$CXXFLAGS
    CPPFLAGS="$CPPFLAGS $HDF5_CPPFLAGS"
    CXXFLAGS="$CXXFLAGS $comm_CXXFLAGS"
    AC_LANG_PUSH(C++)
    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
-       #include <octave/config.h>
+       #include <octave/oct.h>
        #include <octave/ov-base.h>
        class foo : public octave_base_value
        {
        public:
          foo () {}
-         void func () { gripe_load ("func"); gripe_save ("func"); }
+         void func () { err_load ("func"); err_save ("func"); }
        };
        ]], [[
        foo x;
        ]])],
-     [comm_cv_octave_base_value_gripe_load_save=yes],
-     [comm_cv_octave_base_value_gripe_load_save=no])
+     [comm_cv_octave_base_value_err_load_save=yes],
+     [comm_cv_octave_base_value_err_load_save=no])
    AC_LANG_POP(C++)
    CPPFLAGS=$comm_save_CPPFLAGS
    CXXFLAGS=$comm_save_CXXFLAGS])
-if test $comm_cv_octave_base_value_gripe_load_save = yes; then
+if test $comm_cv_octave_base_value_err_load_save = yes; then
   PKG_CPPFLAGS="$PKG_CPPFLAGS -DHAVE_OCTAVE_BASE_VALUE_GRIPE_LOAD_SAVE=1"
 fi
 
@@ -85,7 +85,7 @@ AC_CACHE_CHECK([whether octave_base_value::print is const-qualified],
    AC_LANG_PUSH(C++)
    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
        #include <iostream>
-       #include <octave/config.h>
+       #include <octave/oct.h>
        #include <octave/ov-base.h>
        ]], [[
        const octave_base_value x; x.print (std::cout);
@@ -104,12 +104,12 @@ CXXFLAGS="$CXXFLAGS $comm_CXXFLAGS"
 AC_LANG_PUSH(C++)
 AC_CHECK_HEADER([octave/ls-oct-ascii.h], [PKG_CPPFLAGS="$PKG_CPPFLAGS -DHAVE_OCTAVE_ASCII_H=1"], [], 
 [
-#include <octave/config.h>
+#include <octave/oct.h>
 #incude <octave/ov.h>
 ])
 AC_CHECK_HEADER([octave/ls-oct-text.h], [PKG_CPPFLAGS="$PKG_CPPFLAGS -DHAVE_OCTAVE_TEXT_H=1"], [], 
 [
-#include <octave/config.h>
+#include <octave/oct.h>
 #include <octave/ov.h>
 ])
 AC_LANG_POP(C++)
diff --git a/src/galois-def.cc b/src/galois-def.cc
index d0fc36b..ca9925d 100644
--- a/src/galois-def.cc
+++ b/src/galois-def.cc
@@ -21,7 +21,7 @@
 #include "galois.h"
 
 void
-gripe_nonconformant_galois (const char *op, int op1_m, int op1_primpoly,
+galois_err_nonconformant (const char *op, int op1_m, int op1_primpoly,
                             int op2_m, int op2_primpoly)
 {
   (*current_liboctave_error_handler)
@@ -31,98 +31,98 @@ gripe_nonconformant_galois (const char *op, int op1_m, int op1_primpoly,
 }
 
 void
-gripe_nonconformant_galois (const char *op, int m)
+galois_err_nonconformant (const char *op, int m)
 {
   (*current_liboctave_error_handler)
     ("%s: element exceeds range of galois field GF(2^%d)", op, m);
 }
 
 void
-gripe_divzero_galois (const char *op)
+galois_err_divzero (const char *op)
 {
   (*current_liboctave_error_handler)
     ("%s: division by zero in galois field", op);
 }
 
 void
-gripe_invalid_galois (void)
+galois_err_invalid (void)
 {
   (*current_liboctave_error_handler)
     ("invalid data in Galois Field");
 }
 
 void
-gripe_range_galois (int m)
+galois_err_range (int m)
 {
   (*current_liboctave_error_handler)
     ("data outside range of Galois Field GF(2^%d)", m);
 }
 
 void
-gripe_integer_galois (void)
+galois_err_integer (void)
 {
   (*current_liboctave_error_handler)
     ("data in Galois Field must be integer");
 }
 
 void
-gripe_copy_invalid_galois (void)
+galois_err_copy_invalid (void)
 {
   (*current_liboctave_error_handler)
     ("trying to copy invalid Galois Field");
 }
 
 void
-gripe_differ_galois (void)
+galois_err_differ (void)
 {
   (*current_liboctave_error_handler)
     ("can not assign data between two different Galois Fields");
 }
 
 void
-gripe_invalid_table_galois (void)
+galois_err_invalid_table (void)
 {
   (*current_liboctave_error_handler)
     ("invalid lookup table in Galois Field");
 }
 
 void
-gripe_square_galois (void)
+galois_err_square (void)
 {
   (*current_liboctave_error_handler)
     ("for A^x, A must be square and x scalar");
 }
 
 void
-gripe_integer_power_galois (void)
+galois_err_integer_power (void)
 {
   (*current_liboctave_error_handler)
     ("exponent must be integer for binary operator '^' with galois field");
 }
 
 void
-gripe_order_galois (int m)
+galois_err_order (int m)
 {
   (*current_liboctave_error_handler)
     ("invalid order %d for Galois Field", m);
 }
 
 void
-gripe_degree_galois (int m)
+galois_err_degree (int m)
 {
   (*current_liboctave_error_handler)
     ("invalid degree for primitive polynomial (%d) of Galois Field", m);
 }
 
 void
-gripe_irred_galois (int m)
+galois_err_irred (int m)
 {
   (*current_liboctave_error_handler)
     ("primitive polynomial (%d) of Galois Field must be irreducible", m);
 }
 
 void
-gripe_init_galois (void)
+galois_err_init (void)
 {
   (*current_liboctave_error_handler)
     ("unable to initialize Galois Field");
diff --git a/src/galois-def.h b/src/galois-def.h
index 59d1882..ca508e1 100644
--- a/src/galois-def.h
+++ b/src/galois-def.h
@@ -21,22 +21,22 @@
 #if !defined (octave_galois_defs_h)
 #define octave_galois_defs_h 1
 
-void gripe_nonconformant_galois (const char *op, int op1_m, int op1_primpoly,
+void galois_err_nonconformant (const char *op, int op1_m, int op1_primpoly,
                                  int op2_m, int op2_primpoly);
-void gripe_nonconformant_galois (const char *op, int m);
-void gripe_divzero_galois (const char *op);
-void gripe_invalid_galois (void);
-void gripe_range_galois (int m);
-void gripe_integer_galois (void);
-void gripe_copy_invalid_galois (void);
-void gripe_differ_galois (void);
-void gripe_invalid_table_galois (void);
-void gripe_square_galois (void);
-void gripe_integer_power_galois (void);
-void gripe_order_galois (int m);
-void gripe_degree_galois (int m);
-void gripe_irred_galois (int m);
-void gripe_init_galois (void);
+void galois_err_nonconformant (const char *op, int m);
+void galois_err_divzero (const char *op);
+void galois_err_invalid (void);
+void galois_err_range (int m);
+void galois_err_integer (void);
+void galois_err_copy_invalid (void);
+void galois_err_differ (void);
+void galois_err_invalid_table (void);
+void galois_err_square (void);
+void galois_err_integer_power (void);
+void galois_err_order (int m);
+void galois_err_degree (int m);
+void galois_err_irred (int m);
+void galois_err_init (void);
 
 // Compute X % N, where N is 2^M - 1, without a slow divide
 #define MODN(X, M, N) \
@@ -52,12 +52,12 @@ void gripe_init_galois (void);
   { \
     if (!M1.have_field () || !M2.have_field ()) \
       { \
-        gripe_invalid_galois (); \
+        galois_err_invalid (); \
         return RET (); \
       } \
     if ((M1.primpoly () != M2.primpoly ()) || (M1.m () != M2.m ())) \
       { \
-        gripe_nonconformant_galois (OP, M1.m (), M1.primpoly (), M2.m (), M2.primpoly ()); \
+        galois_err_nonconformant (OP, M1.m (), M1.primpoly (), M2.m (), M2.primpoly ()); \
         return RET (); \
       } \
   }
@@ -69,7 +69,7 @@ void gripe_init_galois (void);
  \
     if (!M1.have_field ()) \
       { \
-        gripe_invalid_galois (); \
+        galois_err_invalid (); \
         return RET (); \
       } \
     for (int i = 0; i < nr; i++) \
@@ -77,12 +77,12 @@ void gripe_init_galois (void);
         { \
           if ((M1(i, j) < 0) || (M1(i, j) > NN)) \
             { \
-              gripe_nonconformant_galois (OP, M1.m ()); \
+              galois_err_nonconformant (OP, M1.m ()); \
               return RET (); \
             } \
           if (((double)M1(i, j) - (double)((int)M1(i, j))) != 0.) \
             { \
-              gripe_nonconformant_galois (OP, M1.m ()); \
+              galois_err_nonconformant (OP, M1.m ()); \
               return RET (); \
             } \
         } \
@@ -98,7 +98,7 @@ void gripe_init_galois (void);
         { \
           if (M(i, j) == 0) \
             { \
-              gripe_divzero_galois (OP); \
+              galois_err_divzero (OP); \
               return RET (); \
             } \
         } \
@@ -137,7 +137,7 @@ void gripe_init_galois (void);
                 r(i, j) = (int)m1(i, j) ^ (int)m2(0, 0); \
           } \
         else \
-          gripe_nonconformant (#OP, m1_nr, m1_nc, m2_nr, m2_nc); \
+          octave::err_nonconformant (#OP, m1_nr, m1_nc, m2_nr, m2_nc); \
       } \
     else \
       { \
@@ -221,7 +221,7 @@ void gripe_init_galois (void);
               } \
           } \
         else \
-          gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
+          octave::err_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
       } \
     else \
       if (m1_nr > 0 && m1_nc > 0) \
@@ -289,7 +289,7 @@ void gripe_init_galois (void);
                 r(i, j) = C1 (m1(i, j)) OP C2 (m2(0, 0)); \
           } \
         else \
-          gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
+          octave::err_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
       } \
  \
     return r; \
@@ -350,7 +350,7 @@ void gripe_init_galois (void);
                   OP (m2(0, 0) != ZERO); \
           } \
         else if ((m1_nr != 0 || m1_nc != 0) && (m2_nr != 0 || m2_nc != 0)) \
-          gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
+          octave::err_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
       } \
  \
     return r; \
diff --git a/src/galois.cc b/src/galois.cc
index 7573474..0fe6427 100644
--- a/src/galois.cc
+++ b/src/galois.cc
@@ -18,9 +18,9 @@
 // program with any Open Source program, as defined by the Open Source
 // Initiative (www.opensource.org)
 
-#include <octave/config.h>
+#include <octave/oct.h>
 #include <octave/error.h>
-#include <octave/gripes.h>
+#include <octave/errwarn.h>
 #include <octave/mx-op-defs.h>
 
 #include "galois.h"
@@ -45,7 +45,7 @@ galois::galois (const Array<int>& a, const int& _m,
         {
           if ((a(i, j) < 0) || (a(i, j) > _n))
             {
-              gripe_range_galois (_m);
+              galois_err_range (_m);
               return;
             }
           xelem(i, j) = (int)a(i, j);
@@ -67,7 +67,7 @@ galois::galois (const MArray<int>& a, const int& _m,
         {
           if ((a(i, j) < 0) || (a(i, j) > _n))
             {
-              gripe_range_galois (_m);
+              galois_err_range (_m);
               return;
             }
           xelem(i, j) = (int)a(i, j);
@@ -89,12 +89,12 @@ galois::galois (const Matrix& a, const int& _m,
         {
           if ((a(i, j) < 0) || (a(i, j) > _n))
             {
-              gripe_range_galois (_m);
+              galois_err_range (_m);
               return;
             }
           if ((a(i, j) - (double)((int)a(i, j))) != 0.)
             {
-              gripe_integer_galois ();
+              galois_err_integer ();
               return;
             }
           xelem(i, j) = (int)a(i, j);
@@ -113,7 +113,7 @@ galois::galois (int nr, int nc, const int& val, const int& _m,
   // Check the validity of the data in the matrix
   if ((val < 0) || (val > _n))
     {
-      gripe_range_galois (_m);
+      galois_err_range (_m);
       return;
     }
 
@@ -129,13 +129,13 @@ galois::galois (int nr, int nc, double val, const int& _m,
   // Check the validity of the data in the matrix
   if ((val < 0) || (val > _n))
     {
-      gripe_range_galois (_m);
+      galois_err_range (_m);
       return;
     }
 
   if ((val - (double)((int)val)) != 0.)
     {
-      gripe_integer_galois ();
+      galois_err_integer ();
       return;
     }
 
@@ -147,7 +147,7 @@ galois::galois (const galois& a) : MArray<int> (a)
 
   if (!a.have_field ())
     {
-      gripe_copy_invalid_galois ();
+      galois_err_copy_invalid ();
       field = NULL;
       return;
     }
@@ -167,7 +167,7 @@ galois::operator = (const galois& t)
 {
   if (!t.have_field ())
     {
-      gripe_copy_invalid_galois ();
+      galois_err_copy_invalid ();
       if (have_field ())
         stored_galois_fields.delete_galois_field (field);
       field = NULL;
@@ -204,19 +204,19 @@ galois::operator += (const galois& a)
     {
       if ((m () != a.m ()) || (primpoly () != a.primpoly ()))
         {
-          gripe_differ_galois ();
+          galois_err_differ ();
           return *this;
         }
     }
   else
     {
-      gripe_invalid_galois ();
+      galois_err_invalid ();
       return *this;
     }
 
   if (nr != a_nr || nc != a_nc)
     {
-      gripe_nonconformant ("operator +=", nr, nc, a_nr, a_nc);
+      octave::err_nonconformant ("operator +=", nr, nc, a_nr, a_nc);
       return *this;
     }
 
@@ -240,19 +240,19 @@ galois::operator -= (const galois& a)
     {
       if ((m () != a.m ()) || (primpoly () != a.primpoly ()))
         {
-          gripe_differ_galois ();
+          galois_err_differ ();
           return *this;
         }
     }
   else
     {
-      gripe_invalid_galois ();
+      galois_err_invalid ();
       return *this;
     }
 
   if (nr != a_nr || nc != a_nc)
     {
-      gripe_nonconformant ("operator -=", nr, nc, a_nr, a_nc);
+      octave::err_nonconformant ("operator -=", nr, nc, a_nr, a_nc);
       return *this;
     }
 
@@ -307,12 +307,12 @@ galois::concat (const Matrix& rb, const Array<int>& ra_idx)
         {
           if ((rb(i, j) < 0) || (rb(i, j) > _n))
             {
-              gripe_range_galois (m ());
+              galois_err_range (m ());
               return *this;
             }
           if ((rb(i, j) - (double)((int)rb(i, j))) != 0.)
             {
-              gripe_integer_galois ();
+              galois_err_integer ();
               return *this;
             }
           tmp(i, j) = (int)rb(i, j);
@@ -345,12 +345,12 @@ concat (const Matrix& ra, const galois& rb,  const Array<int>& ra_idx)
 #if 0
           if ((ra(i, j) < 0) || (ra(i, j) > _n))
             {
-              gripe_range_galois (rb.m ());
+              galois_err_range (rb.m ());
               return retval;
             }
           if ((ra(i, j) - (double)((int)ra(i, j))) != 0.)
             {
-              gripe_integer_galois ();
+              galois_err_integer ();
               return retval;
             }
           retval(i, j) = (int)ra(i, j);
@@ -483,13 +483,13 @@ elem_pow (const galois& a, const galois& b)
     {
       if ((a.m () != b.m ()) || (a.primpoly () != b.primpoly ()))
         {
-          gripe_differ_galois ();
+          galois_err_differ ();
           return galois ();
         }
     }
   else
     {
-      gripe_invalid_galois ();
+      galois_err_invalid ();
       return galois ();
     }
 
@@ -518,7 +518,7 @@ elem_pow (const galois& a, const galois& b)
     {
       if (a_nr != b_nr || a_nc != b_nc)
         {
-          gripe_nonconformant ("operator .^", a_nr, a_nc, a_nr, a_nc);
+          octave::err_nonconformant ("operator .^", a_nr, a_nc, a_nr, a_nc);
           return galois ();
         }
 
@@ -549,7 +549,7 @@ elem_pow (const galois& a, const Matrix& b)
 
   if (a_nr != b_nr || a_nc != b_nc)
     {
-      gripe_nonconformant ("operator .^", a_nr, a_nc, b_nr, b_nc);
+      octave::err_nonconformant ("operator .^", a_nr, a_nc, b_nr, b_nc);
       return galois ();
     }
 
@@ -578,7 +578,7 @@ elem_pow (const galois& a, double b)
 
   if ((double)bi != b)
     {
-      gripe_integer_galois ();
+      galois_err_integer ();
       return galois ();
     }
 
@@ -625,7 +625,7 @@ pow (const galois& a, double b)
   int bi = (int)b;
   if ((double)bi != b)
     {
-      gripe_integer_power_galois ();
+      galois_err_integer_power ();
       return galois ();
     }
 
@@ -642,19 +642,19 @@ pow (const galois& a, const galois& b)
     {
       if ((a.m () != b.m ()) || (a.primpoly () != b.primpoly ()))
         {
-          gripe_differ_galois ();
+          galois_err_differ ();
           return galois ();
         }
     }
   else
     {
-      gripe_invalid_galois ();
+      galois_err_invalid ();
       return galois ();
     }
 
   if (nr != 1 || nc != 1)
     {
-      gripe_square_galois ();
+      galois_err_square ();
       return galois ();
     }
   else
@@ -670,12 +670,12 @@ pow (const galois& a, int b)
 
   if (!a.have_field ())
     {
-      gripe_invalid_galois ();
+      galois_err_invalid ();
       return retval;
     }
 
   if (nr == 0 || nc == 0 || nr != nc)
-    gripe_square_galois ();
+    galois_err_square ();
   else if (b == 0)
     {
       retval = galois (nr, nc, 0, a.m (), a.primpoly ());
@@ -738,13 +738,13 @@ operator * (const galois& a, const galois& b)
     {
       if ((a.m () != b.m ()) || (a.primpoly () != b.primpoly ()))
         {
-          gripe_differ_galois ();
+          galois_err_differ ();
           return galois ();
         }
     }
   else
     {
-      gripe_invalid_galois ();
+      galois_err_invalid ();
       return galois ();
     }
 
@@ -758,7 +758,7 @@ operator * (const galois& a, const galois& b)
     return product (a, b);
   else if (a_nc != b_nr)
     {
-      gripe_nonconformant ("operator *", a_nr, a_nc, b_nr, b_nc);
+      octave::err_nonconformant ("operator *", a_nr, a_nc, b_nr, b_nc);
       return galois ();
     }
   else
@@ -810,7 +810,7 @@ galois::prod (int dim) const
 {
   if (!have_field ())
     {
-      gripe_invalid_galois ();
+      galois_err_invalid ();
       return galois ();
     }
 
@@ -842,7 +842,7 @@ galois::sum (int dim) const
 {
   if (!have_field ())
     {
-      gripe_invalid_galois ();
+      galois_err_invalid ();
       return galois ();
     }
 
@@ -867,7 +867,7 @@ galois::sumsq (int dim) const
 {
   if (!have_field ())
     {
-      gripe_invalid_galois ();
+      galois_err_invalid ();
       return galois ();
     }
 
@@ -914,7 +914,7 @@ galois::log (void) const
   bool warned = false;
   if (!have_field ())
     {
-      gripe_invalid_galois ();
+      galois_err_invalid ();
       return galois ();
     }
 
@@ -949,7 +949,7 @@ galois::exp (void) const
   bool warned = false;
   if (!have_field ())
     {
-      gripe_invalid_galois ();
+      galois_err_invalid ();
       return galois ();
     }
 
@@ -1219,12 +1219,12 @@ galois::solve (const galois& b, int& info,
 
   if (!have_field () || !b.have_field ())
     {
-      gripe_invalid_galois ();
+      galois_err_invalid ();
       return galois ();
     }
   else if ((m () != b.m ()) || (primpoly () != b.primpoly ()))
     {
-      gripe_differ_galois ();
+      galois_err_differ ();
       return galois ();
     }
 
@@ -1420,7 +1420,7 @@ xdiv (const galois& a, const galois& b)
       int a_nr = a.rows ();
       int b_nr = b.rows ();
 
-      gripe_nonconformant ("operator /", a_nr, a_nc, b_nr, b_nc);
+      octave::err_nonconformant ("operator /", a_nr, a_nc, b_nr, b_nc);
       return galois ();
     }
 
@@ -1464,7 +1464,7 @@ xleftdiv (const galois& a, const galois& b)
       int a_nc = a.cols ();
       int b_nc = b.cols ();
 
-      gripe_nonconformant ("operator \\", a_nr, a_nc, b_nr, b_nc);
+      octave::err_nonconformant ("operator \\", a_nr, a_nc, b_nr, b_nc);
       return galois ();
     }
 
diff --git a/src/galois.h b/src/galois.h
index 21f8a85..9ae988b 100644
--- a/src/galois.h
+++ b/src/galois.h
@@ -21,7 +21,7 @@
 #if !defined (octave_galois_int_h)
 #define octave_galois_int_h 1
 
-#include <octave/config.h>
+#include <octave/oct.h>
 #include <octave/mx-base.h>
 
 #include "galoisfield.h"
diff --git a/src/galoisfield.cc b/src/galoisfield.cc
index a1bc7c5..9b91efb 100644
--- a/src/galoisfield.cc
+++ b/src/galoisfield.cc
@@ -48,7 +48,7 @@ galois_field_node::galois_field_node (const int& _m, const int& _primpoly)
   m = _m;
   if ((m < 1) || (m > __OCTAVE_GALOIS_MAX_M))
     {
-      gripe_order_galois (m);
+      galois_err_order (m);
       return;
     }
   n = (1<<m) -1;
@@ -58,7 +58,7 @@ galois_field_node::galois_field_node (const int& _m, const int& _primpoly)
     {
       if ((_primpoly & (0x7FFFFFFF - (1<<(m+1)) + 1)) || !(_primpoly & (1<<m)))
         {
-          gripe_degree_galois (primpoly);
+          galois_err_degree (primpoly);
           return;
         }
       primpoly = _primpoly;
@@ -90,14 +90,14 @@ galois_field_node::galois_field_node (const int& _m, const int& _primpoly)
 
   if (mask != 1)
     {
-      gripe_irred_galois (primpoly);
+      galois_err_irred (primpoly);
       return;
     }
 
   for (int i = 0; i < n+1; i++)
     if (index_of(i) > n)
       {
-        gripe_irred_galois (primpoly);
+        galois_err_irred (primpoly);
         return;
       }
 
@@ -158,7 +158,7 @@ galois_field_list::create_galois_field (const int& m, const int& primpoly)
   ptr = new galois_field_node (m, primpoly);
   if (ptr->count ==  0)
     {
-      gripe_init_galois ();
+      galois_err_init ();
       return ptr;
     }
   if (first)
diff --git a/src/genqamdemod.cc b/src/genqamdemod.cc
index a575145..bd3da34 100644
--- a/src/genqamdemod.cc
+++ b/src/genqamdemod.cc
@@ -36,7 +36,7 @@ constellation mapping specified by the 1D vector @var{C}.\n\
 
   int nr1 (args(0).rows ());
   int nc1 (args(0).columns ());
-  int arg_is_empty1 = empty_arg ("genqamdemod", nr1, nc1);
+  int arg_is_empty1 = args(0).isempty();
   Matrix y (nr1,nc1);
 
   int nr2 (args(1).rows ());
diff --git a/src/gf.cc b/src/gf.cc
index 6874361..27e0c00 100644
--- a/src/gf.cc
+++ b/src/gf.cc
@@ -29,9 +29,9 @@ the website http://www.eccpage.com for more details. Permission has been granted
 for a GPL release of his code
 */
 
-#include <octave/config.h>
+#include <octave/oct.h>
 #include <octave/defun-dld.h>
-#include <octave/gripes.h>
+#include <octave/errwarn.h>
 #include <octave/oct-locbuf.h>
 #include <octave/ov.h>
 #include <octave/utils.h>
@@ -142,7 +142,7 @@ make_gdiag (const octave_value& a, const octave_value& b)
 
   if ((!galois_type_loaded) || (a.type_id () !=
                                 octave_galois::static_type_id ()))
-    gripe_wrong_type_arg ("gdiag", a);
+    err_wrong_type_arg ("gdiag", a);
   else
     {
       galois m = ((const octave_galois&) a.get_rep ()).galois_value ();
@@ -196,7 +196,7 @@ make_gdiag (const octave_value& a, const octave_value& b)
             }
         }
       else
-        gripe_wrong_type_arg ("gdiag", a);
+        err_wrong_type_arg ("gdiag", a);
     }
   return retval;
 }
@@ -302,7 +302,7 @@ matrix must match the total number of elements in the new matrix.\n\
       if ((!galois_type_loaded) || (args(0).type_id () !=
                                     octave_galois::static_type_id ()))
         {
-          gripe_wrong_type_arg ("greshape", args(0));
+          err_wrong_type_arg ("greshape", args(0));
           return retval;
         }
       galois a = ((const octave_galois&) args(0).get_rep ()).galois_value ();
@@ -372,7 +372,7 @@ matrix must match the total number of elements in the new matrix.\n\
                 } \
               else \
                 { \
-                  gripe_wrong_type_arg (#FCN, arg); \
+                  err_wrong_type_arg (#FCN, arg); \
                   return retval; \
                 } \
             } \
@@ -469,7 +469,7 @@ Compute the square root of @var{x}, element by element, in a Galois Field.\n\
   if (!galois_type_loaded || (args(0).type_id () !=
                               octave_galois::static_type_id ()))
     {
-      gripe_wrong_type_arg ("gsqrt", args(0));
+      err_wrong_type_arg ("gsqrt", args(0));
       return retval;
     }
 
@@ -508,7 +508,7 @@ array.\n\
   if (!galois_type_loaded || (args(0).type_id () !=
                               octave_galois::static_type_id ()))
     {
-      gripe_wrong_type_arg ("glog", args(0));
+      err_wrong_type_arg ("glog", args(0));
       return retval;
     }
 
@@ -547,7 +547,7 @@ array.\n\
   if (!galois_type_loaded || (args(0).type_id () !=
                               octave_galois::static_type_id ()))
     {
-      gripe_wrong_type_arg ("gexp", args(0));
+      err_wrong_type_arg ("gexp", args(0));
       return retval;
     }
 
@@ -962,7 +962,7 @@ lower triangular matrix. The matrix @var{a} can be rectangular.\n\
   if (!galois_type_loaded || (arg.type_id () !=
                               octave_galois::static_type_id ()))
     {
-      gripe_wrong_type_arg ("glu", arg);
+      err_wrong_type_arg ("glu", arg);
       return retval;
     }
 
@@ -971,7 +971,7 @@ lower triangular matrix. The matrix @var{a} can be rectangular.\n\
   int nr = arg.rows ();
   int nc = arg.columns ();
 
-  int arg_is_empty = empty_arg ("glu", nr, nc);
+  int arg_is_empty = arg.isempty();
 
   if (arg_is_empty < 0)
     return retval;
@@ -1049,13 +1049,13 @@ ill-conditioned matrix if the reciprocal condition number is small.\n\
   if (!galois_type_loaded || (arg.type_id () !=
                               octave_galois::static_type_id ()))
     {
-      gripe_wrong_type_arg ("ginverse", arg);
+      err_wrong_type_arg ("ginverse", arg);
       return retval;
     }
 
   galois m = ((const octave_galois&) arg.get_rep ()).galois_value ();
 
-  int arg_is_empty = empty_arg ("ginverse", nr, nc);
+  int arg_is_empty = arg.isempty();
 
   if (arg_is_empty < 0)
     return retval;
@@ -1066,7 +1066,7 @@ ill-conditioned matrix if the reciprocal condition number is small.\n\
     }
   if (nr != nc)
     {
-      gripe_square_matrix_required ("ginverse");
+      err_square_matrix_required("ginverse", "arg");
       return retval;
     }
 
@@ -1143,7 +1143,7 @@ Compute the determinant of the Galois array @var{a}.\n\
   if (!galois_type_loaded || (arg.type_id () !=
                               octave_galois::static_type_id ()))
     {
-      gripe_wrong_type_arg ("gdet", arg);
+      err_wrong_type_arg ("gdet", arg);
       return retval;
     }
 
@@ -1152,7 +1152,7 @@ Compute the determinant of the Galois array @var{a}.\n\
 
   galois m = ((const octave_galois&) arg.get_rep ()).galois_value ();
 
-  int arg_is_empty = empty_arg ("gdet", nr, nc);
+  int arg_is_empty = arg.isempty();
 
   if (arg_is_empty < 0)
     return retval;
@@ -1164,7 +1164,7 @@ Compute the determinant of the Galois array @var{a}.\n\
 
   if (nr != nc)
     {
-      gripe_square_matrix_required ("det");
+      err_square_matrix_required("det", "arg");
       return retval;
     }
 
@@ -1203,7 +1203,7 @@ rows and columns.\n\
   if (!galois_type_loaded || (arg.type_id () !=
                               octave_galois::static_type_id ()))
     {
-      gripe_wrong_type_arg ("grank", arg);
+      err_wrong_type_arg ("grank", arg);
       return retval;
     }
 
@@ -1212,7 +1212,7 @@ rows and columns.\n\
 
   galois m = ((const octave_galois&) arg.get_rep ()).galois_value ();
 
-  int arg_is_empty = empty_arg ("grank", nr, nc);
+  int arg_is_empty = arg.isempty();
 
   if (arg_is_empty > 0)
     retval = 0.0;
@@ -1333,7 +1333,7 @@ The variable @var{parpos} controls this positioning and can take the values\n\
   if (!galois_type_loaded || (args(0).type_id () !=
                               octave_galois::static_type_id ()))
     {
-      gripe_wrong_type_arg ("rsenc", args(0));
+      err_wrong_type_arg ("rsenc", args(0));
       return retval;
     }
 
@@ -1874,7 +1874,7 @@ treated with the least-significant symbol first.\n\
   if (!galois_type_loaded || (args(0).type_id () !=
                               octave_galois::static_type_id ()))
     {
-      gripe_wrong_type_arg ("rsdec", args(0));
+      err_wrong_type_arg ("rsdec", args(0));
       return retval;
     }
 
diff --git a/src/op-gm-gm.cc b/src/op-gm-gm.cc
index 86277d4..e21d4cf 100644
--- a/src/op-gm-gm.cc
+++ b/src/op-gm-gm.cc
@@ -18,7 +18,7 @@
 // program with any Open Source program, as defined by the Open Source
 // Initiative (www.opensource.org)
 
-#include <octave/config.h>
+#include <octave/oct.h>
 #include <octave/oct-obj.h>
 #include <octave/ops.h>
 
diff --git a/src/op-gm-m.cc b/src/op-gm-m.cc
index c66913f..d260b26 100644
--- a/src/op-gm-m.cc
+++ b/src/op-gm-m.cc
@@ -18,7 +18,7 @@
 // program with any Open Source program, as defined by the Open Source
 // Initiative (www.opensource.org)
 
-#include <octave/config.h>
+#include <octave/oct.h>
 #include <octave/ops.h>
 #include <octave/ov-re-mat.h>
 
diff --git a/src/op-gm-s.cc b/src/op-gm-s.cc
index fe29f31..4bc47d0 100644
--- a/src/op-gm-s.cc
+++ b/src/op-gm-s.cc
@@ -18,7 +18,7 @@
 // program with any Open Source program, as defined by the Open Source
 // Initiative (www.opensource.org)
 
-#include <octave/config.h>
+#include <octave/oct.h>
 #include <octave/ops.h>
 #include <octave/ov-scalar.h>
 
diff --git a/src/op-m-gm.cc b/src/op-m-gm.cc
index db8615b..164dc0f 100644
--- a/src/op-m-gm.cc
+++ b/src/op-m-gm.cc
@@ -18,7 +18,7 @@
 // program with any Open Source program, as defined by the Open Source
 // Initiative (www.opensource.org)
 
-#include <octave/config.h>
+#include <octave/oct.h>
 #include <octave/ops.h>
 #include <octave/ov-re-mat.h>
 
diff --git a/src/op-s-gm.cc b/src/op-s-gm.cc
index f5d79d1..b3e5764 100644
--- a/src/op-s-gm.cc
+++ b/src/op-s-gm.cc
@@ -18,7 +18,7 @@
 // program with any Open Source program, as defined by the Open Source
 // Initiative (www.opensource.org)
 
-#include <octave/config.h>
+#include <octave/oct.h>
 #include <octave/ops.h>
 #include <octave/ov-scalar.h>
 
diff --git a/src/ov-galois.cc b/src/ov-galois.cc
index 0d93407..bebe396 100644
--- a/src/ov-galois.cc
+++ b/src/ov-galois.cc
@@ -20,9 +20,9 @@
 
 #include <iostream>
 
-#include <octave/config.h>
+#include <octave/oct.h>
 #include <octave/byte-swap.h>
-#include <octave/gripes.h>
+#include <octave/errwarn.h>
 #include <octave/lo-ieee.h>
 #include <octave/oct-locbuf.h>
 #include <octave/oct-obj.h>
@@ -333,13 +333,13 @@ octave_galois::double_value (bool) const
 
   if (rows () > 0 && columns () > 0)
     {
-      gripe_implicit_conversion ("Octave:array-as-scalar",
+      warn_implicit_conversion ("Octave:array-as-scalar",
                                  "real matrix", "real scalar");
 
       retval = (double) gval (0, 0);
     }
   else
-    gripe_invalid_conversion ("galois", "real scalar");
+    err_invalid_conversion ("galois", "real scalar");
 
   return retval;
 }
@@ -353,13 +353,13 @@ octave_galois::complex_value (bool) const
 
   if (rows () > 0 && columns () > 0)
     {
-      gripe_implicit_conversion ("Octave:array-as-scalar",
+      warn_implicit_conversion ("Octave:array-as-scalar",
                                  "real matrix", "real scalar");
 
       retval = (double) gval (0, 0);
     }
   else
-    gripe_invalid_conversion ("galois", "complex scalar");
+    err_invalid_conversion ("galois", "complex scalar");
 
   return retval;
 }
@@ -724,7 +724,7 @@ octave_galois::save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_
   H5Gclose (group_hid);
 
 #elif defined (HAVE_OCTAVE_BASE_VALUE_GRIPE_LOAD_SAVE)
-  gripe_save ("hdf5");
+  err_save ("hdf5");
 #else
   warning ("galois: saving hdf5 files not available");
 #endif
@@ -834,7 +834,7 @@ octave_galois::load_hdf5 (octave_hdf5_id loc_id, const char *name)
   H5Dclose (data_hid);
 
 #elif defined (HAVE_OCTAVE_BASE_VALUE_GRIPE_LOAD_SAVE)
-  gripe_load ("hdf5");
+  err_load ("hdf5");
 #else
   warning ("galois: loading hdf5 files not available");
 #endif
-- 
2.21.0

Places

File 0001-Update-deprecated-functions-includes.patch of Package octave-forge-communications

Places