--- a/src/function.h	Tue Aug 12 15:42:50 2014 +0200
+++ b/src/function.h	Thu Aug 14 12:26:55 2014 +0200
@@ -28,98 +28,98 @@
 class function : public octave_base_value
 {
 
- public:
+public:
 
   function ()
     : octave_base_value (), fun () {}
 
-  function (std::string & _str, 
+  function (std::string & _str,
             SHARED_PTR <const dolfin::Function> _fun)
-    : octave_base_value (), str(_str), fun (_fun) {}
+    : octave_base_value (), str (_str), fun (_fun) {}
 
-  function (function const& _func)
+  function (function const & _func)
     : octave_base_value (), str (_func.get_str ()), fun (_func.get_pfun ()) {}
 
-  void 
-  print (std::ostream& os,
+  void
+  print (std::ostream & os,
          bool pr_as_read_syntax = false) const
-    { os << "Function " << str << ": " << fun->str (true) << std::endl; }
+  { os << "Function " << str << ": " << fun->str (true) << std::endl; }
 
-  ~function(void) {}
+  ~function (void) {}
 
-  bool 
+  bool
   is_defined (void) const
-    { return true; }
+  { return true; }
 
   const dolfin::Function &
   get_fun (void) const
-    { return (*fun); }
+  { return (*fun); }
 
   const SHARED_PTR <const dolfin::Function> &
   get_pfun (void) const
-    { return fun; }
+  { return fun; }
 
-  void 
+  void
   set_fun (dolfin::Function & _fun)
-    {
-      dolfin::Function * p = new dolfin::Function (_fun);
-      fun = SHARED_PTR <const dolfin::Function> (p);
-    }
+  {
+    dolfin::Function * p = new dolfin::Function (_fun);
+    fun = SHARED_PTR <const dolfin::Function> (p);
+  }
 
-  const std::string & 
+  const std::string &
   get_str (void) const
-    { return str; }
+  { return str; }
 
   octave_value
-  subsref (const std::string& type,
-           const std::list<octave_value_list>& idx)
-    {
-      octave_value retval;
-      retval = subsref (type, idx, 1);
-      return retval;
-    }
+  subsref (const std::string & type,
+           const std::list<octave_value_list> & idx)
+  {
+    octave_value retval;
+    retval = subsref (type, idx, 1);
+    return retval;
+  }
 
   octave_value_list
-  subsref (const std::string& type,
-           const std::list<octave_value_list>& idx,
+  subsref (const std::string & type,
+           const std::list<octave_value_list> & idx,
            int nargout)
-    {
-      octave_value_list retval;
+  {
+    octave_value_list retval;
 
-      switch (type[0])
+    switch (type[0])
+      {
+      case '(':
         {
-        case '(':
-          {
-            retval = do_multi_index_op (nargout, idx.front ());
-          }
-          break;
+          retval = do_multi_index_op (nargout, idx.front ());
+        }
+        break;
 
-        case '{':
-        case '.':
-          {
-            std::string nm = type_name ();
-            error ("%s cannot be indexed with %c", nm.c_str (), type[0]);
-          }
-          break;
+      case '{':
+      case '.':
+        {
+          std::string nm = type_name ();
+          error ("%s cannot be indexed with %c", nm.c_str (), type[0]);
+        }
+        break;
 
-        default:
-          panic_impossible ();
-        }
+      default:
+        { panic_impossible (); }
+      }
 
-      return retval;
-    }
+    return retval;
+  }
 
   octave_value_list
-  do_multi_index_op (int nargout, const octave_value_list& idx)
-    {
-      octave_value_list retval;
-      std::list<octave_value_list> args (1, idx);
-      args.push_front (octave_value (new function (*this)));
-      retval = feval ("feval", args, nargout);
-      return retval;
-    }
+  do_multi_index_op (int nargout, const octave_value_list & idx)
+  {
+    octave_value_list retval;
+    std::list<octave_value_list> args (1, idx);
+    args.push_front (octave_value (new function (*this)));
+    retval = feval ("feval", args, nargout);
+    return retval;
+  }
 
- private:
+private:
 
   std::string str;
   SHARED_PTR <const dolfin::Function> fun;