--- a/inst/@dataframe/subsref.m
+++ b/inst/@dataframe/subsref.m
@@ -81,7 +81,7 @@
               indi = strmatch (S(1).subs, resu._name{2}, "exact");
               if (~isempty (indi))
                 resu = df._data{indi}; %# extract colum;
-                if (strcmp (df._type{indi}, 'char') \
+                if (strcmp (df._type{indi}, 'char') ...
                     && 1 == size (df._data{indi}, 2))
                   resu = char (resu)
                 endif 
@@ -90,7 +90,7 @@
                   switch dummy(1).type
                     case '()'
                       if (isa (dummy(1).subs{1}, "char"))
-                        [indr, nrow, dummy(1).subs{1}] = \
+                        [indr, nrow, dummy(1).subs{1}] = ...
                             df_name2idx(df._name{1}, dummy(1).subs{1}, df._cnt(1), 'row');
                       endif
                       resu = feval(@subsref, resu, dummy);
@@ -151,8 +151,8 @@
                     error ("Invalid sub-dereferencing");
                   endif
                   if (isa (dummy(1).subs{1}, "char"))
-                    [indc, ncol, dummy(1).subs{1}] = \
-                        df_name2idx (df._name{2}, dummy(1).subs{1}, \
+                    [indc, ncol, dummy(1).subs{1}] = ...
+                        df_name2idx (df._name{2}, dummy(1).subs{1}, ...
                                      df._cnt(2), 'column');
                     if (isempty (indc)) 
                       %# should be already catched  inside df_name2idx
@@ -227,12 +227,12 @@
         if (isempty (S(1).subs{2}))
           error ('subsref: second dimension empty ???');
         endif
-        [indr, nrow, S(1).subs{1}] = \
+        [indr, nrow, S(1).subs{1}] = ...
             df_name2idx (df._name{1}, S(1).subs{1}, df._cnt(1), 'row');      
         if (~isa(indr, 'char') && max (indr) > df._cnt(1))
           error ("Accessing dataframe past end of lines");
         endif
-        [indc, ncol, S(1).subs{2}] = \
+        [indc, ncol, S(1).subs{2}] = ...
             df_name2idx (df._name{2}, S(1).subs{2}, df._cnt(2), 'column');
         if (max (indc) > df._cnt(2))
           %# is it a two index access of a 3D structure ?
@@ -255,7 +255,7 @@
             if (strcmp (S(1).subs{1}, ':'))
               fullindr = []; fullindc = []; asked_output_type = "array"; 
             else
-              error (["Accessing through single dimension and name " \
+              error (["Accessing through single dimension and name " ...
                       S(1).subs{1} " not allowed\n-- use variable(:, 'name') instead"]);
             endif
           case {'logical'}
@@ -276,8 +276,8 @@
             fullinds = ones (size (fullindr));
           else
             dummy = max (cellfun(@length, df._rep));
-            [fullindr, fullindc, fullinds] = ind2sub\
-                ([df._cnt dummy], S(1).subs{1});
+            [fullindr, fullindc, fullinds] = ...
+	    ind2sub ([df._cnt dummy], S(1).subs{1});
           endif 
           
           indr = unique (fullindr); nrow = length (indr);
@@ -309,7 +309,7 @@
     if (isempty (asked_output_type))
       output_type = class (df); %# force df output
     else
-      if (~strcmp (asked_output_type, "array") \
+      if (~strcmp (asked_output_type, "array") ...
           || ~isempty (asked_output_format))
         %# override the class of the return value
         output_type = asked_output_type;
@@ -387,7 +387,7 @@
       resu._cnt(1) = nrow; resu._cnt(2) = ncol;
       if (isempty (fullindr))
         for indi = (1:ncol)
-          resu._data{indi} =  df._data{indc(indi)}\
+          resu._data{indi} =  df._data{indc(indi)}...
               (indr, df._rep{indc(indi)}(indt{indc(indi)})); 
           resu._rep{indi} =  1:size (resu._data{indi}, 2);
           resu._name{2}(indi, 1) = df._name{2}(indc(indi));
@@ -410,7 +410,7 @@
             resu._name{2}(indi)= df._name{2}(indc);
             resu._over{2}(indi)= df._over{2}(indc);
             unfolded = df._data{indc}(:, df._rep{indc});
-            indj =  sub2ind (size (unfolded), fullindr(:, indi), \
+            indj =  sub2ind (size (unfolded), fullindr(:, indi), ...
                             fullinds(:, indi));
             resu._data{indi} = unfolded(indj);
             resu._type{indi} = df._type{indc};
@@ -473,7 +473,7 @@
             resu(1+row_offs:end, indi+col_offs) = dummy;
           otherwise
             dummy = df._data{indc(indi)}(indr, :);
-            resu(1+row_offs:end, indi+col_offs) = \
+            resu(1+row_offs:end, indi+col_offs) = ...
                 mat2cell (dummy, ones (nrow, 1), size (dummy, 2));
         endswitch
       endfor
@@ -496,34 +496,34 @@
             if (~isempty (dummy(2).subs))
               dummy(2).subs{2} = ':';
             endif
-            resuf = cat (2, \
+            resuf = cat (2, ...
                          %# reselect indexes
                          feval (@subsref, resu(3:end, 1),
-                                dummy(2:end)), \
+                                dummy(2:end)), ...
                          %# reselect rownames
                          feval (@subsref, resu(3:end, 2),
-                                dummy(2:end)), \
+                                dummy(2:end)), ...
                          %# extract - reorder - whatever
                          feval (@subsref, resu(3:end, 3:end), S(2:end))
-                         \
+                         ...
                          );
             dummy = S;
             if (~isempty (dummy(2).subs))
               dummy(2).subs{1} =  [1 2];
             endif
-            resuf =  cat(1, \
+            resuf =  cat(1, ...
                          %# reselect column names and types
                          [cell(2, 2) feval(@subsref, resu(1:2,
-                                                          3:end), \
-                                           dummy(2:end))], \
-                         resuf \
+                                                          3:end), ...
+                                           dummy(2:end))], ...
+                         resuf ...
                          );
             resuf(1:2, 1:2) = {''}; resu = resuf;
           else
             %# one dimensionnal access of the whole 2D cell array -- you
             %# asked it, you got it
             resu = feval (@subsref, resu(:), S(2:end));
-            if (~isa (S(2).subs{1}, 'char') \
+            if (~isa (S(2).subs{1}, 'char') ...
                   && size (S(2).subs{1}, 2) > 1)
               resu = resu.';
             endif
@@ -531,7 +531,7 @@
         endif
       elseif (1 == length (S(1).subs))
         resu = resu(:);
-        if (~isa(S(1).subs{1}, 'char') \
+        if (~isa(S(1).subs{1}, 'char') ...
               && size (S(1).subs{1}, 2) > 1)
           resu = resu.';
         endif
@@ -546,8 +546,8 @@
       %# * x(:, n:m) select only the first sequence 
       %# * x(:) returns a vertcat of the columns of x(:, :)
       %# disp('line 403 '); keyboard
-      if (isempty (S) || isempty (S(1).subs) || \
-          length (S(1).subs) > 1 || \
+      if (isempty (S) || isempty (S(1).subs) || ...
+          length (S(1).subs) > 1 || ...
           (isnumeric (S(1).subs{1}) && ~isvector(S(1).subs{1}))) 
         %# access-as-matrix
 	if (isempty (df))
@@ -557,12 +557,12 @@
           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)), \
+		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)),\
+		extractfunc = @(x) cast ( df._data{indc(x)}...
+						  (indr, df._rep{indc(x)}(inds)),...
 					  asked_output_format);
               endif
             else %# let the usual downclassing occur
@@ -578,7 +578,7 @@
 		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)
@@ -595,7 +595,7 @@
                     dummy = extractfunc (indi);
                   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(indi), df._type{indc(indi)}, asked_output_format);
 		end_try_catch
 		resu(:, indi, :) = dummy;
@@ -607,7 +607,7 @@
 		resu = dummy;
               endif
             endif
-            if (~isempty (S) && 2 == length (S(1).subs) \
+            if (~isempty (S) && 2 == length (S(1).subs) ...
 		&& all (cellfun ('isclass', S(1).subs, 'char')))
               resu = reshape (resu, nrow, ncol*nseq);
             endif
@@ -615,28 +615,28 @@
             %# 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)), \
+		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
               extractfunc = @(x, y) df._data{x}(:, df._rep{x})(y);
             endif
             try
-              resu = zeros(0, class (sum (cellfun (@(x) zeros (1, class (x(1))),\
+              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), \
+		idx = sub2ind (size (df._data{indi}), fullindr(dummy), ...
                                fullinds(dummy));
 		resu(dummy) = extractfunc (indi, idx);
               endfor
             catch
               disp (lasterr); 
-              error ("Column %d format (%s) can't be converted to %s", \
+              error ("Column %d format (%s) can't be converted to %s", ...
                      indi, df._type{indi}, asked_output_format);
             end_try_catch
             resu = reshape (resu, size (onedimidx));
@@ -647,31 +647,31 @@
         if (~isempty (fullindr))
           switch df._type{indc(1)}
             case {'char'}
-              resu = df._data{indc(1)}(fullindr(1), \
+              resu = df._data{indc(1)}(fullindr(1), ...
                                        df._rep{indc(1)}(fullinds(1)));
               for indi = (2:length (fullindr))
-                resu = char (resu, df._data{indc(indi)}\
+                resu = char (resu, df._data{indc(indi)}...
                              (fullindr(indi), df._rep{indc(indi)}(fullinds(indi))));
               endfor
             otherwise
               if (isempty (asked_output_format))
-                resu = df._data{fullindc(1)}\
+                resu = df._data{fullindc(1)}...
                     (fullindr(1), df._rep{fullindc(1)}(fullinds(1)));
               else      %# this type will propagate with subsequent cat
-                resu = cast (df._data{fullindc(1)}\
-                             (fullindr(1), df._rep{fullindc(1)}(fullinds(1))),\
+                resu = cast (df._data{fullindc(1)}...
+                             (fullindr(1), df._rep{fullindc(1)}(fullinds(1))),...
                              asked_output_format);
               endif
               for indi = (2:length (fullindr))
-                resu = cat(1, resu, df._data{fullindc(indi)}\
-                           (fullindr(indi), \
+                resu = cat(1, resu, df._data{fullindc(indi)}...
+                           (fullindr(indi), ...
                             df._rep{fullindc(indi)}(fullinds(indi))));
               endfor
           endswitch
         else %# using the (:) operator
           resu = df_whole(df)(:);
         endif
-        if (~isa (S(1).subs{1}, 'char') \
+        if (~isa (S(1).subs{1}, 'char') ...
               && size (S(1).subs{1}, 2) > 1)
           resu = resu.';
         endif