--- a/liboctave/DASRT.cc
+++ b/liboctave/DASRT.cc
@@ -35,23 +35,23 @@
 #include "quit.h"
 
 typedef octave_idx_type (*dasrt_fcn_ptr) (const double&, const double*, const double*,
-			      double*, octave_idx_type&, double*, octave_idx_type*);
+                              double*, octave_idx_type&, double*, octave_idx_type*);
 
 typedef octave_idx_type (*dasrt_jac_ptr) (const double&, const double*, const double*,
-			      double*, const double&, double*, octave_idx_type*);
+                              double*, const double&, double*, octave_idx_type*);
 
 typedef octave_idx_type (*dasrt_constr_ptr) (const octave_idx_type&, const double&, const double*,
-				 const octave_idx_type&, double*, double*, octave_idx_type*);
+                                 const octave_idx_type&, double*, double*, octave_idx_type*);
 
 extern "C"
 {
   F77_RET_T
   F77_FUNC (ddasrt, DDASRT) (dasrt_fcn_ptr, const octave_idx_type&, double&,
-			     double*, double*, const double&, octave_idx_type*,
-			     const double*, const double*, octave_idx_type&, double*,
-			     const octave_idx_type&, octave_idx_type*, const octave_idx_type&, double*,
-			     octave_idx_type*, dasrt_jac_ptr, dasrt_constr_ptr,
-			     const octave_idx_type&, octave_idx_type*);
+                             double*, double*, const double&, octave_idx_type*,
+                             const double*, const double*, octave_idx_type&, double*,
+                             const octave_idx_type&, octave_idx_type*, const octave_idx_type&, double*,
+                             octave_idx_type*, dasrt_jac_ptr, dasrt_constr_ptr,
+                             const octave_idx_type&, octave_idx_type*);
 }
 
 static DAEFunc::DAERHSFunc user_fsub;
@@ -62,7 +62,7 @@
 
 static octave_idx_type
 ddasrt_f (const double& t, const double *state, const double *deriv,
-	  double *delta, octave_idx_type& ires, double *, octave_idx_type *)
+          double *delta, octave_idx_type& ires, double *, octave_idx_type *)
 {
   BEGIN_INTERRUPT_WITH_EXCEPTIONS;
 
@@ -82,7 +82,7 @@
   else
     {
       for (octave_idx_type i = 0; i < nn; i++)
-	delta[i] = tmp_fval(i);
+        delta[i] = tmp_fval(i);
     }
 
   END_INTERRUPT_WITH_EXCEPTIONS;
@@ -92,7 +92,7 @@
 
 octave_idx_type
 ddasrt_j (const double& time, const double *state, const double *deriv,
-	  double *pd, const double& cj, double *, octave_idx_type *)
+          double *pd, const double& cj, double *, octave_idx_type *)
 {
   BEGIN_INTERRUPT_WITH_EXCEPTIONS;
 
@@ -120,7 +120,7 @@
 
 static octave_idx_type
 ddasrt_g (const octave_idx_type& neq, const double& t, const double *state,
-	  const octave_idx_type& ng, double *gout, double *, octave_idx_type *) 
+          const octave_idx_type& ng, double *gout, double *, octave_idx_type *) 
 {
   BEGIN_INTERRUPT_WITH_EXCEPTIONS;
 
@@ -159,7 +159,7 @@
       info.resize (15);
 
       for (octave_idx_type i = 0; i < 15; i++)
-	info(i) = 0;
+        info(i) = 0;
 
       pinfo = info.fortran_vec ();
 
@@ -172,29 +172,29 @@
       user_csub = DAERTFunc::constraint_function ();
 
       if (user_csub)
-	{
-	  ColumnVector tmp = (*user_csub) (x, t);
-	  ng = tmp.length ();
-	}
+        {
+          ColumnVector tmp = (*user_csub) (x, t);
+          ng = tmp.length ();
+        }
       else
-	ng = 0;
+        ng = 0;
 
       octave_idx_type maxord = maximum_order ();
       if (maxord >= 0)
-	{
-	  if (maxord > 0 && maxord < 6)
-	    {
-	      info(8) = 1;
-	      iwork(2) = maxord;
-	    }
-	  else
-	    {
-	      (*current_liboctave_error_handler)
-		("dassl: invalid value for maximum order");
-	      integration_error = true;
-	      return;
-	    }
-	}
+        {
+          if (maxord > 0 && maxord < 6)
+            {
+              info(8) = 1;
+              iwork(2) = maxord;
+            }
+          else
+            {
+              (*current_liboctave_error_handler)
+                ("dassl: invalid value for maximum order");
+              integration_error = true;
+              return;
+            }
+        }
 
       liw = 21 + n;
       lrw = 50 + 9*n + n*n + 3*ng;
@@ -205,12 +205,12 @@
       info(0) = 0;
 
       if (stop_time_set)
-	{
-	  info(3) = 1;
-	  rwork(0) = stop_time;
-	}
+        {
+          info(3) = 1;
+          rwork(0) = stop_time;
+        }
       else
-	info(3) = 0;
+        info(3) = 0;
 
       px = x.fortran_vec ();
       pxdot = xdot.fortran_vec ();
@@ -226,28 +226,28 @@
       user_jsub = DAEFunc::jacobian_function ();
 
       if (user_fsub)
-	{
-	  octave_idx_type ires = 0;
+        {
+          octave_idx_type ires = 0;
 
-	  ColumnVector fval = (*user_fsub) (x, xdot, t, ires);
+          ColumnVector fval = (*user_fsub) (x, xdot, t, ires);
 
-	  if (fval.length () != x.length ())
-	    {
-	      (*current_liboctave_error_handler)
-		("dasrt: inconsistent sizes for state and residual vectors");
+          if (fval.length () != x.length ())
+            {
+              (*current_liboctave_error_handler)
+                ("dasrt: inconsistent sizes for state and residual vectors");
 
-	      integration_error = true;
-	      return;
-	    }
-	}
+              integration_error = true;
+              return;
+            }
+        }
       else
-	{
-	  (*current_liboctave_error_handler)
-	    ("dasrt: no user supplied RHS subroutine!");
+        {
+          (*current_liboctave_error_handler)
+            ("dasrt: no user supplied RHS subroutine!");
 
-	  integration_error = true;
-	  return;
-	}
+          integration_error = true;
+          return;
+        }
 
       info(4) = user_jsub ? 1 : 0;
 
@@ -263,29 +263,29 @@
 
       double mss = maximum_step_size ();
       if (mss >= 0.0)
-	{
-	  rwork(1) = mss;
-	  info(6) = 1;
-	}
+        {
+          rwork(1) = mss;
+          info(6) = 1;
+        }
       else
-	info(6) = 0;
+        info(6) = 0;
 
       double iss = initial_step_size ();
       if (iss >= 0.0)
-	{
-	  rwork(2) = iss;
-	  info(7) = 1;
-	}
+        {
+          rwork(2) = iss;
+          info(7) = 1;
+        }
       else
-	info(7) = 0;
+        info(7) = 0;
 
       if (step_limit () >= 0)
-	{
-	  info(11) = 1;
-	  iwork(20) = step_limit ();
-	}
+        {
+          info(11) = 1;
+          iwork(20) = step_limit ();
+        }
       else
-	info(11) = 0;
+        info(11) = 0;
 
       abs_tol = absolute_tolerance ();
       rel_tol = relative_tolerance ();
@@ -294,21 +294,21 @@
       octave_idx_type rel_tol_len = rel_tol.length ();
 
       if (abs_tol_len == 1 && rel_tol_len == 1)
-	{
-	  info.elem (1) = 0;
-	}
+        {
+          info.elem (1) = 0;
+        }
       else if (abs_tol_len == n && rel_tol_len == n)
-	{
-	  info.elem (1) = 1;
-	}
+        {
+          info.elem (1) = 1;
+        }
       else
-	{
-	  (*current_liboctave_error_handler)
-	    ("dasrt: inconsistent sizes for tolerance arrays");
+        {
+          (*current_liboctave_error_handler)
+            ("dasrt: inconsistent sizes for tolerance arrays");
 
-	  integration_error = true;
-	  return;
-	}
+          integration_error = true;
+          return;
+        }
 
       pabs_tol = abs_tol.fortran_vec ();
       prel_tol = rel_tol.fortran_vec ();
@@ -320,56 +320,56 @@
   static octave_idx_type *idummy = 0;
 
   F77_XFCN (ddasrt, DDASRT, (ddasrt_f, nn, t, px, pxdot, tout, pinfo,
-			     prel_tol, pabs_tol, istate, prwork, lrw,
-			     piwork, liw, dummy, idummy, ddasrt_j,
-			     ddasrt_g, ng, pjroot));
+                             prel_tol, pabs_tol, istate, prwork, lrw,
+                             piwork, liw, dummy, idummy, ddasrt_j,
+                             ddasrt_g, ng, pjroot));
 
   switch (istate)
     {
     case 1: // A step was successfully taken in intermediate-output
-	    // mode. The code has not yet reached TOUT.
+            // mode. The code has not yet reached TOUT.
     case 2: // The integration to TOUT was successfully completed
-	    // (T=TOUT) by stepping exactly to TOUT.
+            // (T=TOUT) by stepping exactly to TOUT.
     case 3: // The integration to TOUT was successfully completed
-	    // (T=TOUT) by stepping past TOUT.  Y(*) is obtained by
-	    // interpolation.  YPRIME(*) is obtained by interpolation.
+            // (T=TOUT) by stepping past TOUT.  Y(*) is obtained by
+            // interpolation.  YPRIME(*) is obtained by interpolation.
       t = tout;
       break;
 
     case 4: //  The integration was successfully completed
-	    // by finding one or more roots of G at T.
+            // by finding one or more roots of G at T.
       break;
 
     case -1: // A large amount of work has been expended.
     case -2: // The error tolerances are too stringent.
     case -3: // The local error test cannot be satisfied because you
-	     // specified a zero component in ATOL and the
-	     // corresponding computed solution component is zero.
-	     // Thus, a pure relative error test is impossible for
-	     // this component.
+             // specified a zero component in ATOL and the
+             // corresponding computed solution component is zero.
+             // Thus, a pure relative error test is impossible for
+             // this component.
     case -6: // DDASRT had repeated error test failures on the last
-	     // attempted step.
+             // attempted step.
     case -7: // The corrector could not converge.
     case -8: // The matrix of partial derivatives is singular.
     case -9: // The corrector could not converge.  There were repeated
-	     // error test failures in this step.
+             // error test failures in this step.
     case -10: // The corrector could not converge because IRES was
-	      // equal to minus one.
+              // equal to minus one.
     case -11: // IRES equal to -2 was encountered and control is being
-	      // returned to the calling program.
+              // returned to the calling program.
     case -12: // DASSL failed to compute the initial YPRIME.
     case -33: // The code has encountered trouble from which it cannot
-	      // recover. A message is printed explaining the trouble
-	      // and control is returned to the calling program. For
-	      // example, this occurs when invalid input is detected.
+              // recover. A message is printed explaining the trouble
+              // and control is returned to the calling program. For
+              // example, this occurs when invalid input is detected.
       integration_error = true;
       break;
 
     default:
       integration_error = true;
       (*current_liboctave_error_handler)
-	("unrecognized value of istate (= %d) returned from ddasrt",
-	 istate);
+        ("unrecognized value of istate (= %d) returned from ddasrt",
+         istate);
       break;
     }
 }
@@ -392,40 +392,40 @@
       xdot_out.resize (n_out, n);
 
       for (octave_idx_type i = 0; i < n; i++)
-	{
-	  x_out(0,i) = x(i);
-	  xdot_out(0,i) = xdot(i);
-	}
+        {
+          x_out(0,i) = x(i);
+          xdot_out(0,i) = xdot(i);
+        }
 
       for (octave_idx_type j = 1; j < n_out; j++)
-	{
-	  integrate (tout(j));
+        {
+          integrate (tout(j));
 
-	  if (integration_error)
-	    {
-	      retval = DASRT_result (x_out, xdot_out, t_out);
-	      return retval;
-	    }
+          if (integration_error)
+            {
+              retval = DASRT_result (x_out, xdot_out, t_out);
+              return retval;
+            }
 
           if (istate == 4)
             t_out(j) = t;
           else
             t_out(j) = tout(j);
 
-	  for (octave_idx_type i = 0; i < n; i++)
-	    {
-	      x_out(j,i) = x(i);
-	      xdot_out(j,i) = xdot(i);
-	    }
+          for (octave_idx_type i = 0; i < n; i++)
+            {
+              x_out(j,i) = x(i);
+              xdot_out(j,i) = xdot(i);
+            }
 
           if (istate == 4)
-	    {
-	      x_out.resize (j+1, n);
-	      xdot_out.resize (j+1, n);
-	      t_out.resize (j+1);
-	      break;
-	    }
-	}
+            {
+              x_out.resize (j+1, n);
+              xdot_out.resize (j+1, n);
+              t_out.resize (j+1);
+              break;
+            }
+        }
     }
 
   retval = DASRT_result (x_out, xdot_out, t_out);
@@ -453,75 +453,75 @@
       octave_idx_type n_crit = tcrit.capacity ();
 
       if (n_crit > 0)
-	{
-	  octave_idx_type i_crit = 0;
-	  octave_idx_type i_out = 1;
-	  double next_crit = tcrit(0);
-	  double next_out;
-	  while (i_out < n_out)
-	    {
-	      bool do_restart = false;
+        {
+          octave_idx_type i_crit = 0;
+          octave_idx_type i_out = 1;
+          double next_crit = tcrit(0);
+          double next_out;
+          while (i_out < n_out)
+            {
+              bool do_restart = false;
 
-	      next_out = tout(i_out);
-	      if (i_crit < n_crit)
-		next_crit = tcrit(i_crit);
+              next_out = tout(i_out);
+              if (i_crit < n_crit)
+                next_crit = tcrit(i_crit);
 
-	      octave_idx_type save_output;
-	      double t_out;
+              octave_idx_type save_output;
+              double t_out;
 
-	      if (next_crit == next_out)
-		{
-		  set_stop_time (next_crit);
-		  t_out = next_out;
-		  save_output = 1;
-		  i_out++;
-		  i_crit++;
-		  do_restart = true;
-		}
-	      else if (next_crit < next_out)
-		{
-		  if (i_crit < n_crit)
-		    {
-		      set_stop_time (next_crit);
-		      t_out = next_crit;
-		      save_output = 0;
-		      i_crit++;
-		      do_restart = true;
-		    }
-		  else
-		    {
-		      clear_stop_time ();
-		      t_out = next_out;
-		      save_output = 1;
-		      i_out++;
-		    }
-		}
-	      else
-		{
-		  set_stop_time (next_crit);
-		  t_out = next_out;
-		  save_output = 1;
-		  i_out++;
-		}
+              if (next_crit == next_out)
+                {
+                  set_stop_time (next_crit);
+                  t_out = next_out;
+                  save_output = 1;
+                  i_out++;
+                  i_crit++;
+                  do_restart = true;
+                }
+              else if (next_crit < next_out)
+                {
+                  if (i_crit < n_crit)
+                    {
+                      set_stop_time (next_crit);
+                      t_out = next_crit;
+                      save_output = 0;
+                      i_crit++;
+                      do_restart = true;
+                    }
+                  else
+                    {
+                      clear_stop_time ();
+                      t_out = next_out;
+                      save_output = 1;
+                      i_out++;
+                    }
+                }
+              else
+                {
+                  set_stop_time (next_crit);
+                  t_out = next_out;
+                  save_output = 1;
+                  i_out++;
+                }
 
-	      integrate (t_out);
+              integrate (t_out);
 
-	      if (integration_error)
-		{
-		  retval = DASRT_result (x_out, xdot_out, t_outs);
-		  return retval;
-		}
+              if (integration_error)
+                {
+                  retval = DASRT_result (x_out, xdot_out, t_outs);
+                  return retval;
+                }
 
               if (istate == 4)
                 t_out = t;
 
-	      if (save_output)
-		{
-		  for (octave_idx_type i = 0; i < n; i++)
-		    {
-		      x_out(i_out-1,i) = x(i);
-		      xdot_out(i_out-1,i) = xdot(i);
-		    }
+              if (save_output)
+                {
+                  for (octave_idx_type i = 0; i < n; i++)
+                    {
+                      x_out(i_out-1,i) = x(i);
+                      xdot_out(i_out-1,i) = xdot(i);
+                    }
 
                   t_outs(i_out-1) = t_out;
 
@@ -532,21 +532,21 @@
                       t_outs.resize (i_out);
                       i_out = n_out;
                     }
-		}
+                }
 
-	      if (do_restart)
-		force_restart ();
-	    }
+              if (do_restart)
+                force_restart ();
+            }
 
-	  retval = DASRT_result (x_out, xdot_out, t_outs);
-	}
+          retval = DASRT_result (x_out, xdot_out, t_outs);
+        }
       else
-	{
-	  retval = integrate (tout);
+        {
+          retval = integrate (tout);
 
-	  if (integration_error)
-	    return retval;
-	}
+          if (integration_error)
+            return retval;
+        }
     }
 
   return retval;
@@ -581,7 +581,7 @@
 
     case -1:
       retval = std::string ("a large amount of work has been expended (t =")
-	+ t_curr + ")";
+        + t_curr + ")";
       break;
 
     case -2:
@@ -590,38 +590,38 @@
 
     case -3:
       retval = std::string ("error weight became zero during problem. (t = ")
-	+ t_curr
-	+ "; solution component i vanished, and atol or atol(i) == 0)";
+        + t_curr
+        + "; solution component i vanished, and atol or atol(i) == 0)";
       break;
 
     case -6:
       retval = std::string ("repeated error test failures on the last attempted step (t = ")
-	+ t_curr + ")";
+        + t_curr + ")";
       break;
 
     case -7:
       retval = std::string ("the corrector could not converge (t = ")
-	+ t_curr + ")";
+        + t_curr + ")";
       break;
 
     case -8:
       retval = std::string ("the matrix of partial derivatives is singular (t = ")
-	+ t_curr + ")";
+        + t_curr + ")";
       break;
 
     case -9:
       retval = std::string ("the corrector could not converge (t = ")
-	+ t_curr + "; repeated test failures)";
+        + t_curr + "; repeated test failures)";
       break;
 
     case -10:
       retval = std::string ("corrector could not converge because IRES was -1 (t = ")
-	+ t_curr + ")";
+        + t_curr + ")";
       break;
 
     case -11:
       retval = std::string ("return requested in user-supplied function (t = ")
-	+ t_curr + ")";
+        + t_curr + ")";
       break;
 
     case -12: