# HG changeset patch
# User John Donoghue
# Date 1548081074 18000
# Node ID dfd7a3adef2af8570b9426c26e0c248b42232b75
# Parent  df010e3a62d62d915caa0185a8736249001e39b9
of-communications: dev octave update patch (Bug #55325)

* src/of-communications-6-deprecated.patch: new file

* dist-files.mk: add ref to patch

diff -r df010e3a62d6 -r dfd7a3adef2a dist-files.mk
--- a/dist-files.mk	Mon Jan 21 08:55:29 2019 -0500
+++ b/dist-files.mk	Mon Jan 21 09:31:14 2019 -0500
@@ -461,6 +461,7 @@
   of-communications-3-fixes.patch \
   of-communications-4-fixes.patch \
   of-communications-5-fixes.patch \
+  of-communications-6-deprecated.patch \
   of-communications.mk \
   of-control-1-deprecated.patch \
   of-control.mk \
diff -r df010e3a62d6 -r dfd7a3adef2a src/of-communications-6-deprecated.patch
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/of-communications-6-deprecated.patch	Mon Jan 21 09:31:14 2019 -0500
@@ -0,0 +1,427 @@
+diff -r 91279e205a70 src/galois.h
+--- a/src/galois.h	Sun Jan 20 19:13:40 2019 +0100
++++ b/src/galois.h	Sun Jan 20 19:55:05 2019 +0100
+@@ -22,6 +22,7 @@
+ #define octave_galois_int_h 1
+ 
+ #include <octave/mx-base.h>
++#include <octave/ov-typeinfo.h>
+ 
+ #include "galoisfield.h"
+ #include "base-lu.h"
+@@ -150,12 +151,12 @@
+   pivot_type ptype;
+ };
+ 
+-void install_gm_gm_ops (void);
+-void install_gm_m_ops (void);
+-void install_m_gm_ops (void);
+-void install_gm_s_ops (void);
+-void install_s_gm_ops (void);
+-void install_fil_gm_ops (void);
++void install_gm_gm_ops (octave::type_info& ti);
++void install_gm_m_ops (octave::type_info& ti);
++void install_m_gm_ops (octave::type_info& ti);
++void install_gm_s_ops (octave::type_info& ti);
++void install_s_gm_ops (octave::type_info& ti);
++void install_fil_gm_ops (octave::type_info& ti);
+ 
+ galois elem_pow (const galois& a, const galois& b);
+ galois elem_pow (const galois& a, const Matrix& b);
+diff -r 91279e205a70 src/gf.cc
+--- a/src/gf.cc	Sun Jan 20 19:13:40 2019 +0100
++++ b/src/gf.cc	Sun Jan 20 19:55:05 2019 +0100
+@@ -116,13 +116,16 @@
+   if (!galois_type_loaded)
+     {
+       octave_galois::register_type ();
+-      install_gm_gm_ops ();
+-      install_m_gm_ops ();
+-      install_gm_m_ops ();
+-      install_s_gm_ops ();
+-      install_gm_s_ops ();
++      interp.mlock ();
++
++      octave::type_info& ti = interp.get_type_info ();
++
++      install_gm_gm_ops (ti);
++      install_m_gm_ops (ti);
++      install_gm_m_ops (ti);
++      install_s_gm_ops (ti);
++      install_gm_s_ops (ti);
+       galois_type_loaded = true;
+-      interp.mlock ();
+     }
+ 
+   retval = new octave_galois (data, m, primpoly);
+diff -r 91279e205a70 src/op-gm-gm.cc
+--- a/src/op-gm-gm.cc	Sun Jan 20 19:13:40 2019 +0100
++++ b/src/op-gm-gm.cc	Sun Jan 20 19:55:05 2019 +0100
+@@ -18,7 +18,7 @@
+ // program with any Open Source program, as defined by the Open Source
+ // Initiative (www.opensource.org)
+ 
+-#include <octave/oct-obj.h>
++#include <octave/ovl.h>
+ #include <octave/ops.h>
+ 
+ #include "galois.h"
+@@ -86,36 +86,36 @@
+ DEFASSIGNOP_FN (assign, galois, galois, assign)
+ 
+ void
+-install_gm_gm_ops (void)
++install_gm_gm_ops (octave::type_info& ti)
+ {
+-  INSTALL_UNOP (op_not, octave_galois, not);
+-  INSTALL_UNOP (op_uminus, octave_galois, uminus);
+-  INSTALL_UNOP (op_uplus, octave_galois, uplus);
+-  INSTALL_UNOP (op_transpose, octave_galois, transpose);
+-  INSTALL_UNOP (op_hermitian, octave_galois, transpose);
++  INSTALL_UNOP_TI (ti, op_not, octave_galois, not);
++  INSTALL_UNOP_TI (ti, op_uminus, octave_galois, uminus);
++  INSTALL_UNOP_TI (ti, op_uplus, octave_galois, uplus);
++  INSTALL_UNOP_TI (ti, op_transpose, octave_galois, transpose);
++  INSTALL_UNOP_TI (ti, op_hermitian, octave_galois, transpose);
+ 
+-  INSTALL_BINOP (op_add, octave_galois, octave_galois, add);
+-  INSTALL_BINOP (op_sub, octave_galois, octave_galois, sub);
+-  INSTALL_BINOP (op_mul, octave_galois, octave_galois, mul);
+-  INSTALL_BINOP (op_div, octave_galois, octave_galois, div);
+-  INSTALL_BINOP (op_pow, octave_galois, octave_galois, pow);
+-  INSTALL_BINOP (op_ldiv, octave_galois, octave_galois, ldiv);
+-  INSTALL_BINOP (op_lt, octave_galois, octave_galois, lt);
+-  INSTALL_BINOP (op_le, octave_galois, octave_galois, le);
+-  INSTALL_BINOP (op_eq, octave_galois, octave_galois, eq);
+-  INSTALL_BINOP (op_ge, octave_galois, octave_galois, ge);
+-  INSTALL_BINOP (op_gt, octave_galois, octave_galois, gt);
+-  INSTALL_BINOP (op_ne, octave_galois, octave_galois, ne);
+-  INSTALL_BINOP (op_el_mul, octave_galois, octave_galois, el_mul);
+-  INSTALL_BINOP (op_el_div, octave_galois, octave_galois, el_div);
+-  INSTALL_BINOP (op_el_pow, octave_galois, octave_galois, el_pow);
+-  INSTALL_BINOP (op_el_ldiv, octave_galois, octave_galois, el_ldiv);
+-  INSTALL_BINOP (op_el_and, octave_galois, octave_galois, el_and);
+-  INSTALL_BINOP (op_el_or, octave_galois, octave_galois, el_or);
++  INSTALL_BINOP_TI (ti, op_add, octave_galois, octave_galois, add);
++  INSTALL_BINOP_TI (ti, op_sub, octave_galois, octave_galois, sub);
++  INSTALL_BINOP_TI (ti, op_mul, octave_galois, octave_galois, mul);
++  INSTALL_BINOP_TI (ti, op_div, octave_galois, octave_galois, div);
++  INSTALL_BINOP_TI (ti, op_pow, octave_galois, octave_galois, pow);
++  INSTALL_BINOP_TI (ti, op_ldiv, octave_galois, octave_galois, ldiv);
++  INSTALL_BINOP_TI (ti, op_lt, octave_galois, octave_galois, lt);
++  INSTALL_BINOP_TI (ti, op_le, octave_galois, octave_galois, le);
++  INSTALL_BINOP_TI (ti, op_eq, octave_galois, octave_galois, eq);
++  INSTALL_BINOP_TI (ti, op_ge, octave_galois, octave_galois, ge);
++  INSTALL_BINOP_TI (ti, op_gt, octave_galois, octave_galois, gt);
++  INSTALL_BINOP_TI (ti, op_ne, octave_galois, octave_galois, ne);
++  INSTALL_BINOP_TI (ti, op_el_mul, octave_galois, octave_galois, el_mul);
++  INSTALL_BINOP_TI (ti, op_el_div, octave_galois, octave_galois, el_div);
++  INSTALL_BINOP_TI (ti, op_el_pow, octave_galois, octave_galois, el_pow);
++  INSTALL_BINOP_TI (ti, op_el_ldiv, octave_galois, octave_galois, el_ldiv);
++  INSTALL_BINOP_TI (ti, op_el_and, octave_galois, octave_galois, el_and);
++  INSTALL_BINOP_TI (ti, op_el_or, octave_galois, octave_galois, el_or);
+ 
+-  INSTALL_G_CATOP (octave_galois, octave_galois, gm_gm);
++  INSTALL_CATOP_TI (ti, octave_galois, octave_galois, gm_gm);
+ 
+-  INSTALL_ASSIGNOP (op_asn_eq, octave_galois, octave_galois, assign);
++  INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_galois, octave_galois, assign);
+ }
+ 
+ /*
+diff -r 91279e205a70 src/op-gm-m.cc
+--- a/src/op-gm-m.cc	Sun Jan 20 19:13:40 2019 +0100
++++ b/src/op-gm-m.cc	Sun Jan 20 19:55:05 2019 +0100
+@@ -75,31 +75,31 @@
+ }
+ 
+ void
+-install_gm_m_ops (void)
++install_gm_m_ops (octave::type_info& ti)
+ {
+-  INSTALL_BINOP (op_add, octave_galois, octave_matrix, add);
+-  INSTALL_BINOP (op_sub, octave_galois, octave_matrix, sub);
+-  INSTALL_BINOP (op_mul, octave_galois, octave_matrix, mul);
+-  INSTALL_BINOP (op_div, octave_galois, octave_matrix, div);
+-  INSTALL_BINOP (op_pow, octave_galois, octave_matrix, pow);
+-  INSTALL_BINOP (op_ldiv, octave_galois, octave_matrix, ldiv);
+-  INSTALL_BINOP (op_lt, octave_galois, octave_matrix, lt);
+-  INSTALL_BINOP (op_le, octave_galois, octave_matrix, le);
+-  INSTALL_BINOP (op_eq, octave_galois, octave_matrix, eq);
+-  INSTALL_BINOP (op_ge, octave_galois, octave_matrix, ge);
+-  INSTALL_BINOP (op_gt, octave_galois, octave_matrix, gt);
+-  INSTALL_BINOP (op_ne, octave_galois, octave_matrix, ne);
+-  INSTALL_BINOP (op_el_mul, octave_galois, octave_matrix, el_mul);
+-  INSTALL_BINOP (op_el_div, octave_galois, octave_matrix, el_div);
+-  INSTALL_BINOP (op_el_pow, octave_galois, octave_matrix, el_pow);
+-  INSTALL_BINOP (op_el_ldiv, octave_galois, octave_matrix, el_ldiv);
+-  INSTALL_BINOP (op_el_and, octave_galois, octave_matrix, el_and);
+-  INSTALL_BINOP (op_el_or, octave_galois, octave_matrix, el_or);
++  INSTALL_BINOP_TI (ti, op_add, octave_galois, octave_matrix, add);
++  INSTALL_BINOP_TI (ti, op_sub, octave_galois, octave_matrix, sub);
++  INSTALL_BINOP_TI (ti, op_mul, octave_galois, octave_matrix, mul);
++  INSTALL_BINOP_TI (ti, op_div, octave_galois, octave_matrix, div);
++  INSTALL_BINOP_TI (ti, op_pow, octave_galois, octave_matrix, pow);
++  INSTALL_BINOP_TI (ti, op_ldiv, octave_galois, octave_matrix, ldiv);
++  INSTALL_BINOP_TI (ti, op_lt, octave_galois, octave_matrix, lt);
++  INSTALL_BINOP_TI (ti, op_le, octave_galois, octave_matrix, le);
++  INSTALL_BINOP_TI (ti, op_eq, octave_galois, octave_matrix, eq);
++  INSTALL_BINOP_TI (ti, op_ge, octave_galois, octave_matrix, ge);
++  INSTALL_BINOP_TI (ti, op_gt, octave_galois, octave_matrix, gt);
++  INSTALL_BINOP_TI (ti, op_ne, octave_galois, octave_matrix, ne);
++  INSTALL_BINOP_TI (ti, op_el_mul, octave_galois, octave_matrix, el_mul);
++  INSTALL_BINOP_TI (ti, op_el_div, octave_galois, octave_matrix, el_div);
++  INSTALL_BINOP_TI (ti, op_el_pow, octave_galois, octave_matrix, el_pow);
++  INSTALL_BINOP_TI (ti, op_el_ldiv, octave_galois, octave_matrix, el_ldiv);
++  INSTALL_BINOP_TI (ti, op_el_and, octave_galois, octave_matrix, el_and);
++  INSTALL_BINOP_TI (ti, op_el_or, octave_galois, octave_matrix, el_or);
+ 
+-  INSTALL_G_CATOP (octave_galois, octave_matrix, gm_m);
++  INSTALL_CATOP_TI (ti, octave_galois, octave_matrix, gm_m);
+ 
+-  INSTALL_ASSIGNOP (op_asn_eq, octave_galois, octave_matrix, assign);
+-  INSTALL_ASSIGNCONV (octave_base_value, octave_galois, octave_matrix);
++  INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_galois, octave_matrix, assign);
++  INSTALL_ASSIGNCONV_TI (ti, octave_base_value, octave_galois, octave_matrix);
+ }
+ 
+ /*
+diff -r 91279e205a70 src/op-gm-s.cc
+--- a/src/op-gm-s.cc	Sun Jan 20 19:13:40 2019 +0100
++++ b/src/op-gm-s.cc	Sun Jan 20 19:55:05 2019 +0100
+@@ -79,30 +79,30 @@
+ }
+ 
+ void
+-install_gm_s_ops (void)
++install_gm_s_ops (octave::type_info& ti)
+ {
+-  INSTALL_BINOP (op_add, octave_galois, octave_scalar, add);
+-  INSTALL_BINOP (op_sub, octave_galois, octave_scalar, sub);
+-  INSTALL_BINOP (op_mul, octave_galois, octave_scalar, mul);
+-  INSTALL_BINOP (op_div, octave_galois, octave_scalar, div);
+-  INSTALL_BINOP (op_pow, octave_galois, octave_scalar, pow);
+-  INSTALL_BINOP (op_ldiv, octave_galois, octave_scalar, ldiv);
+-  INSTALL_BINOP (op_lt, octave_galois, octave_scalar, lt);
+-  INSTALL_BINOP (op_le, octave_galois, octave_scalar, le);
+-  INSTALL_BINOP (op_eq, octave_galois, octave_scalar, eq);
+-  INSTALL_BINOP (op_ge, octave_galois, octave_scalar, ge);
+-  INSTALL_BINOP (op_gt, octave_galois, octave_scalar, gt);
+-  INSTALL_BINOP (op_ne, octave_galois, octave_scalar, ne);
+-  INSTALL_BINOP (op_el_mul, octave_galois, octave_scalar, el_mul);
+-  INSTALL_BINOP (op_el_div, octave_galois, octave_scalar, el_div);
+-  INSTALL_BINOP (op_el_pow, octave_galois, octave_scalar, el_pow);
+-  INSTALL_BINOP (op_el_ldiv, octave_galois, octave_scalar, el_ldiv);
+-  INSTALL_BINOP (op_el_and, octave_galois, octave_scalar, el_and);
+-  INSTALL_BINOP (op_el_or, octave_galois, octave_scalar, el_or);
++  INSTALL_BINOP_TI (ti, op_add, octave_galois, octave_scalar, add);
++  INSTALL_BINOP_TI (ti, op_sub, octave_galois, octave_scalar, sub);
++  INSTALL_BINOP_TI (ti, op_mul, octave_galois, octave_scalar, mul);
++  INSTALL_BINOP_TI (ti, op_div, octave_galois, octave_scalar, div);
++  INSTALL_BINOP_TI (ti, op_pow, octave_galois, octave_scalar, pow);
++  INSTALL_BINOP_TI (ti, op_ldiv, octave_galois, octave_scalar, ldiv);
++  INSTALL_BINOP_TI (ti, op_lt, octave_galois, octave_scalar, lt);
++  INSTALL_BINOP_TI (ti, op_le, octave_galois, octave_scalar, le);
++  INSTALL_BINOP_TI (ti, op_eq, octave_galois, octave_scalar, eq);
++  INSTALL_BINOP_TI (ti, op_ge, octave_galois, octave_scalar, ge);
++  INSTALL_BINOP_TI (ti, op_gt, octave_galois, octave_scalar, gt);
++  INSTALL_BINOP_TI (ti, op_ne, octave_galois, octave_scalar, ne);
++  INSTALL_BINOP_TI (ti, op_el_mul, octave_galois, octave_scalar, el_mul);
++  INSTALL_BINOP_TI (ti, op_el_div, octave_galois, octave_scalar, el_div);
++  INSTALL_BINOP_TI (ti, op_el_pow, octave_galois, octave_scalar, el_pow);
++  INSTALL_BINOP_TI (ti, op_el_ldiv, octave_galois, octave_scalar, el_ldiv);
++  INSTALL_BINOP_TI (ti, op_el_and, octave_galois, octave_scalar, el_and);
++  INSTALL_BINOP_TI (ti, op_el_or, octave_galois, octave_scalar, el_or);
+ 
+-  INSTALL_G_CATOP (octave_galois, octave_scalar, gm_s);
++  INSTALL_CATOP_TI (ti, octave_galois, octave_scalar, gm_s);
+ 
+-  INSTALL_ASSIGNOP (op_asn_eq, octave_galois, octave_scalar, assign);
++  INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_galois, octave_scalar, assign);
+ }
+ 
+ /*
+diff -r 91279e205a70 src/op-m-gm.cc
+--- a/src/op-m-gm.cc	Sun Jan 20 19:13:40 2019 +0100
++++ b/src/op-m-gm.cc	Sun Jan 20 19:55:05 2019 +0100
+@@ -76,30 +76,30 @@
+ DEFASSIGNOP_FN (assign, matrix, galois, assign)
+ 
+ void
+-install_m_gm_ops (void)
++install_m_gm_ops (octave::type_info& ti)
+ {
+-  INSTALL_BINOP (op_add, octave_matrix, octave_galois, add);
+-  INSTALL_BINOP (op_sub, octave_matrix, octave_galois, sub);
+-  INSTALL_BINOP (op_mul, octave_matrix, octave_galois, mul);
+-  INSTALL_BINOP (op_div, octave_matrix, octave_galois, div);
+-  INSTALL_BINOP (op_pow, octave_matrix, octave_galois, pow);
+-  INSTALL_BINOP (op_ldiv, octave_matrix, octave_galois, ldiv);
+-  INSTALL_BINOP (op_lt, octave_matrix, octave_galois, lt);
+-  INSTALL_BINOP (op_le, octave_matrix, octave_galois, le);
+-  INSTALL_BINOP (op_eq, octave_matrix, octave_galois, eq);
+-  INSTALL_BINOP (op_ge, octave_matrix, octave_galois, ge);
+-  INSTALL_BINOP (op_gt, octave_matrix, octave_galois, gt);
+-  INSTALL_BINOP (op_ne, octave_matrix, octave_galois, ne);
+-  INSTALL_BINOP (op_el_mul, octave_matrix, octave_galois, el_mul);
+-  INSTALL_BINOP (op_el_div, octave_matrix, octave_galois, el_div);
+-  INSTALL_BINOP (op_el_pow, octave_matrix, octave_galois, el_pow);
+-  INSTALL_BINOP (op_el_ldiv, octave_matrix, octave_galois, el_ldiv);
+-  INSTALL_BINOP (op_el_and, octave_matrix, octave_galois, el_and);
+-  INSTALL_BINOP (op_el_or, octave_matrix, octave_galois, el_or);
++  INSTALL_BINOP_TI (ti, op_add, octave_matrix, octave_galois, add);
++  INSTALL_BINOP_TI (ti, op_sub, octave_matrix, octave_galois, sub);
++  INSTALL_BINOP_TI (ti, op_mul, octave_matrix, octave_galois, mul);
++  INSTALL_BINOP_TI (ti, op_div, octave_matrix, octave_galois, div);
++  INSTALL_BINOP_TI (ti, op_pow, octave_matrix, octave_galois, pow);
++  INSTALL_BINOP_TI (ti, op_ldiv, octave_matrix, octave_galois, ldiv);
++  INSTALL_BINOP_TI (ti, op_lt, octave_matrix, octave_galois, lt);
++  INSTALL_BINOP_TI (ti, op_le, octave_matrix, octave_galois, le);
++  INSTALL_BINOP_TI (ti, op_eq, octave_matrix, octave_galois, eq);
++  INSTALL_BINOP_TI (ti, op_ge, octave_matrix, octave_galois, ge);
++  INSTALL_BINOP_TI (ti, op_gt, octave_matrix, octave_galois, gt);
++  INSTALL_BINOP_TI (ti, op_ne, octave_matrix, octave_galois, ne);
++  INSTALL_BINOP_TI (ti, op_el_mul, octave_matrix, octave_galois, el_mul);
++  INSTALL_BINOP_TI (ti, op_el_div, octave_matrix, octave_galois, el_div);
++  INSTALL_BINOP_TI (ti, op_el_pow, octave_matrix, octave_galois, el_pow);
++  INSTALL_BINOP_TI (ti, op_el_ldiv, octave_matrix, octave_galois, el_ldiv);
++  INSTALL_BINOP_TI (ti, op_el_and, octave_matrix, octave_galois, el_and);
++  INSTALL_BINOP_TI (ti, op_el_or, octave_matrix, octave_galois, el_or);
+ 
+-  INSTALL_G_CATOP (octave_matrix, octave_galois, m_gm);
++  INSTALL_CATOP_TI (ti, octave_matrix, octave_galois, m_gm);
+ 
+-  INSTALL_ASSIGNOP (op_asn_eq, octave_matrix, octave_galois, assign);
++  INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_matrix, octave_galois, assign);
+   //INSTALL_ASSIGNCONV (octave_base_value, octave_matrix, octave_galois);
+ }
+ 
+diff -r 91279e205a70 src/op-s-gm.cc
+--- a/src/op-s-gm.cc	Sun Jan 20 19:13:40 2019 +0100
++++ b/src/op-s-gm.cc	Sun Jan 20 19:55:05 2019 +0100
+@@ -83,30 +83,30 @@
+ }
+ 
+ void
+-install_s_gm_ops (void)
++install_s_gm_ops (octave::type_info& ti)
+ {
+-  INSTALL_BINOP (op_add, octave_scalar, octave_galois, add);
+-  INSTALL_BINOP (op_sub, octave_scalar, octave_galois, sub);
+-  INSTALL_BINOP (op_mul, octave_scalar, octave_galois, mul);
+-  INSTALL_BINOP (op_div, octave_scalar, octave_galois, div);
+-  INSTALL_BINOP (op_pow, octave_scalar, octave_galois, pow);
+-  INSTALL_BINOP (op_ldiv, octave_scalar, octave_galois, ldiv);
+-  INSTALL_BINOP (op_lt, octave_scalar, octave_galois, lt);
+-  INSTALL_BINOP (op_le, octave_scalar, octave_galois, le);
+-  INSTALL_BINOP (op_eq, octave_scalar, octave_galois, eq);
+-  INSTALL_BINOP (op_ge, octave_scalar, octave_galois, ge);
+-  INSTALL_BINOP (op_gt, octave_scalar, octave_galois, gt);
+-  INSTALL_BINOP (op_ne, octave_scalar, octave_galois, ne);
+-  INSTALL_BINOP (op_el_mul, octave_scalar, octave_galois, el_mul);
+-  INSTALL_BINOP (op_el_div, octave_scalar, octave_galois, el_div);
+-  INSTALL_BINOP (op_el_pow, octave_scalar, octave_galois, el_pow);
+-  INSTALL_BINOP (op_el_ldiv, octave_scalar, octave_galois, el_ldiv);
+-  INSTALL_BINOP (op_el_and, octave_scalar, octave_galois, el_and);
+-  INSTALL_BINOP (op_el_or, octave_scalar, octave_galois, el_or);
++  INSTALL_BINOP_TI (ti, op_add, octave_scalar, octave_galois, add);
++  INSTALL_BINOP_TI (ti, op_sub, octave_scalar, octave_galois, sub);
++  INSTALL_BINOP_TI (ti, op_mul, octave_scalar, octave_galois, mul);
++  INSTALL_BINOP_TI (ti, op_div, octave_scalar, octave_galois, div);
++  INSTALL_BINOP_TI (ti, op_pow, octave_scalar, octave_galois, pow);
++  INSTALL_BINOP_TI (ti, op_ldiv, octave_scalar, octave_galois, ldiv);
++  INSTALL_BINOP_TI (ti, op_lt, octave_scalar, octave_galois, lt);
++  INSTALL_BINOP_TI (ti, op_le, octave_scalar, octave_galois, le);
++  INSTALL_BINOP_TI (ti, op_eq, octave_scalar, octave_galois, eq);
++  INSTALL_BINOP_TI (ti, op_ge, octave_scalar, octave_galois, ge);
++  INSTALL_BINOP_TI (ti, op_gt, octave_scalar, octave_galois, gt);
++  INSTALL_BINOP_TI (ti, op_ne, octave_scalar, octave_galois, ne);
++  INSTALL_BINOP_TI (ti, op_el_mul, octave_scalar, octave_galois, el_mul);
++  INSTALL_BINOP_TI (ti, op_el_div, octave_scalar, octave_galois, el_div);
++  INSTALL_BINOP_TI (ti, op_el_pow, octave_scalar, octave_galois, el_pow);
++  INSTALL_BINOP_TI (ti, op_el_ldiv, octave_scalar, octave_galois, el_ldiv);
++  INSTALL_BINOP_TI (ti, op_el_and, octave_scalar, octave_galois, el_and);
++  INSTALL_BINOP_TI (ti, op_el_or, octave_scalar, octave_galois, el_or);
+ 
+-  INSTALL_G_CATOP (octave_scalar, octave_galois, s_gm);
++  INSTALL_CATOP_TI (ti, octave_scalar, octave_galois, s_gm);
+ 
+-  INSTALL_ASSIGNCONV (octave_scalar, octave_galois, octave_galois);
++  INSTALL_ASSIGNCONV_TI (ti, octave_scalar, octave_galois, octave_galois);
+ }
+ 
+ /*
+diff -r 91279e205a70 src/ov-galois.cc
+--- a/src/ov-galois.cc	Sun Jan 20 19:13:40 2019 +0100
++++ b/src/ov-galois.cc	Sun Jan 20 19:55:05 2019 +0100
+@@ -24,8 +24,8 @@
+ #include <octave/errwarn.h>
+ #include <octave/lo-ieee.h>
+ #include <octave/oct-locbuf.h>
+-#include <octave/oct-obj.h>
+ #include <octave/ov.h>
++#include <octave/ovl.h>
+ #include <octave/pr-output.h>
+ 
+ 
+@@ -535,7 +535,7 @@
+ 
+ bool
+ octave_galois::load_binary (std::istream& is, bool swap,
+-                            oct_mach_info::float_format fmt)
++                            octave::mach_info::float_format fmt)
+ {
+   char mord;
+   int32_t prim, mdims;
+diff -r 91279e205a70 src/ov-galois.h
+--- a/src/ov-galois.h	Sun Jan 20 19:13:40 2019 +0100
++++ b/src/ov-galois.h	Sun Jan 20 19:55:05 2019 +0100
+@@ -156,7 +156,7 @@
+   bool save_binary (std::ostream& os, bool& save_as_floats);
+ 
+   bool load_binary (std::istream& is, bool swap,
+-                    oct_mach_info::float_format fmt);
++                    octave::mach_info::float_format fmt);
+ 
+   bool save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats);
+ 
+diff -r 91279e205a70 src/primpoly.cc
+--- a/src/primpoly.cc	Sun Jan 20 19:13:40 2019 +0100
++++ b/src/primpoly.cc	Sun Jan 20 19:55:05 2019 +0100
+@@ -216,8 +216,8 @@
+       for (int i = (1<<m)+1; i < (1<<(1+m)); i+=2)
+         if (do_isprimitive (i, m))
+           {
+-            primpolys.resize (primpolys.length ()+1);
+-            primpolys(primpolys.length ()-1) = (double)i;
++            primpolys.resize (primpolys.numel ()+1);
++            primpolys(primpolys.numel ()-1) = (double)i;
+           }
+       break;
+     case PRIMPOLY_K:
+@@ -231,8 +231,8 @@
+             {
+               if (do_isprimitive (i, m))
+                 {
+-                  primpolys.resize (primpolys.length ()+1);
+-                  primpolys(primpolys.length ()-1) = (double)i;
++                  primpolys.resize (primpolys.numel ()+1);
++                  primpolys(primpolys.numel ()-1) = (double)i;
+                 }
+             }
+         }
+@@ -244,12 +244,12 @@
+ 
+   if (disp)
+     {
+-      if (primpolys.length () == 0)
++      if (primpolys.numel () == 0)
+         warning ("primpoly: No primitive polynomial satisfies the given constraints");
+       else
+         {
+           octave_stdout << std::endl << "Primitive polynomial(s) =" << std::endl << std::endl;
+-          for (int i = 0; i < primpolys.length (); i++)
++          for (int i = 0; i < primpolys.numel (); i++)
+             {
+               bool first = true;
+               for (int j = m; j >= 0; j--)