--- a/inst/@dataframe/subsref.m
+++ b/inst/@dataframe/subsref.m
@@ -124,7 +124,7 @@
                   case "source"
                     S(1).subs = "_src";
                     further_deref = true;
-		  case "header"
+                  case "header"
                     S(1).subs = "_header";
                     further_deref = true;
                   case "comment"
@@ -277,7 +277,7 @@
           else
             dummy = max (cellfun(@length, df._rep));
             [fullindr, fullindc, fullinds] = ...
-	    ind2sub ([df._cnt dummy], S(1).subs{1});
+            ind2sub ([df._cnt dummy], S(1).subs{1});
           endif 
           
           indr = unique (fullindr); nrow = length (indr);
@@ -315,18 +315,18 @@
         output_type = asked_output_type;
       else
         %# can the data be merged ?
-	if (isempty (df))
-	   output_type = 0.0;
-	else
-	  output_type = df._data{indc(1)}(1);
+        if (isempty (df))
+           output_type = 0.0;
+        else
+          output_type = df._data{indc(1)}(1);
           dummy = isnumeric (df._data{indc(1)}); 
           for indi = (2:ncol)
             dummy = dummy & isnumeric (df._data{indc(indi)});
             if (~strcmp (class (output_type), df._type{indc(indi)}))
               if (dummy) 
-		%# let downclassing occur
-		output_type = horzcat (output_type, df._data{indc(indi)}(1));
-		continue; 
+                %# let downclassing occur
+                output_type = horzcat (output_type, df._data{indc(indi)}(1));
+                continue; 
               endif
               %# unmixable args -- falls back to type of parent container 
               error ("Selected columns %s not compatible with cat() -- use 'cell' as output format", mat2str (indc));
@@ -335,7 +335,7 @@
               break;
             endif
           endfor
-	endif
+        endif
         asked_output_format = class (output_type);
         output_type = "array";
       endif
@@ -550,42 +550,42 @@
           length (S(1).subs) > 1 || ...
           (isnumeric (S(1).subs{1}) && ~isvector(S(1).subs{1}))) 
         %# access-as-matrix
-	if (isempty (df))
-	   resu = [];
-	else
+        if (isempty (df))
+           resu = [];
+        else
           df = struct (df);        %# remove the magic, avoid recursive calls 
           if (isempty (fullindr)) %# two index access
             if (~isempty (asked_output_format)) %# force a conversion
               if (strmatch (asked_output_format, 'cell'))
-		extractfunc = @(x) mat2cell...
-			       (df._data{indc(x)}(indr, df._rep{indc(x)}(inds)), ...
-				ones (nrow, 1));
+                extractfunc = @(x) mat2cell...
+                               (df._data{indc(x)}(indr, df._rep{indc(x)}(inds)), ...
+                                ones (nrow, 1));
               else
-		extractfunc = @(x) cast ( df._data{indc(x)}...
-						  (indr, df._rep{indc(x)}(inds)),...
-					  asked_output_format);
+                extractfunc = @(x) cast ( df._data{indc(x)}...
+                                                  (indr, df._rep{indc(x)}(inds)),...
+                                          asked_output_format);
               endif
             else %# let the usual downclassing occur
               extractfunc = @(x) df._data{indc(x)}(indr, df._rep{indc(x)}(inds));
             endif 
             try
               if (nseq > 1)
-		dummy = reshape (extractfunc (1), nrow, 1, []); 
-		if (size (dummy, 3) < nseq)
+                dummy = reshape (extractfunc (1), nrow, 1, []); 
+                if (size (dummy, 3) < nseq)
                   dummy = repmat (dummy, [1 1 nseq]);
-		endif
+                endif
               else
-		dummy = extractfunc (1);
+                dummy = extractfunc (1);
               endif
             catch
-	      error ("Column %d format (%s) can't be converted to %s", ...
+              error ("Column %d format (%s) can't be converted to %s", ...
                      indc(1), df._type{indc(1)}, asked_output_format);
             end_try_catch
             if (ncol > 1)
               %# dynamic allocation with the final type
               resu = repmat (dummy, [1 ncol]);
               for indi = (2:ncol)
-		try
+                try
                   if (nseq > 1)
                     dummy = reshape (extractfunc (indi), nrow, 1, []);
                     if (size (dummy, 3) < nseq)
@@ -594,31 +594,31 @@
                   else
                     dummy = extractfunc (indi);
                   endif
-		catch
+                catch
                   error ("Column %d format (%s) can't be converted to %s", ...
-			 indc(indi), df._type{indc(indi)}, asked_output_format);
-		end_try_catch
-		resu(:, indi, :) = dummy;
+                         indc(indi), df._type{indc(indi)}, asked_output_format);
+                end_try_catch
+                resu(:, indi, :) = dummy;
               endfor
             else
               if (strcmp (df._type{indc(1)}, 'char'))
-		resu = char (dummy);
+                resu = char (dummy);
               else
-		resu = dummy;
+                resu = dummy;
               endif
             endif
             if (~isempty (S) && 2 == length (S(1).subs) ...
-		&& all (cellfun ('isclass', S(1).subs, 'char')))
+                && all (cellfun ('isclass', S(1).subs, 'char')))
               resu = reshape (resu, nrow, ncol*nseq);
             endif
-	  else %# one index access
+          else %# one index access
             %# disp('line 557'); keyboard
             if (~isempty (asked_output_format)) %# force a conversion
               if (strmatch (asked_output_format, 'cell'))
-		extractfunc = @(x, y) mat2cell (df._data{x}(:, df._rep{x}(y)), ...
-						ones (length (y), 1));
+                extractfunc = @(x, y) mat2cell (df._data{x}(:, df._rep{x}(y)), ...
+                                                ones (length (y), 1));
               else
-		extractfunc = @(x, y) cast (df._data{x}(:, df._rep{x})(y), ...
+                extractfunc = @(x, y) cast (df._data{x}(:, df._rep{x})(y), ...
                                             asked_output_format);      
               endif
             else %# let the usual downclassing occur
@@ -628,11 +628,11 @@
               resu = zeros(0, class (sum (cellfun (@(x) zeros (1, class (x(1))),...
                                                    df._data(indc)))));
               for indi = (indc)
-		dummy = find (indi == fullindc);   %# linear global index
-		%# linear index for this matrix
-		idx = sub2ind (size (df._data{indi}), fullindr(dummy), ...
+                dummy = find (indi == fullindc);   %# linear global index
+                %# linear index for this matrix
+                idx = sub2ind (size (df._data{indi}), fullindr(dummy), ...
                                fullinds(dummy));
-		resu(dummy) = extractfunc (indi, idx);
+                resu(dummy) = extractfunc (indi, idx);
               endfor
             catch
               disp (lasterr); 
@@ -641,7 +641,7 @@
             end_try_catch
             resu = reshape (resu, size (onedimidx));
           endif
-	endif
+        endif
       else %# access-as-vector
         %# disp('line 548 '); keyboard
         if (~isempty (fullindr))