octave-nkf: scripts/io/strread.m comparison

comparison scripts/io/strread.m @ 13141:e81ddf9cacd5

maint: untabify and remove trailing whitespace from source files * bicg.m, gmres.m, pkg.m: Untabify and remove trailing whitespace. * libcruft/Makefile.am, libcruft/blas-xtra/cdotc3.f, libcruft/blas-xtra/cmatm3.f, libcruft/blas-xtra/ddot3.f, libcruft/blas-xtra/dmatm3.f, libcruft/blas-xtra/sdot3.f, libcruft/blas-xtra/smatm3.f, libcruft/blas-xtra/zdotc3.f, libcruft/blas-xtra/zmatm3.f, libcruft/lapack-xtra/crsf2csf.f, libcruft/lapack-xtra/zrsf2csf.f, liboctave/Array.cc, liboctave/DASPK-opts.in, liboctave/DASRT-opts.in, liboctave/DASSL-opts.in, liboctave/LSODE-opts.in, liboctave/Makefile.a,mliboctave/Quad-opts.in, liboctave/Sparse-perm-op-defs.h, scripts/Makefile.a,mscripts/deprecated/glpkmex.m, scripts/general/blkdiag.m, scripts/general/interp1.m, scripts/general/profshow.m, scripts/general/quadl.m, scripts/general/triplequad.m, scripts/help/__makeinfo__.m, scripts/io/strread.m, scripts/io/textread.m, scripts/io/textscan.m, scripts/linear-algebra/rank.m, scripts/miscellaneous/gzip.m, scripts/miscellaneous/private/__xzip__.m, scripts/miscellaneous/tempdir.m, scripts/miscellaneous/unpack.m, scripts/pkg/pkg.m, scripts/plot/allchild.m, scripts/plot/ancestor.m, scripts/plot/cla.m, scripts/plot/clf.m, scripts/plot/findall.m, scripts/plot/findobj.m, scripts/plot/gca.m, scripts/plot/gcf.m, scripts/plot/hggroup.m, scripts/plot/isfigure.m, scripts/plot/ishghandle.m, scripts/plot/legend.m, scripts/plot/line.m, scripts/plot/loglog.m, scripts/plot/patch.m, scripts/plot/print.m, scripts/plot/private/__quiver__.m, scripts/plot/private/__scatter__.m, scripts/plot/rectangle.m, scripts/plot/semilogx.m, scripts/plot/semilogy.m, scripts/plot/surface.m, scripts/plot/text.m, scripts/plot/title.m, scripts/plot/trisurf.m, scripts/plot/view.m, scripts/plot/whitebg.m, scripts/plot/xlabel.m, scripts/plot/xlim.m, scripts/plot/ylabel.m, scripts/plot/ylim.m, scripts/plot/zlabel.m, scripts/plot/zlim.m, scripts/polynomial/mkpp.m, scripts/polynomial/polygcd.m, scripts/polynomial/ppint.m, scripts/polynomial/ppjumps.m, scripts/polynomial/ppval.m, scripts/set/setxor.m, scripts/sparse/bicgstab.m, scripts/sparse/cgs.m, scripts/sparse/spconvert.m, scripts/specfun/nthroot.m, scripts/strings/strmatch.m, scripts/strings/untabify.m, scripts/testfun/demo.m, scripts/testfun/example.m, src/DLD-FUNCTIONS/filter.cc, src/DLD-FUNCTIONS/mgorth.cc, src/DLD-FUNCTIONS/quadcc.cc, src/DLD-FUNCTIONS/str2double.cc, src/Makefile.a,msrc/gl-render.cc, src/gl2ps-renderer.cc, src/graphics.cc, src/octave-config.cc.in, src/octave-config.in, src/ov-class.h, src/ov-fcn.h, src/profiler.cc, src/profiler.h, src/pt-binop.cc, src/pt-unop.cc, src/symtab.cc, src/txt-eng-ft.cc: Remove trailing whitespace.

author	John W. Eaton <jwe@octave.org>
date	Thu, 15 Sep 2011 12:51:10 -0400
parents	3509cf60d1f6
children	9b8e786bbf3c

comparison

equal deleted inserted replaced

-:98d23b0f16e1
+:e81ddf9cacd5
 ## (2) 2x1 cell string array: Everything between the left and right strings
 ## is skipped.
 ## @end itemize
 ##
 ## @item "delimiter"
 ## Any character in @var{value} will be used to split @var{str} into words
 ## (default value = any whitespace).
 ##
 ## @item "emptyvalue"
 ## Parts of the output where no word is available is filled with @var{value}.
 ##
 ## @item "multipledelimsasone"
 ## Treat a series of consecutive delimiters, without whitespace in between,
 ## as a single delimiter.  Consecutive delimiter series need not be vertically
 ## "aligned".
 ##
 ## @item "treatasempty"
 ## Treat single occurrences (surrounded by delimiters or whitespace) of the
 ## string(s) in @var{value} as missing values.
 ## @item "whitespace"
 ## Any character in @var{value} will be interpreted as whitespace and
 ## trimmed; the string defining whitespace must be enclosed in double
 ## quotes for proper processing of special characters like \t.
 ## The default value for whitespace = " \b\r\n\t" (note the space).
 ##
 ## @end table
 ##
 ## @seealso{textscan, textread, load, dlmread, fscanf}
 ## @end deftypefn
 elseif (iscellstr (varargin{n+1}) && numel (varargin{n+1}) == 2)
 [comment_start, comment_end] = deal (varargin{n+1}{:});
 else
 ## FIXME - a user may have numeric values specified: {'//', 7}
 ##         this will lead to an error in the warning message
 error ("strread: unknown or unrecognized comment style '%s'",
 varargin{n+1});
 endif
 endswitch
 case "delimiter"
 delimiter_str = varargin{n+1};
 endif
 ## Remove comments in str
 if (comment_flag)
 ## Expand 'eol_char' here, after option processing which may have set value
 comment_end = regexprep (comment_end, 'eol_char', eol_char);
 cstart = strfind (str, comment_start);
 cstop  = strfind (str, comment_end);
 ## Treat end of string as additional comment stop
 if (isempty (cstop) || cstop(end) != length (str))
 cstop(end+1) = length (str);
 ## Trim whitespace if needed
 ## FIXME: This is very complicated.  Can this be simplified with regexprep?
 if (! isempty (white_spaces))
 ## Check if trailing "\n" might signal padding output arrays to equal size
 ## before it is trimmed away below
 if ((str(end) == 10) && (nargout > 1))
 pad_out = 1;
 endif
 ## Remove repeated white_space chars.  First find white_space positions
 idx = strchr (str, white_spaces);
 ## Find repeated white_spaces
 for ii = 1:numel (empty_str)
 idz = strmatch (empty_str{ii}, words, "exact");
 words(idz) = {""};
 endfor
 endif
 ## We now may have to cope with 3 cases:
 ## A: Trailing literals (%f<literal>) w/o delimiter in between.
 ## B: Leading literals (<literal>%f) w/o delimiter in between.
 ## C. Skipping leftover parts of specified skip fields (%*N )
 ## fmt_words has been split properly now, but words{} has only been split on
 ## Find indices and pointers to possible literals in fmt_words
 idf = cellfun ("isempty", strfind (fmt_words, "%"));
 ## Find indices and pointers to conversion specifiers with fixed width
 idg = ! cellfun ("isempty", regexp (fmt_words, '%\*?\d'));
 idy = find (idf | idg);
 ## If needed, split up columns in three steps:
 if (! isempty (idy))
 ## Try-catch because complexity of strings to read can be infinite
 #try
 ## 1. Assess "period" in the split-up words array ( < num_words_per_line).
 ## Could be done using EndOfLine but that prohibits EndOfLine = "" option.
 ## Alternative below goes by simply parsing a first grab of words
 error ("strread: Field width '%s' (fmt spec # %d) extends beyond word limit", fmt_words{ii}, ii);
 elseif (iwrdp == iwrdl)
 ## Word completely "used up".  Next word
 ++iwrd; iwrdp = 0; iwrdl = length (words{iwrd});
 endif
 else
 ## A simple format conv. specifier. Either (1) uses rest of word, or
 ## (2) is squeezed between current iwrdp and next literal, or (3) uses
 ## next word. (3) is already taken care of.  So just check (1) & (2)
 if (ii < numel (fmt_words) && idf(ii+1))
 ## ..or it IS found.  Add inferred width of current conversion field
 iwrdp += index (words{iwrd}(iwrdp+1:end), fmt_words{ii+1}) - 1;
 endif
 elseif (iwrdp < iwrdl)
 ## No bordering literal to the right => field occupies (rest of) word
 ++iwrd; iwrdp = 0;
 if (ii < numel (fmt_words))
 iwrdl = length (words{iwrd});
 endif
 endif
 ## 2. Pad words array so that it can be reshaped
 tmp_lines = ceil (num_words / words_period);
 num_words_padded = tmp_lines * words_period - num_words;
 if (num_words_padded)
 words = [words'; cell(num_words_padded, 1)];
 endif
 words = reshape (words, words_period, tmp_lines);
 ## 3. Do the column splitting on rectangular words array
 icol = 1; ii = 1;    # icol = current column, ii = current fmt_word
 s = s{:}(1);
 e = s(1) + length (fmt_words{ii}) - 1;
 endif
 if (! strcmp (fmt_words{ii}, words{icol, 1}))
 ## Column doesn't exactly match literal => split needed.  Insert a column
 words(icol+1:end+1, :) = words(icol:end, :);
 ## Watch out for empty cells
 jptr = find (! cellfun ("isempty", words(icol, :)));
 ## Distinguish leading or trailing literals
 if (! idg(ii) && ! isempty (s) && s(1) == 1)
 elseif (idg(ii))
 ## Current field = fixed width. Strip into icol, rest in icol+1
 wdth = floor (str2double (fmt_words{ii}(regexp(fmt_words{ii}, ...
 '\d') : end-1)));
 words(icol+1, jptr) = cellfun (@(x) x(wdth+1:end),
 words(icol,jptr), "UniformOutput", false);
 words(icol, jptr) = strtrunc (words(icol, jptr), wdth);
 else
 ## FIXME: this assumes char(254)/char(255) won't occur in input!
 clear wrds;
 wrds(1:2:2*numel (words(icol, jptr))) = ...
 #  warning ("strread: unable to parse text or file with given format string");
 #  return;
 #end_try_catch
 endif
 ## For each specifier, process corresponding column
 k = 1;
 for m = 1:num_words_per_line
 try
 if (format_repeat_count < 0)
 ## FIXME - add support for formats like "<%s>", "%[a-zA-Z]"
 ##         Someone with regexp experience is needed.
 switch fmt_words{m}(1:min (2, length (fmt_words{m})))
 case "%s"
 if (pad_out)
 data(end+1:num_lines) = {""};
 endif
 varargout{k} = data';
 k++;
 case {"%d", "%u", "%f", "%n"}
 n = cellfun ("isempty", data);
 ### FIXME - erroneously formatted data lead to NaN, not an error
 data = str2double (data);
 if (! isempty (regexp (fmt_words{m}, "%[du]")))
 ## Cast to integer
 ## FIXME: NaNs will be transformed into zeros
 data = int32 (data);
 end
 data(n) = numeric_fill_value;
 if (pad_out)
 endif
 if (numel (nfmt) > 1)
 sprec = str2double (nfmt{2});
 data = 10^-sprec * round (10^sprec * data);
 elseif (! isempty (regexp (fmt_words{m}, "[du]")))
 ## Cast to integer
 ## FIXME: NaNs will be transformed into zeros
 data = int32 (data);
 end
 varargout{k} = data.';
 k++;
 out = strsplit (text, sep, mult_dlms_s1);
 ## In case of trailing delimiter, strip stray last empty word
 if (!isempty (out) && any (sep == text(end)))
 out(end) = [];
 endif
 ## Empty cells converted to empty cellstrings.
 out(cellfun ("isempty", out)) = {""};
 endfunction

Mercurial > hg > octave-nkf

comparison scripts/io/strread.m @ 13141:e81ddf9cacd5