Mercurial > octave-nkf

changeset 8333:9238637cb81c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
style fixes
author John W. Eaton <jwe@octave.org>
date Tue, 18 Nov 2008 11:14:31 -0500
parents 34fde4755a0f
children 70dd33450061
files configure.in liboctave/Array-util.cc liboctave/Array.cc liboctave/Array.h liboctave/idx-vector.cc liboctave/idx-vector.h liboctave/oct-inttypes.cc liboctave/oct-inttypes.h src/Cell.h src/DLD-FUNCTIONS/__contourc__.cc src/DLD-FUNCTIONS/amd.cc src/DLD-FUNCTIONS/fltk_backend.cc src/OPERATORS/op-range.cc src/error.cc src/graphics.cc src/graphics.h.in src/ov-builtin.cc src/pr-output.cc
diffstat 18 files changed, 156 insertions(+), 128 deletions(-) [+]
line wrap: on
line diff
--- a/configure.in	Tue Nov 18 10:01:58 2008 -0500
+++ b/configure.in	Tue Nov 18 11:14:31 2008 -0500
@@ -1977,8 +1977,8 @@
 #endif
 
 // To be able to use long doubles for 64-bit mixed arithmetics, we need them at
-// least 80 bits wide and we need roundl declared in math.h
-// FIXME: Maybe substitute this by a more precise check in the future.
+// least 80 bits wide and we need roundl declared in math.h.
+// FIXME -- maybe substitute this by a more precise check in the future.
 #if (SIZEOF_LONG_DOUBLE >= 10) && defined (HAVE_ROUNDL)
 #define OCTAVE_INT_USE_LONG_DOUBLE
 #endif
--- a/liboctave/Array-util.cc	Tue Nov 18 10:01:58 2008 -0500
+++ b/liboctave/Array-util.cc	Tue Nov 18 11:14:31 2008 -0500
@@ -29,7 +29,8 @@
 #include "lo-error.h"
 
 bool
-index_in_bounds (const Array<octave_idx_type>& ra_idx, const dim_vector& dimensions)
+index_in_bounds (const Array<octave_idx_type>& ra_idx,
+		 const dim_vector& dimensions)
 {
   bool retval = true;
 
@@ -339,7 +340,8 @@
 }
 
 Array<octave_idx_type>
-get_elt_idx (const Array<idx_vector>& ra_idx, const Array<octave_idx_type>& result_idx)
+get_elt_idx (const Array<idx_vector>& ra_idx,
+	     const Array<octave_idx_type>& result_idx)
 {
   octave_idx_type n = ra_idx.length ();
 
@@ -375,7 +377,8 @@
   octave_idx_type var = 1;
   for (int i = 0; i < n_dims; i++)
     {
-      std::cout << "idx: " << idx << ", var: " << var << ", dims(" << i << "): " << dims(i) <<"\n";
+      std::cout << "idx: " << idx << ", var: " << var
+		<< ", dims(" << i << "): " << dims(i) <<"\n";
       retval(i) = ((int)floor(((idx) / (double)var))) % dims(i);
       idx -= var * retval(i);
       var = dims(i);
@@ -397,7 +400,7 @@
   bool all_colons = true;
   for (int i = 0; i < ial; i++)
     {
-      // FIXME: should we check for length() instead?
+      // FIXME -- should we check for length() instead?
       scalar[i] = ia(i).is_scalar ();
       colon[i] = ia(i).is_colon ();
       if (! scalar[i]) nonsc++;
@@ -406,8 +409,8 @@
     }
 
   bool match = false;
-  // If the number of nonscalar indices matches the dimensionality of RHS,
-  // we try an exact match, inquiring even singleton dimensions.
+  // If the number of nonscalar indices matches the dimensionality of
+  // RHS, we try an exact match, inquiring even singleton dimensions.
   if (all_colons)
     {
       rdv = rhdv;
--- a/liboctave/Array.cc	Tue Nov 18 10:01:58 2008 -0500
+++ b/liboctave/Array.cc	Tue Nov 18 11:14:31 2008 -0500
@@ -749,22 +749,27 @@
     }
   else
     {
-      // FIXME: This is the only place where orig_dimensions are used.
+      // FIXME -- this is the only place where orig_dimensions are used.
       dim_vector rd = i.orig_dimensions ();
       octave_idx_type il = i.length (n);
 
-      // FIXME: This is for Matlab compatibility. Matlab 2007 given `b = ones(3,1)'
+      // FIXME -- this is for Matlab compatibility.  Matlab 2007 given
+      //
+      //   b = ones(3,1)
+      //
       // yields the following:
-      // b(zeros(0,0)) gives []
-      // b(zeros(1,0)) gives zeros(0,1)
-      // b(zeros(0,1)) gives zeros(0,1)
-      // b(zeros(0,m)) gives zeros(0,m)
-      // b(zeros(m,0)) gives zeros(m,0)
-      // b(1:2) gives ones(2,1)
-      // b(ones(2)) gives ones(2) etc.
+      //
+      //   b(zeros(0,0)) gives []
+      //   b(zeros(1,0)) gives zeros(0,1)
+      //   b(zeros(0,1)) gives zeros(0,1)
+      //   b(zeros(0,m)) gives zeros(0,m)
+      //   b(zeros(m,0)) gives zeros(m,0)
+      //   b(1:2) gives ones(2,1)
+      //   b(ones(2)) gives ones(2) etc.
+      //
       // As you can see, the behaviour is weird, but the tests end up pretty
-      // simple. Nah, I don't want to suggest that this is ad hoc :) Neither do
-      // I want to say that Matlab is a lousy piece of s...oftware.
+      // simple.  Nah, I don't want to suggest that this is ad hoc :)
+
       if (ndims () == 2 && n != 1)
         {
           if (columns () == 1 && rd(0) == 1)
@@ -773,7 +778,8 @@
             rd = dim_vector (1, il);
         }
 
-      // Don't use resize here to avoid useless initialization for POD types.
+      // Don't use resize here to avoid useless initialization for POD
+      // types.
       retval = Array<T> (rd);
 
       if (il != 0)
@@ -887,18 +893,19 @@
   return retval;
 }
 
-// FIXME: the following is a common error message to resize, regardless of whether it's
-// called from assign or elsewhere. It seems OK to me, but eventually the gripe can be
-// specialized. Anyway, propagating various error messages into procedure is, IMHO, a
-// nonsense. If anything, we should change error handling here (and throughout liboctave)
-// to allow custom handling of errors
+// FIXME -- the following is a common error message to resize,
+// regardless of whether it's called from assign or elsewhere.  It
+// seems OK to me, but eventually the gripe can be specialized.
+// Anyway, propagating various error messages into procedure is, IMHO,
+// a nonsense.  If anything, we should change error handling here (and
+// throughout liboctave) to allow custom handling of errors
 static void gripe_invalid_resize (void)
 {
   (*current_liboctave_error_handler)
     ("resize: Invalid resizing operation or ambiguous assignment to an out-of-bounds array element.");
 }
 
-// The default fill value. Override if you want a different one.
+// The default fill value.  Override if you want a different one.
 
 template <class T>
 T Array<T>::resize_fill_value ()
@@ -906,8 +913,8 @@
   return T ();
 }
 
-// Yes, we could do resize using index & assign.  However, that would possibly
-// involve a lot more memory traffic than we actually need.
+// Yes, we could do resize using index & assign.  However, that would
+// possibly involve a lot more memory traffic than we actually need.
 
 template <class T>
 void
@@ -916,13 +923,13 @@
   if (n >= 0 && ndims () == 2)
     {
       dim_vector dv;
-      // This is driven by Matlab's behaviour of giving a *row* vector on
-      // some out-of-bounds assignments. Specifically, matlab allows a(i) with
-      // out-of-bouds i when a is either of 0x0, 1x0, 1x1, 0xN, and gives
-      // a row vector in all cases (yes, even the last one, search me why).
-      // Giving a column vector would make much more sense (given the way
-      // trailing singleton dims are treated), but hey, Matlab is not here to
-      // make sense, it's here to make money ;)
+      // This is driven by Matlab's behaviour of giving a *row* vector
+      // on some out-of-bounds assignments.  Specifically, Matlab
+      // allows a(i) with out-of-bouds i when a is either of 0x0, 1x0,
+      // 1x1, 0xN, and gives a row vector in all cases (yes, even the
+      // last one, search me why).  Giving a column vector would make
+      // much more sense (given the way trailing singleton dims are
+      // treated).
       bool invalid = false;
       if (rows () == 0 || rows () == 1)
         dv = dim_vector (1, n);          
@@ -1144,8 +1151,9 @@
   dim_vector dv = dimensions.redim (2);
   // Check for out-of-bounds and form resizing dimensions.
   dim_vector rdv; 
-  // In the special when all dimensions are zero, colons are allowed to inquire
-  // the shape of RHS. The rules are more obscure, so we solve that elsewhere.
+  // In the special when all dimensions are zero, colons are allowed
+  // to inquire the shape of RHS.  The rules are more obscure, so we
+  // solve that elsewhere.
   if (dv.all_zero ())
     rdv = zero_dims_inquire (i, j, rhdv);
   else
@@ -1157,7 +1165,8 @@
   bool isfill = rhs.numel () == 1;
   octave_idx_type il = i.length (rdv(0)), jl = j.length (rdv(1));
   rhdv.chop_all_singletons ();
-  bool match = isfill || (rhdv.length () == 2 && il == rhdv(0) && jl == rhdv(1));
+  bool match = (isfill
+		|| (rhdv.length () == 2 && il == rhdv(0) && jl == rhdv(1)));
   match = match || (il == 1 && jl == rhdv(0) && rhdv(1) == 1);
 
   if (match)
@@ -1242,9 +1251,9 @@
       // Get the extents forced by indexing. 
       dim_vector rdv;
 
-      // In the special when all dimensions are zero, colons are allowed to
-      // inquire the shape of RHS. The rules are more obscure, so we solve that
-      // elsewhere.
+      // In the special when all dimensions are zero, colons are
+      // allowed to inquire the shape of RHS.  The rules are more
+      // obscure, so we solve that elsewhere.
       if (dv.all_zero ())
         rdv = zero_dims_inquire (ia, rhdv);
       else
@@ -1691,7 +1700,7 @@
     }
   else
     {
-      // Fast transpose for vectors and empty matrices
+      // Fast transpose for vectors and empty matrices.
       return Array<T> (*this, dim_vector (nc, nr));
     }
 }
--- a/liboctave/Array.h	Tue Nov 18 10:01:58 2008 -0500
+++ b/liboctave/Array.h	Tue Nov 18 11:14:31 2008 -0500
@@ -458,11 +458,14 @@
   void resize (octave_idx_type n)
     { resize_fill (n, resize_fill_value ()); }
 
-  // FIXME: This method cannot be defined here because it would clash with
+  // FIXME -- this method cannot be defined here because it would
+  // clash with
+  //
   //   void resize (octave_idx_type, const T&)
-  // (these become undistinguishable when T = octave_idx_type). 
-  // In the future, I think the resize (.., const T& rfv) overloads should go away
-  // in favor of using resize_fill.
+  //
+  // (these become indistinguishable when T = octave_idx_type).
+  // In the future, I think the resize (.., const T& rfv) overloads
+  // should go away in favor of using resize_fill.
 
   // void resize (octave_idx_type nr, octave_idx_type nc)
   //  { resize_fill (nr, nc, resize_fill_value ()); }
@@ -470,8 +473,8 @@
   void resize (dim_vector dv)
     { resize_fill (dv, resize_fill_value ()); }
 
-  // FIXME: these are here for backward compatibility. They should go away in favor
-  // of using resize_fill directly.
+  // FIXME -- these are here for backward compatibility. They should
+  // go away in favor of using resize_fill directly.
   void resize (octave_idx_type n, const T& rfv)
     { resize_fill (n, static_cast<T> (rfv)); }
 
@@ -482,8 +485,8 @@
     { resize_fill (dv, rfv); }
 
   // Indexing with possible resizing and fill
-  // FIXME: This is really a corner case, that should better be handled
-  // directly in liboctinterp.
+  // FIXME -- this is really a corner case, that should better be
+  // handled directly in liboctinterp.
 
   Array<T> index (const idx_vector& i, bool resize_ok,
                   const T& rfv = resize_fill_value ()) const;
@@ -516,7 +519,7 @@
   // Dispatcher to the above two.
   void delete_elements (const Array<idx_vector>& ia);
 
-  // FIXME: are these required? What exactly are they supposed to do?.
+  // FIXME -- are these required? What exactly are they supposed to do?.
 
   Array<T>& insert (const Array<T>& a, octave_idx_type r, octave_idx_type c);
   Array<T>& insert2 (const Array<T>& a, octave_idx_type r, octave_idx_type c);
@@ -561,10 +564,11 @@
 #define INSTANTIATE_ARRAY(T, API) \
   template class API Array<T>
 
-// FIXME: These are here for compatibility. In current implementation, only
-// homogeneous array assignments are actually instantiated. I think heterogeneous
-// indexed assignments are rare enough to be implemented via conversion first.
-// This decision may still be revised, that's why these macros stay here.
+// FIXME -- these are here for compatibility.  In the current
+// implementation, only homogeneous array assignments are actually
+// instantiated.  I think heterogeneous indexed assignments are rare
+// enough to be implemented via conversion first.  This decision may
+// still be revised, that's why these macros stay here.
 #define INSTANTIATE_ARRAY_AND_ASSIGN(T, API) \
   INSTANTIATE_ARRAY(T, API)
 
--- a/liboctave/idx-vector.cc	Tue Nov 18 10:01:58 2008 -0500
+++ b/liboctave/idx-vector.cc	Tue Nov 18 11:14:31 2008 -0500
@@ -37,19 +37,22 @@
 #include "lo-error.h"
 #include "lo-mappers.h"
 
-static void gripe_invalid_index ()
+static void
+gripe_invalid_index (void)
 {
   (*current_liboctave_error_handler)
     ("subscript indices must be either positive integers or logicals.");
 }
 
-static void gripe_invalid_range ()
+static void
+gripe_invalid_range (void)
 {
   (*current_liboctave_error_handler)
     ("invalid range used as index.");
 }
 
-static void gripe_index_out_of_range ()
+static void
+gripe_index_out_of_range (void)
 {
   (*current_liboctave_error_handler)
     ("internal error: idx_vector index out of range.");
@@ -99,7 +102,8 @@
     }
 }
 
-static void gripe_non_int_range ()
+static void
+gripe_non_int_range (void)
 {
   (*current_liboctave_error_handler)
     ("If a range is used as subscript, all elements are expected to be integers.");
@@ -458,8 +462,9 @@
   return reduced;
 }
 
-bool idx_vector::is_cont_range (octave_idx_type n,
-                                octave_idx_type& l, octave_idx_type& u) const
+bool
+idx_vector::is_cont_range (octave_idx_type n,
+			   octave_idx_type& l, octave_idx_type& u) const
 {
   bool res = false;
   switch (rep->idx_class ())
--- a/liboctave/idx-vector.h	Tue Nov 18 10:01:58 2008 -0500
+++ b/liboctave/idx-vector.h	Tue Nov 18 11:14:31 2008 -0500
@@ -79,7 +79,7 @@
     virtual octave_idx_type extent (octave_idx_type n) const = 0;
 
     // Index class.
-    virtual idx_class_type idx_class () const { return class_invalid; }
+    virtual idx_class_type idx_class (void) const { return class_invalid; }
 
     // Sorts, maybe uniqifies, and returns a clone object pointer.
     virtual idx_base_rep *sort_uniq_clone (bool uniq = false) = 0;
@@ -89,7 +89,7 @@
       { return false; }
 
     // The original dimensions of this object (used when subscribing by matrices).
-    virtual dim_vector orig_dimensions () const
+    virtual dim_vector orig_dimensions (void) const
       { return dim_vector (); }
 
     // i/o
@@ -124,7 +124,7 @@
     octave_idx_type extent (octave_idx_type n) const
       { return n; }
 
-    idx_class_type idx_class () const { return class_colon; }
+    idx_class_type idx_class (void) const { return class_colon; }
 
     idx_base_rep *sort_uniq_clone (bool = false) 
       { count++; return this; }
@@ -171,19 +171,19 @@
     octave_idx_type extent (octave_idx_type n) const
       { return len ? std::max (n, (start + 1 + (step < 0 ? 0 : step * (len - 1)))) : n; }
 
-    idx_class_type idx_class () const { return class_range; }
+    idx_class_type idx_class (void) const { return class_range; }
 
     idx_base_rep *sort_uniq_clone (bool uniq = false);
 
     bool is_colon_equiv (octave_idx_type n) const
       { return start == 0 && step == 1 && len == n; }
 
-    dim_vector orig_dimensions () const
+    dim_vector orig_dimensions (void) const
       { return dim_vector (1, len); }
 
-    octave_idx_type get_start () const { return start; }
+    octave_idx_type get_start (void) const { return start; }
 
-    octave_idx_type get_step () const { return step; }
+    octave_idx_type get_step (void) const { return step; }
 
     std::ostream& print (std::ostream& os) const;
 
@@ -223,7 +223,7 @@
     octave_idx_type extent (octave_idx_type n) const
       { return std::max (n, data + 1); }
 
-    idx_class_type idx_class () const { return class_scalar; }
+    idx_class_type idx_class (void) const { return class_scalar; }
 
     idx_base_rep *sort_uniq_clone (bool = false)
       { count++; return this; }
@@ -231,10 +231,10 @@
     bool is_colon_equiv (octave_idx_type n) const
       { return n == 1 && data == 0; }
 
-    dim_vector orig_dimensions () const
+    dim_vector orig_dimensions (void) const
       { return dim_vector (1, 1); }
 
-    octave_idx_type get_data () const { return data; }
+    octave_idx_type get_data (void) const { return data; }
 
     std::ostream& print (std::ostream& os) const;
 
@@ -283,14 +283,14 @@
     octave_idx_type extent (octave_idx_type n) const
       { return std::max (n, ext); }
 
-    idx_class_type idx_class () const { return class_vector; }
+    idx_class_type idx_class (void) const { return class_vector; }
 
     idx_base_rep *sort_uniq_clone (bool uniq = false);
 
-    dim_vector orig_dimensions () const
+    dim_vector orig_dimensions (void) const
       { return orig_dims; }
 
-    const octave_idx_type *get_data () const { return data; }
+    const octave_idx_type *get_data (void) const { return data; }
 
     std::ostream& print (std::ostream& os) const;
 
@@ -317,14 +317,14 @@
   idx_vector (idx_base_rep *r) : rep (r) { }
 
   // The shared empty vector representation (for fast default constructor)
-  static idx_vector_rep *nil_rep ()
+  static idx_vector_rep *nil_rep (void)
     {
       static idx_vector_rep ivr;
       return &ivr;
     }
 
   // The shared empty vector representation with the error flag set.
-  static idx_vector_rep *err_rep ()
+  static idx_vector_rep *err_rep (void)
     {
       static idx_vector_rep ivr;
       ivr.err = true;
@@ -441,7 +441,7 @@
 #endif
     }
 
-  operator bool () const
+  operator bool (void) const
     { return ! rep->err; }
 
   bool is_colon (void) const 
@@ -458,10 +458,10 @@
 
   dim_vector orig_dimensions (void) const { return rep->orig_dimensions (); }
 
-  octave_idx_type orig_rows () const
+  octave_idx_type orig_rows (void) const
     { return orig_dimensions () (0); }
 
-  octave_idx_type orig_columns () const
+  octave_idx_type orig_columns (void) const
     { return orig_dimensions () (1); }
 
   int orig_empty (void) const
@@ -719,8 +719,8 @@
   idx_vector
   complement (octave_idx_type n) const;
 
-  // FIXME: These are here for compatibility. They should be removed when no
-  // longer in use.
+  // FIXME -- these are here for compatibility.  They should be removed
+  // when no longer in use.
 
   octave_idx_type elem (octave_idx_type n) const 
     { return (*this) (n); }
@@ -728,14 +728,15 @@
   bool is_colon_equiv (octave_idx_type n, int) const
     { return is_colon_equiv (n); }
 
-  octave_idx_type freeze (octave_idx_type z_len, const char *tag, bool resize_ok = false);
+  octave_idx_type
+  freeze (octave_idx_type z_len, const char *tag, bool resize_ok = false);
 
   void sort (bool uniq = false)
     { *this = sorted (uniq); }
 
-  octave_idx_type ones_count () const;
+  octave_idx_type ones_count (void) const;
 
-  octave_idx_type max () const { return extent (1) - 1; }
+  octave_idx_type max (void) const { return extent (1) - 1; }
   
 private:
 
--- a/liboctave/oct-inttypes.cc	Tue Nov 18 10:01:58 2008 -0500
+++ b/liboctave/oct-inttypes.cc	Tue Nov 18 11:14:31 2008 -0500
@@ -194,7 +194,7 @@
   
   // Essentially, what we do is compute sign, multiply absolute values
   // (as above) and impose the sign.
-  // FIXME: Can we do something faster if we HAVE_FAST_INT_OPS?
+  // FIXME -- can we do something faster if we HAVE_FAST_INT_OPS?
 
   uint64_t usx = octave_int_abs (x), usy = octave_int_abs (y);
   bool positive = (x < 0) == (y < 0);
--- a/liboctave/oct-inttypes.h	Tue Nov 18 10:01:58 2008 -0500
+++ b/liboctave/oct-inttypes.h	Tue Nov 18 11:14:31 2008 -0500
@@ -45,9 +45,9 @@
 #undef max
 #endif
 
-// FIXME: we define this by our own because some compilers, such as MSVC,
-// do not provide std::abs (int64_t) and std::abs (uint64_t). In the future,
-// it should go away in favor of std::abs.
+// FIXME -- we define this by our own because some compilers, such as
+// MSVC, do not provide std::abs (int64_t) and std::abs (uint64_t).  In
+// the future, it should go away in favor of std::abs.
 template <class T>
 inline T octave_int_abs (T x) { return x >= 0 ? x : -x; }
 
@@ -282,7 +282,7 @@
       val = xround (val); // Fool optimizations (maybe redundant)
       // If val is even, but orig_val is odd, we're one unit off.
       if (orig_val % 2 && val / 2 == xround (val / 2))
-        // FIXME: is this always correct?
+        // FIXME -- is this always correct?
         val *= (static_cast<S>(1) - (std::numeric_limits<S>::epsilon () / 2)); 
       return val;
     }
@@ -546,9 +546,9 @@
       return ((x > 0) ? 1 : 0) - signbit (x); 
     }
 
-  // FIXME: We do not have an authority what signed shifts should exactly do, so
-  // we define them the easy way. Note that Matlab does not define signed
-  // shifts.
+  // FIXME -- we do not have an authority what signed shifts should
+  // exactly do, so we define them the easy way. Note that Matlab does
+  // not define signed shifts.
 
   static T
   rshift (T x, int n) { return x >> n; }
@@ -714,8 +714,11 @@
       else
         {
           z = x / y;
-          // FIXME: this is a workaround due to MSVC's absence of std::abs (int64_t).
-          T w = octave_int_abs (x % y); // Can't overflow, but std::abs (x) can!
+          // FIXME -- this is a workaround due to MSVC's absence of
+          // std::abs (int64_t).  The call to octave_int_abs can't
+          // overflow, but std::abs (x) can!
+	  T w = octave_int_abs (x % y);
+
           if (w >= y - w) 
             z += 1 - (signbit (x) << 1);
         }
@@ -884,7 +887,7 @@
 xisnan (const octave_int<T>&)
 { return false; }
 
-// FIXME: Can/should any of these be inline?
+// FIXME -- can/should any of these be inline?
 
 template <class T>
 extern OCTAVE_API octave_int<T>
--- a/src/Cell.h	Tue Nov 18 10:01:58 2008 -0500
+++ b/src/Cell.h	Tue Nov 18 11:14:31 2008 -0500
@@ -89,8 +89,9 @@
 	      const octave_value& rfv = resize_fill_value ()) const
     { return Cell (ArrayN<octave_value>::index (ra_idx, resize_ok, rfv)); }
 
-  // FIXME: This seems necessary for octave_base_mat<Cell>::delete_elements
-  // to work, but I don't understand why.
+  // FIXME -- this seems necessary for
+  // octave_base_mat<Cell>::delete_elements to work, but I don't
+  // understand why.
   void delete_elements (const Array<idx_vector>& ia)
     { ArrayN<octave_value>::delete_elements (ia); }
 
@@ -99,7 +100,7 @@
   Cell& assign (const octave_value_list& idx, const Cell& rhs,
 		const octave_value& fill_val = octave_value ());
 
-  // FIXME: This seems necessary for octave_base_mat<Cell>::assign
+  // FIXME -- this seems necessary for octave_base_mat<Cell>::assign
   // to work, but I don't understand why.
   void assign (const Array<idx_vector>& ia, const Array<octave_value>& rhs,
                const octave_value& fill_val = octave_value ())
--- a/src/DLD-FUNCTIONS/__contourc__.cc	Tue Nov 18 10:01:58 2008 -0500
+++ b/src/DLD-FUNCTIONS/__contourc__.cc	Tue Nov 18 11:14:31 2008 -0500
@@ -158,7 +158,8 @@
       start_contour (lvl, ct_x, ct_y);
     }
 
-  // Find stop edge FIXME: control flow --> while.
+  // Find stop edge.
+  // FIXME -- perhaps this should use a while loop?
   for (unsigned int k = 1; k <= 4; k++)
     {
       if (start_edge == 0 || start_edge == 2)
--- a/src/DLD-FUNCTIONS/amd.cc	Tue Nov 18 10:01:58 2008 -0500
+++ b/src/DLD-FUNCTIONS/amd.cc	Tue Nov 18 11:14:31 2008 -0500
@@ -168,8 +168,8 @@
 	      Matrix xinfo (AMD_INFO, 1);
 	      double *Info = xinfo.fortran_vec ();
 
-	      // FIXME: How can we manage the memory allocation of amd in 
-	      // a cleaner manner? 
+	      // FIXME -- how can we manage the memory allocation of
+	      // amd in a cleaner manner? 
 	      amd_malloc = malloc;
 	      amd_free = free;
 	      amd_calloc = calloc;
--- a/src/DLD-FUNCTIONS/fltk_backend.cc	Tue Nov 18 10:01:58 2008 -0500
+++ b/src/DLD-FUNCTIONS/fltk_backend.cc	Tue Nov 18 11:14:31 2008 -0500
@@ -764,7 +764,7 @@
 	    switch (id)
 	      {
 	      case base_properties::VISIBLE:
-		// FIXME: something to do here
+		// FIXME -- something to do here.
 		break;
 	      }
 	  }
--- a/src/OPERATORS/op-range.cc	Tue Nov 18 10:01:58 2008 -0500
+++ b/src/OPERATORS/op-range.cc	Tue Nov 18 11:14:31 2008 -0500
@@ -117,8 +117,9 @@
 
   INSTALL_CONVOP (octave_range, octave_float_matrix, range_to_float_matrix);
 
-  // FIXME: this would be unneccessary if octave_base_value::numeric_assign always tried converting
-  // lhs before rhs.
+  // FIXME -- this would be unneccessary if
+  // octave_base_value::numeric_assign always tried converting lhs
+  // before rhs.
   
   INSTALL_ASSIGNCONV (octave_range, octave_null_matrix, octave_matrix);
   INSTALL_ASSIGNCONV (octave_range, octave_null_str, octave_matrix);
--- a/src/error.cc	Tue Nov 18 10:01:58 2008 -0500
+++ b/src/error.cc	Tue Nov 18 11:14:31 2008 -0500
@@ -876,7 +876,7 @@
 		rethrow_error (id.c_str (), "%s", tmp_msg);
 	      delete [] tmp_msg;
 
-	      // FIXME: Need to restore the stack as rethrow_error sets it?
+	      // FIXME -- Need to restore the stack as rethrow_error sets it?
 	      Vlast_error_file = file;
 	      Vlast_error_name = nm;
 	      Vlast_error_line = l;
--- a/src/graphics.cc	Tue Nov 18 10:01:58 2008 -0500
+++ b/src/graphics.cc	Tue Nov 18 11:14:31 2008 -0500
@@ -194,7 +194,7 @@
     }
   else if (from_units.compare ("characters"))
     {
-      // FIXME: implement this
+      // FIXME -- implement this.
     }
   else
     {
@@ -229,7 +229,7 @@
 	}
       else if (to_units.compare ("characters"))
 	{
-	  // FIXME: implement this
+	  // FIXME -- implement this.
 	}
       else
 	{
@@ -684,7 +684,7 @@
 {
   bool xok = false;
 
-  // FIXME: should we always support []?
+  // FIXME -- should we always support []?
   if (v.is_empty () && v.is_double_type ())
     return true;
 
@@ -954,8 +954,8 @@
 	{
 	  retval.set (args(0));
 
-	  // FIXME: additional argument could define constraints
-	  //        but is this really useful...?
+	  // FIXME -- additional argument could define constraints,
+	  // but is this really useful?
 	}
     }
   else if (type.compare ("color"))
@@ -2096,7 +2096,7 @@
 figure::properties::get_boundingbox (bool) const
 {
   graphics_backend b = get_backend ();
-  // FIXME: screen size should be obtained from root object
+  // FIXME -- screen size should be obtained from root object.
   Matrix screen_size = b.get_screen_size ();
   Matrix pos;
 
@@ -2114,7 +2114,7 @@
 figure::properties::set_boundingbox (const Matrix& bb)
 {
   graphics_backend b = get_backend ();
-  // FIXME: screen size should be obtained from root object
+  // FIXME -- screen size should be obtained from root object.
   Matrix screen_size = b.get_screen_size ();
   Matrix pos = bb;
 
@@ -2801,7 +2801,7 @@
     {
       double af;
 
-      // FIXME: Was this really needed? When compared to Matlab, it
+      // FIXME -- was this really needed?  When compared to Matlab, it
       // does not seem to be required. Need investigation with concrete
       // backend to see results visually.
       if (false && dowarp)
@@ -2916,8 +2916,8 @@
 	}
     }
   
-  // FIXME: if plotboxaspectratiomode is "manual", limits
-  // and/or dataaspectratio might be adapted
+  // FIXME -- if plotboxaspectratiomode is "manual", limits
+  // and/or dataaspectratio might be adapted.
 }
 
 // The INTERNAL flag defines whether position or outerposition is used.
@@ -2999,8 +2999,8 @@
   return retval;
 }
 
-// FIXME: Remove
-// FIXME: Maybe this should go into array_property class?
+// FIXME -- remove.
+// FIXME -- maybe this should go into array_property class?
 /*
 static void
 check_limit_vals (double& min_val, double& max_val, double& min_pos,
@@ -3606,7 +3606,7 @@
       i1 = i2 = i3 = 0;
       j1 = j2 = j3 = 0;
 
-      // FIXME: normal computation at boundaries
+      // FIXME -- normal computation at boundaries.
       for (int i = 1; i < (p-1); i++)
 	{
 	  if (y_mat)
--- a/src/graphics.h.in	Tue Nov 18 10:01:58 2008 -0500
+++ b/src/graphics.h.in	Tue Nov 18 11:14:31 2008 -0500
@@ -974,7 +974,7 @@
     {
       if (validate (v))
 	{
-	  // FIXME: should we check for actual data change?
+	  // FIXME -- should we check for actual data change?
 	  if (! is_equal (v))
 	    {
 	      data = v;
@@ -1729,7 +1729,7 @@
     bool_property beingdeleted , "off"
     radio_property busyaction , "{queue}|cancel"
     callback_property buttondownfcn , Matrix ()
-    // FIXME: use a property class for children
+    // FIXME -- use a property class for children.
     Matrix children Gfs , Matrix ()
     bool_property clipping , "on"
     callback_property createfcn , Matrix ()
@@ -1747,7 +1747,7 @@
     // additional (octave-specific) properties
     bool_property __modified__ s , "on"
     graphics_handle __myhandle__ fhrs , mh
-    // FIXME: should this really be here?
+    // FIXME -- should this really be here?
     handle_property uicontextmenu , graphics_handle ()
   END_PROPERTIES
 
@@ -2646,7 +2646,7 @@
       bool_property xminortick , "off"
       bool_property yminortick , "off"
       bool_property zminortick , "off"
-      // FIXME: should be kind of string array
+      // FIXME -- should be kind of string array.
       any_property xticklabel m , ""
       any_property yticklabel m , ""
       any_property zticklabel m , ""
@@ -2687,7 +2687,7 @@
       radio_property fontunits , "{points}|normalized|inches|centimeters|pixels"
       radio_property fontweight , "{normal}|light|demi|bold"
       radio_property gridlinestyle , "-|--|{:}|-.|none"
-      // FIXME: should be kind of string array
+      // FIXME -- should be kind of string array.
       string_property linestyleorder , "-"
       double_property linewidth , 0.5
       radio_property minorgridlinestyle , "-|--|{:}|-.|none"
@@ -2698,7 +2698,7 @@
       radio_property tickdirmode , "{auto}|manual"
       array_property ticklength , Matrix (1, 2, 0.1)
       array_property tightinset r , Matrix (1, 4, 0.0)
-      // FIXME: uicontextmenu should be moved here
+      // FIXME -- uicontextmenu should be moved here.
       radio_property units , "{normalized}|inches|centimeters|points|pixels|characters"
       // hidden properties for transformation computation
       array_property x_viewtransform h , Matrix (4, 4, 0.0)
@@ -3080,11 +3080,11 @@
       }
 
   private:
-    // FIXME: limits should take pixel width into account
+    // FIXME -- limits should take pixel width into account.
     void update_xdata (void)
       { set_xlim (xdata.get_limits ()); }
 
-    // FIXME: idem
+    // FIXME -- idem.
     void update_ydata (void)
       { set_ylim (ydata.get_limits ()); }
 
--- a/src/ov-builtin.cc	Tue Nov 18 10:01:58 2008 -0500
+++ b/src/ov-builtin.cc	Tue Nov 18 11:14:31 2008 -0500
@@ -106,7 +106,7 @@
 	{
 	  retval = (*f) (args, nargout);
           // Do not allow null values to be returned from functions.
-          // FIXME: perhaps true builtins should be allowed?
+          // FIXME -- perhaps true builtins should be allowed?
           retval.normalize_null_values ();
 	}
       catch (octave_execution_exception)
--- a/src/pr-output.cc	Tue Nov 18 10:01:58 2008 -0500
+++ b/src/pr-output.cc	Tue Nov 18 11:14:31 2008 -0500
@@ -1977,7 +1977,7 @@
   octave_print_internal (os, double (d), pr_as_read_syntax); 
 }
 
-// FIXME: Write single precision versions of the printing functions
+// FIXME -- write single precision versions of the printing functions.
 
 void
 octave_print_internal (std::ostream& os, float d, bool pr_as_read_syntax)