GNU bug report logs - #9085
'split' feature request: an option to uses e.g. '.001' as first suffix.

Previous Next

To add a comment to this bug, you must first unarchive it, by sending
a message to control AT debbugs.gnu.org, with unarchive 9085 in the body.
You can then email your comments to 9085 AT debbugs.gnu.org in the normal way.

Toggle the display of automated, internal messages from the tracker.

Message #5 received at submit <at> debbugs.gnu.org (full text, mbox):

From: SciFi <sci-fi <at> hush.ai>
To: bug-coreutils <at> gnu.org
Subject: 'split' feature request: an option to uses e.g. '.001' as first
	suffix.
Date: Thu, 14 Jul 2011 17:20:40 -0500

[Message part 1 (text/plain, inline)]

[Originally posted at <https://savannah.gnu.org/bugs/?22231> on Tue 05 Feb 2008 07:51:09 AM GMT:]

To create UseNet binary postings to match those made by others as close as possible, we need to create split files with 3-digit numeric suffixes.

The problem comes when 'split --numeric-suffixes --suffix-length=3' starts naming the files with .000 as the first suffix.  This causes great confusion among much of the UseNet userbase esp'ly those running M$ systems.  It seems the .000 file is reserved as some kind of index for their apps [MasterSplitter and others], and 'split's .000 file is rejected as "unknown format".

I know... I know... UNIX® was here well-before Mr Gates & company, but trying to explain to those users what to do (simply 'cat' or 'copy /b' all of the files in numeric order) is a chore.  We who use *ix-based systems (mine's OSX) do not furnish DOS .bat files for those users.  Yes I've received some public flack about this; I have no idea if those users ever were able to reconstruct the original files.

I'd like to suggest an option be added to 'split' that would let us begin naming the files with a suffix e.g. .001 or settable by a command-line option.  I don't know what would be a good name for this option (and whether it'd follow POSIX standards etc.).

I'm hoping by the absence of a .000 file in our UseNet posts, where the .001 file is really "the beginning", this would cause the M$-based tools to follow suit.

As an aside, most of us normally post several .par2 files, and some of us construct them in such a way that simply running a par2repair utility will recreate the original file automatically.  So, at least for my posts, that's what I'm telling users to do: just run your favorite par2 util, you don't need to 'copy /b' beforehand.  But it'd be best if we could cause 'split' to begin with the .001 file as explained above.

Thank you for letting me discuss this here.

[Today's Addendum I intended to add to the original report, for historical purposes if nothing else:]

I've found a few simple C pgms, all self-contained, that can be very-easily modified to do 3-digit suffixes starting at .001, such as 'bsplit.c'.  For example, these were discovered with internet search engines:
<http://www.linuxforums.org/forum/ubuntu-linux/148798-split-command-need-some-help.html#post707718>
<http://iraf.noao.edu/iraf/ftp/util/bsplit.c>

Nevertheless, it would be terribly nice to have GNU 'split' modify its suffix-generator logic to provide a bit more customization ability in this regard -- right now, the coding looks way-too complicated, too much for me to figure out how to rewrite it for a patch.  ;)

Thanks again.

[PGP.sig (application/pgp-signature, inline)]

Message #8 received at 9085 <at> debbugs.gnu.org (full text, mbox):

From: Jérémy Compostella <jeremy.compostella <at> gmail.com>
To: Pádraig Brady <P <at> draigbrady.com>
Cc: 9085 <at> debbugs.gnu.org, SciFi <sci-fi <at> hush.ai>
Subject: Re: 'split' feature request: an option to uses e.g. '.001' as first
	suffix.
Date: Sun, 29 Jan 2012 23:34:09 +0100

[Message part 1 (text/plain, inline)]

Pádraig, Sci-Fi, others,

I made an implementation of the requested feature. With the attached
patch applied the split command accepts a new optional "from" argument
for the --numeric-suffixes (aka -d) option. If this argument is
specified, the numeric suffix counts from this value, otherwise, like
before, it counts from 0.

I've tried to not impact the performance, to not break anything and to
respect the coding rules but feel free to comment this patch. I will
take into account whatever you may want.

Cheers,

Jérémy
---

[0001-split-numeric-suffixes-new-optional-from-argument-bu.patch (text/x-diff, inline)]

From 82cbcf36e1fc9901964b6a348b495739357f28ee Mon Sep 17 00:00:00 2001
From: Jeremy Compostella <jeremy.compostella <at> gmail.com>
Date: Sun, 29 Jan 2012 15:20:31 +0100
Subject: [PATCH] split: --numeric-suffixes new optional "from" argument (bug#9085)

The split command now accepts a new optional "from" argument for the
--numeric-suffixes (aka -d) option. When this argument is specified,
the numeric suffix counts from this value, otherwise, like before, it
counts from 0.

Signed-off-by: Jeremy Compostella <jeremy.compostella <at> gmail.com>
---
 NEWS               |    6 +++++
 doc/coreutils.texi |    7 +++--
 src/split.c        |   63 +++++++++++++++++++++++++++++++++++++++++++++++-----
 3 files changed, 67 insertions(+), 9 deletions(-)

diff --git a/NEWS b/NEWS
index 2b0926f..2f46707 100644
--- a/NEWS
+++ b/NEWS
@@ -2,6 +2,12 @@ GNU coreutils NEWS                                    -*- outline -*-
 
 * Noteworthy changes in release ?.? (????-??-??) [?]
 
+** New features
+
+   split now accept an optional "from" value for the
+   --numeric-suffixes (aka -d) option. When this argument is
+   specified, the numeric suffix counts from this value, otherwise,
+   like before, it counts from 0.
 
 * Noteworthy changes in release 8.15 (2012-01-06) [stable]
 
diff --git a/doc/coreutils.texi b/doc/coreutils.texi
index 0d3b739..53ab356 100644
--- a/doc/coreutils.texi
+++ b/doc/coreutils.texi
@@ -3083,11 +3083,12 @@ and so can be a pipe for example.
 @opindex --suffix-length
 Use suffixes of length @var{length}.  The default @var{length} is 2.
 
-@item -d
-@itemx --numeric-suffixes
+@item -d[@var{from}]
+@itemx --numeric-suffixes[=@var{from}]
 @opindex -d
 @opindex --numeric-suffixes
-Use digits in suffixes rather than lower-case letters.
+Use digits in suffixes rather than lower-case letters. The numerical
+suffix counts from @var{from} if specified, 0 otherwise.
 
 @item -e
 @itemx --elide-empty-files
diff --git a/src/split.c b/src/split.c
index 5fbce0e..7454bc2 100644
--- a/src/split.c
+++ b/src/split.c
@@ -80,6 +80,9 @@ static size_t suffix_length;
 /* Alphabet of characters to use in suffix.  */
 static char const *suffix_alphabet = "abcdefghijklmnopqrstuvwxyz";
 
+/* Numerical suffix count from value.  */
+static size_t suffix_count_from;
+
 /* Name of input file.  May be "-".  */
 static char *infile;
 
@@ -122,7 +125,7 @@ static struct option const longopts[] =
   {"elide-empty-files", no_argument, NULL, 'e'},
   {"unbuffered", no_argument, NULL, 'u'},
   {"suffix-length", required_argument, NULL, 'a'},
-  {"numeric-suffixes", no_argument, NULL, 'd'},
+  {"numeric-suffixes", optional_argument, NULL, 'd'},
   {"filter", required_argument, NULL, FILTER_OPTION},
   {"verbose", no_argument, NULL, VERBOSE_OPTION},
   {"-io-blksize", required_argument, NULL,
@@ -195,7 +198,8 @@ Mandatory arguments to long options are mandatory for short options too.\n\
   -a, --suffix-length=N   use suffixes of length N (default %d)\n\
   -b, --bytes=SIZE        put SIZE bytes per output file\n\
   -C, --line-bytes=SIZE   put at most SIZE bytes of lines per output file\n\
-  -d, --numeric-suffixes  use numeric suffixes instead of alphabetic\n\
+  -d[FROM], --numeric-suffixes[FROM]  use numeric suffixes instead of alphabetic.\n\
+                           When specified, start counting from FROM, 0 otherwise\n\
   -e, --elide-empty-files  do not generate empty output files with '-n'\n\
       --filter=COMMAND    write to shell COMMAND; file name is $FILE\n\
   -l, --lines=NUMBER      put NUMBER lines per output file\n\
@@ -231,6 +235,7 @@ next_file_name (void)
 {
   /* Index in suffix_alphabet of each character in the suffix.  */
   static size_t *sufindex;
+  size_t i = suffix_length;
 
   if (! outfile)
     {
@@ -243,9 +248,23 @@ next_file_name (void)
       outfile = xmalloc (outfile_length + 1);
       outfile_mid = outfile + outbase_length;
       memcpy (outfile, outbase, outbase_length);
-      memset (outfile_mid, suffix_alphabet[0], suffix_length);
-      outfile[outfile_length] = 0;
       sufindex = xcalloc (suffix_length, sizeof *sufindex);
+      /* Initialize the suffix index accordingly to the count from
+         value.  */
+      {
+        size_t left = suffix_count_from;
+        while (i-- != 0)
+          {
+            if (left)
+              {
+                sufindex[i] = left % 10;
+                left /= 10;
+              }
+            outfile_mid[i] = suffix_alphabet[sufindex[i]];
+          }
+      }
+
+      outfile[outfile_length] = 0;
 
 #if ! _POSIX_NO_TRUNC && HAVE_PATHCONF && defined _PC_NAME_MAX
       /* POSIX requires that if the output file name is too long for
@@ -265,7 +284,6 @@ next_file_name (void)
     {
       /* Increment the suffix in place, if possible.  */
 
-      size_t i = suffix_length;
       while (i-- != 0)
         {
           sufindex[i]++;
@@ -1016,7 +1034,7 @@ main (int argc, char **argv)
       int this_optind = optind ? optind : 1;
       char *slash;
 
-      c = getopt_long (argc, argv, "0123456789C:a:b:del:n:u",
+      c = getopt_long (argc, argv, "0123456789C:a:b:d::el:n:u",
                        longopts, NULL);
       if (c == -1)
         break;
@@ -1142,6 +1160,19 @@ main (int argc, char **argv)
 
         case 'd':
           suffix_alphabet = "0123456789";
+          if (optarg)
+            {
+              unsigned long tmp;
+              if (xstrtoul (optarg, NULL, 10, &tmp, "") != LONGINT_OK
+                  || SIZE_MAX / sizeof (size_t) < tmp)
+                {
+                  error (0, 0, _("%s: invalid count from numerical suffix number"),
+                         optarg);
+                  usage (EXIT_FAILURE);
+                }
+              else
+                suffix_count_from = tmp;
+            }
           break;
 
         case 'e':
@@ -1212,6 +1243,26 @@ main (int argc, char **argv)
       usage (EXIT_FAILURE);
     }
 
+  /* Check that the suffix length is greater enough for the numerical
+     suffix count from value.  */
+  if (suffix_count_from)
+    {
+      size_t start = suffix_count_from;
+      size_t length = suffix_length;
+
+      while (start)
+        {
+          if (length == 0)
+            {
+              error (0, 0, _("numerical suffix FROM number too hight\
+ for the suffix length"));
+              usage (EXIT_FAILURE);
+            }
+          start /= 10;
+          length--;
+        }
+    }
+
   /* Open the input file.  */
   if (! STREQ (infile, "-")
       && fd_reopen (STDIN_FILENO, infile, O_RDONLY, 0) < 0)
-- 
1.7.2.5

Message #11 received at 9085 <at> debbugs.gnu.org (full text, mbox):

From: Pádraig Brady <P <at> draigBrady.com>
To: Jérémy Compostella
 <jeremy.compostella <at> gmail.com>
Cc: 9085 <at> debbugs.gnu.org
Subject: Re: bug#9085: 'split' feature request: an option to uses e.g. '.001'
	as first suffix.
Date: Mon, 30 Jan 2012 10:29:34 +0000

On 01/29/2012 10:34 PM, Jérémy Compostella wrote:
> Pádraig, Sci-Fi, others,
> 
> I made an implementation of the requested feature. With the attached
> patch applied the split command accepts a new optional "from" argument
> for the --numeric-suffixes (aka -d) option. If this argument is
> specified, the numeric suffix counts from this value, otherwise, like
> before, it counts from 0.
> 
> I've tried to not impact the performance, to not break anything and to
> respect the coding rules but feel free to comment this patch. I will
> take into account whatever you may want.

Thanks again for looking at this.
It's a useful feature for the presented use case,
or for supporting multiple independent split invocations.

Note we rarely change an option to have optional args.
For optional args, no space is allowed between option name and value.
I.E. --numeric-suffixes=10 or -d10 is required, which is a little restrictive.
More problematically though, existing scripts using the short options -de or -du in
combination will break.  The -eu options are relatively new though, so I'm leaning
towards this being acceptable. Hmm, this unusual form would fail too, `split -da3 ...`.
The failure mode is immediate and obvious, but this worries me a bit.

I wonder might we have a separate option, --suffix-start,
and theoretically that could accept alphabetic options too?
I'm not suggesting we do this, but it's worth discussing.

>From 82cbcf36e1fc9901964b6a348b495739357f28ee Mon Sep 17 00:00:00 2001
From: Jeremy Compostella <jeremy.compostella <at> gmail.com>
Date: Sun, 29 Jan 2012 15:20:31 +0100
Subject: [PATCH] split: --numeric-suffixes new optional "from" argument (bug#9085)

+  -d[FROM], --numeric-suffixes[FROM]  use numeric suffixes instead of alphabetic.\n\
+                           When specified, start counting from FROM, 0 otherwise\n\

s/-d[FROM], --numeric-suffixes[FROM]/-d, --numeric-suffixes[=FROM]

   -e, --elide-empty-files  do not generate empty output files with '-n'\n\
       --filter=COMMAND    write to shell COMMAND; file name is $FILE\n\
   -l, --lines=NUMBER      put NUMBER lines per output file\n\
@@ -231,6 +235,7 @@ next_file_name (void)
 {
   /* Index in suffix_alphabet of each character in the suffix.  */
   static size_t *sufindex;
+  size_t i = suffix_length;

   if (! outfile)
     {
@@ -243,9 +248,23 @@ next_file_name (void)
       outfile = xmalloc (outfile_length + 1);
       outfile_mid = outfile + outbase_length;
       memcpy (outfile, outbase, outbase_length);
-      memset (outfile_mid, suffix_alphabet[0], suffix_length);
-      outfile[outfile_length] = 0;
       sufindex = xcalloc (suffix_length, sizeof *sufindex);
+      /* Initialize the suffix index accordingly to the count from
+         value.  */
+      {
+        size_t left = suffix_count_from;
+        while (i-- != 0)
+          {
+            if (left)
+              {
+                sufindex[i] = left % 10;
+                left /= 10;
+              }
+            outfile_mid[i] = suffix_alphabet[sufindex[i]];
+          }
+      }
+
+      outfile[outfile_length] = 0;

 #if ! _POSIX_NO_TRUNC && HAVE_PATHCONF && defined _PC_NAME_MAX
       /* POSIX requires that if the output file name is too long for
@@ -265,7 +284,6 @@ next_file_name (void)
     {
       /* Increment the suffix in place, if possible.  */

-      size_t i = suffix_length;
       while (i-- != 0)
         {
           sufindex[i]++;
@@ -1016,7 +1034,7 @@ main (int argc, char **argv)
       int this_optind = optind ? optind : 1;
       char *slash;

-      c = getopt_long (argc, argv, "0123456789C:a:b:del:n:u",
+      c = getopt_long (argc, argv, "0123456789C:a:b:d::el:n:u",
                        longopts, NULL);
       if (c == -1)
         break;
@@ -1142,6 +1160,19 @@ main (int argc, char **argv)

         case 'd':
           suffix_alphabet = "0123456789";
+          if (optarg)
+            {
+              unsigned long tmp;
+              if (xstrtoul (optarg, NULL, 10, &tmp, "") != LONGINT_OK
+                  || SIZE_MAX / sizeof (size_t) < tmp)

Note the SIZE_MAX/sizeof(size_t) restriction was on the -a option,
as that is later used in a malloc. For -d there would be
no such restriction, so I'd just use xstrtoumax() != LONGINT_OK

cheers,
Pádraig.

Message #14 received at 9085 <at> debbugs.gnu.org (full text, mbox):

From: Pádraig Brady <P <at> draigBrady.com>
To: Jérémy Compostella
 <jeremy.compostella <at> gmail.com>
Cc: 9085 <at> debbugs.gnu.org
Subject: Re: bug#9085: 'split' feature request: an option to uses e.g. '.001'
	as first suffix.
Date: Mon, 30 Jan 2012 10:59:59 +0000

On 01/30/2012 10:29 AM, Pádraig Brady wrote:
> On 01/29/2012 10:34 PM, Jérémy Compostella wrote:
>> Pádraig, Sci-Fi, others,
>>
>> I made an implementation of the requested feature. With the attached
>> patch applied the split command accepts a new optional "from" argument
>> for the --numeric-suffixes (aka -d) option. If this argument is
>> specified, the numeric suffix counts from this value, otherwise, like
>> before, it counts from 0.
>>
>> I've tried to not impact the performance, to not break anything and to
>> respect the coding rules but feel free to comment this patch. I will
>> take into account whatever you may want.
> 
> Thanks again for looking at this.
> It's a useful feature for the presented use case,
> or for supporting multiple independent split invocations.
> 
> Note we rarely change an option to have optional args.
> For optional args, no space is allowed between option name and value.
> I.E. --numeric-suffixes=10 or -d10 is required, which is a little restrictive.
> More problematically though, existing scripts using the short options -de or -du in
> combination will break.  The -eu options are relatively new though, so I'm leaning
> towards this being acceptable. Hmm, this unusual form would fail too, `split -da3 ...`.
> The failure mode is immediate and obvious, but this worries me a bit.
> 
> I wonder might we have a separate option, --suffix-start,
> and theoretically that could accept alphabetic options too?
> I'm not suggesting we do this, but it's worth discussing.

Think a bit more about it, it's probably worth to split
the short and long options. Have -d not take a param as before,
and have --numeric-suffixes take an optional param.

cheers,
Pádraig.

Message #17 received at 9085 <at> debbugs.gnu.org (full text, mbox):

From: Jim Meyering <jim <at> meyering.net>
To: Pádraig Brady <P <at> draigBrady.com>
Cc: 9085 <at> debbugs.gnu.org,
	Jérémy Compostella <jeremy.compostella <at> gmail.com>
Subject: Re: bug#9085: 'split' feature request: an option to uses e.g. '.001'
	as first suffix.
Date: Mon, 30 Jan 2012 12:07:23 +0100

Pádraig Brady wrote:
> On 01/30/2012 10:29 AM, Pádraig Brady wrote:
>> On 01/29/2012 10:34 PM, Jérémy Compostella wrote:
>>> Pádraig, Sci-Fi, others,
>>>
>>> I made an implementation of the requested feature. With the attached
>>> patch applied the split command accepts a new optional "from" argument
>>> for the --numeric-suffixes (aka -d) option. If this argument is
>>> specified, the numeric suffix counts from this value, otherwise, like
>>> before, it counts from 0.
>>>
>>> I've tried to not impact the performance, to not break anything and to
>>> respect the coding rules but feel free to comment this patch. I will
>>> take into account whatever you may want.
>>
>> Thanks again for looking at this.
>> It's a useful feature for the presented use case,
>> or for supporting multiple independent split invocations.
>>
>> Note we rarely change an option to have optional args.
>> For optional args, no space is allowed between option name and value.
>> I.E. --numeric-suffixes=10 or -d10 is required, which is a little restrictive.
>> More problematically though, existing scripts using the short
>> options -de or -du in
>> combination will break.  The -eu options are relatively new though,
>> so I'm leaning
>> towards this being acceptable. Hmm, this unusual form would fail
>> too, `split -da3 ...`.
>> The failure mode is immediate and obvious, but this worries me a bit.
>>
>> I wonder might we have a separate option, --suffix-start,
>> and theoretically that could accept alphabetic options too?
>> I'm not suggesting we do this, but it's worth discussing.
>
> Think a bit more about it, it's probably worth to split
> the short and long options. Have -d not take a param as before,
> and have --numeric-suffixes take an optional param.

I agree.
We try hard to avoid short options with optional args
for the reasons you've outlined above.

Message #20 received at 9085 <at> debbugs.gnu.org (full text, mbox):

From: Jérémy Compostella <jeremy.compostella <at> gmail.com>
To: Jim Meyering <jim <at> meyering.net>
Cc: 9085 <at> debbugs.gnu.org, Pádraig Brady <P <at> draigbrady.com>
Subject: Re: bug#9085: 'split' feature request: an option to uses e.g. '.001'
	as first suffix.
Date: Mon, 30 Jan 2012 13:05:17 +0100

[Message part 1 (text/plain, inline)]

Thanks to both you for looking at this patch.

I'm a bit busy right now. I will take your proposition into account as soon
as possible. Exceptionaly, I do not have access to a computer during the
day this week. I only have access to my mailbox via my phone.

Cheers,

Jeremy
Le 30 janv. 2012 12:07, "Jim Meyering" <jim <at> meyering.net> a écrit :

> Pádraig Brady wrote:
> > On 01/30/2012 10:29 AM, Pádraig Brady wrote:
> >> On 01/29/2012 10:34 PM, Jérémy Compostella wrote:
> >>> Pádraig, Sci-Fi, others,
> >>>
> >>> I made an implementation of the requested feature. With the attached
> >>> patch applied the split command accepts a new optional "from" argument
> >>> for the --numeric-suffixes (aka -d) option. If this argument is
> >>> specified, the numeric suffix counts from this value, otherwise, like
> >>> before, it counts from 0.
> >>>
> >>> I've tried to not impact the performance, to not break anything and to
> >>> respect the coding rules but feel free to comment this patch. I will
> >>> take into account whatever you may want.
> >>
> >> Thanks again for looking at this.
> >> It's a useful feature for the presented use case,
> >> or for supporting multiple independent split invocations.
> >>
> >> Note we rarely change an option to have optional args.
> >> For optional args, no space is allowed between option name and value.
> >> I.E. --numeric-suffixes=10 or -d10 is required, which is a little
> restrictive.
> >> More problematically though, existing scripts using the short
> >> options -de or -du in
> >> combination will break.  The -eu options are relatively new though,
> >> so I'm leaning
> >> towards this being acceptable. Hmm, this unusual form would fail
> >> too, `split -da3 ...`.
> >> The failure mode is immediate and obvious, but this worries me a bit.
> >>
> >> I wonder might we have a separate option, --suffix-start,
> >> and theoretically that could accept alphabetic options too?
> >> I'm not suggesting we do this, but it's worth discussing.
> >
> > Think a bit more about it, it's probably worth to split
> > the short and long options. Have -d not take a param as before,
> > and have --numeric-suffixes take an optional param.
>
> I agree.
> We try hard to avoid short options with optional args
> for the reasons you've outlined above.
>

[Message part 2 (text/html, inline)]

Message #23 received at 9085 <at> debbugs.gnu.org (full text, mbox):

From: Jérémy Compostella <jeremy.compostella <at> gmail.com>
To: Pádraig Brady <P <at> draigbrady.com>,
Cc: 9085 <at> debbugs.gnu.org, Jim Meyering <jim <at> meyering.net>
Subject: Re: bug#9085: 'split' feature request: an option to uses e.g. '.001'
	as first suffix.
Date: Mon, 30 Jan 2012 18:33:28 +0100

Pádraig, Jim, others,

- Solution 1:
Pádraig wrotes:
> I wonder might we have a separate option, --suffix-start, and
> theoretically that could accept alphabetic options too?  I'm not
> suggesting we do this, but it's worth discussion.
That's was my first idea but since your first mail subject was "split
--numeric-suffixes=N" I assumed that you already thought about it as a
bad solution. Wrong assumption I guess.

- Solution 2:
Pádraig wrotes:
> Thinking a bit more about it, it's probably worth to split the short
> and long options. Have -d not take a param as before, and have
> --numeric-suffixes take an optional param.
> To do this, leave 'optional_argument' in the long_opts array, and just
> remove the :: from the getopts call.

Personally, I do prefer the "Solution 1" since the result looks more
consistent, more powerful andf does not change anything to the current
options.

However, it needs more work. It's a very particular week for me
and I will probably miss time and energy to work on this solution before
next week-end.

Anyway, we can talk about the best solution to implement so let me know.

- Note:
Pádraig wrotes:
> Note the SIZE_MAX/sizeof(size_t) restriction was on the -a option, as
> that is later used in a malloc. For -d there would be no such
> restriction, so I'd just use xstrtoumax() != LONGINT_OK
OK, thanks for the note and explanation, I will take this into account.

Cheers,

Jérémy

Message #26 received at 9085 <at> debbugs.gnu.org (full text, mbox):

From: Pádraig Brady <P <at> draigBrady.com>
To: Jérémy Compostella
 <jeremy.compostella <at> gmail.com>
Cc: 9085 <at> debbugs.gnu.org, Jim Meyering <jim <at> meyering.net>
Subject: Re: bug#9085: 'split' feature request: an option to uses e.g. '.001'
	as first suffix.
Date: Mon, 30 Jan 2012 17:44:38 +0000

On 01/30/2012 05:33 PM, Jérémy Compostella wrote:
> Pádraig, Jim, others,
> 
> - Solution 1:
> Pádraig wrotes:
>> I wonder might we have a separate option, --suffix-start, and
>> theoretically that could accept alphabetic options too?  I'm not
>> suggesting we do this, but it's worth discussion.
> That's was my first idea but since your first mail subject was "split
> --numeric-suffixes=N" I assumed that you already thought about it as a
> bad solution. Wrong assumption I guess.
> 
> - Solution 2:
> Pádraig wrotes:
>> Thinking a bit more about it, it's probably worth to split the short
>> and long options. Have -d not take a param as before, and have
>> --numeric-suffixes take an optional param.
>> To do this, leave 'optional_argument' in the long_opts array, and just
>> remove the :: from the getopts call.

My vote is for solution 2.
Less options = simpler interface for users.
I don't think it's too onerous to mandate,
numeric suffixes for this feature.

> Personally, I do prefer the "Solution 1" since the result looks more
> consistent, more powerful andf does not change anything to the current
> options.
> 
> However, it needs more work.

cheers,
Pádraig.

Message #29 received at 9085 <at> debbugs.gnu.org (full text, mbox):

From: Jérémy Compostella <jeremy.compostella <at> gmail.com>
To: Pádraig Brady <P <at> draigbrady.com>
Cc: 9085 <at> debbugs.gnu.org, Jim Meyering <jim <at> meyering.net>
Subject: Re: bug#9085: 'split' feature request: an option to uses e.g. '.001'
	as first suffix.
Date: Mon, 30 Jan 2012 19:07:49 +0100

[Message part 1 (text/plain, inline)]

Pádraig wrotes:
> On 01/30/2012 05:33 PM, Jérémy Compostella wrote:
> > Pádraig, Jim, others,
> >
> > - Solution 1:
> > Pádraig wrotes:
> >> I wonder might we have a separate option, --suffix-start, and
> >> theoretically that could accept alphabetic options too?  I'm not
> >> suggesting we do this, but it's worth discussion.
> > That's was my first idea but since your first mail subject was "split
> > --numeric-suffixes=N" I assumed that you already thought about it as a
> > bad solution. Wrong assumption I guess.
> >
> > - Solution 2:
> > Pádraig wrotes:
> >> Thinking a bit more about it, it's probably worth to split the short
> >> and long options. Have -d not take a param as before, and have
> >> --numeric-suffixes take an optional param.
> >> To do this, leave 'optional_argument' in the long_opts array, and just
> >> remove the :: from the getopts call.
> 
> My vote is for solution 2.
> Less options = simpler interface for users.
> I don't think it's too onerous to mandate,
> numeric suffixes for this feature.
OK, I attached the updated patch. If nobody does challenge the "Solution
2" I think we have the appropriate implementation.

Note: I just received my coreutils assignment PDF file. I will print it
and send it this week.

Cheers,

Jeremy
---

[0001-split-numeric-suffixes-new-optional-from-argument-bu.patch (text/x-diff, inline)]

From 79f08eef51b5651f153e0bacaab28c1da73c6517 Mon Sep 17 00:00:00 2001
From: Jeremy Compostella <jeremy.compostella <at> gmail.com>
Date: Sun, 29 Jan 2012 15:20:31 +0100
Subject: [PATCH] split: --numeric-suffixes new optional "from" argument (bug#9085)

The split command now accepts a new optional "from" argument for the
--numeric-suffixes option. If this argument is specified, the numeric
suffix counts from this value, otherwise, like before, it counts from
0.

Signed-off-by: Jeremy Compostella <jeremy.compostella <at> gmail.com>
---
 NEWS               |    6 +++++
 doc/coreutils.texi |    5 ++-
 src/split.c        |   60 +++++++++++++++++++++++++++++++++++++++++++++++----
 3 files changed, 64 insertions(+), 7 deletions(-)

diff --git a/NEWS b/NEWS
index 2b0926f..083e047 100644
--- a/NEWS
+++ b/NEWS
@@ -2,6 +2,12 @@ GNU coreutils NEWS                                    -*- outline -*-
 
 * Noteworthy changes in release ?.? (????-??-??) [?]
 
+** New features
+
+   split now accept an optional "from" value for the
+   --numeric-suffixes option. If this argument is specified, the
+   numeric suffix counts from this value, otherwise, like before, it
+   counts from 0.
 
 * Noteworthy changes in release 8.15 (2012-01-06) [stable]
 
diff --git a/doc/coreutils.texi b/doc/coreutils.texi
index 0d3b739..2d2ba32 100644
--- a/doc/coreutils.texi
+++ b/doc/coreutils.texi
@@ -3084,10 +3084,11 @@ and so can be a pipe for example.
 Use suffixes of length @var{length}.  The default @var{length} is 2.
 
 @item -d
-@itemx --numeric-suffixes
+@itemx --numeric-suffixes[=@var{from}]
 @opindex -d
 @opindex --numeric-suffixes
-Use digits in suffixes rather than lower-case letters.
+Use digits in suffixes rather than lower-case letters. The numerical
+suffix counts from @var{from} if specified, 0 otherwise.
 
 @item -e
 @itemx --elide-empty-files
diff --git a/src/split.c b/src/split.c
index 5fbce0e..ca72637 100644
--- a/src/split.c
+++ b/src/split.c
@@ -80,6 +80,9 @@ static size_t suffix_length;
 /* Alphabet of characters to use in suffix.  */
 static char const *suffix_alphabet = "abcdefghijklmnopqrstuvwxyz";
 
+/* Numerical suffix count from value.  */
+static unsigned long suffix_count_from;
+
 /* Name of input file.  May be "-".  */
 static char *infile;
 
@@ -122,7 +125,7 @@ static struct option const longopts[] =
   {"elide-empty-files", no_argument, NULL, 'e'},
   {"unbuffered", no_argument, NULL, 'u'},
   {"suffix-length", required_argument, NULL, 'a'},
-  {"numeric-suffixes", no_argument, NULL, 'd'},
+  {"numeric-suffixes", optional_argument, NULL, 'd'},
   {"filter", required_argument, NULL, FILTER_OPTION},
   {"verbose", no_argument, NULL, VERBOSE_OPTION},
   {"-io-blksize", required_argument, NULL,
@@ -195,7 +198,8 @@ Mandatory arguments to long options are mandatory for short options too.\n\
   -a, --suffix-length=N   use suffixes of length N (default %d)\n\
   -b, --bytes=SIZE        put SIZE bytes per output file\n\
   -C, --line-bytes=SIZE   put at most SIZE bytes of lines per output file\n\
-  -d, --numeric-suffixes  use numeric suffixes instead of alphabetic\n\
+  -d, --numeric-suffixes[FROM]  use numeric suffixes instead of alphabetic.\n\
+                           When specified, start counting from FROM, 0 otherwise\n\
   -e, --elide-empty-files  do not generate empty output files with '-n'\n\
       --filter=COMMAND    write to shell COMMAND; file name is $FILE\n\
   -l, --lines=NUMBER      put NUMBER lines per output file\n\
@@ -231,6 +235,7 @@ next_file_name (void)
 {
   /* Index in suffix_alphabet of each character in the suffix.  */
   static size_t *sufindex;
+  size_t i = suffix_length;
 
   if (! outfile)
     {
@@ -243,9 +248,23 @@ next_file_name (void)
       outfile = xmalloc (outfile_length + 1);
       outfile_mid = outfile + outbase_length;
       memcpy (outfile, outbase, outbase_length);
-      memset (outfile_mid, suffix_alphabet[0], suffix_length);
-      outfile[outfile_length] = 0;
       sufindex = xcalloc (suffix_length, sizeof *sufindex);
+      /* Initialize the suffix index accordingly to the count from
+         value.  */
+      {
+        unsigned long left = suffix_count_from;
+        while (i-- != 0)
+          {
+            if (left)
+              {
+                sufindex[i] = left % 10;
+                left /= 10;
+              }
+            outfile_mid[i] = suffix_alphabet[sufindex[i]];
+          }
+      }
+
+      outfile[outfile_length] = 0;
 
 #if ! _POSIX_NO_TRUNC && HAVE_PATHCONF && defined _PC_NAME_MAX
       /* POSIX requires that if the output file name is too long for
@@ -265,7 +284,6 @@ next_file_name (void)
     {
       /* Increment the suffix in place, if possible.  */
 
-      size_t i = suffix_length;
       while (i-- != 0)
         {
           sufindex[i]++;
@@ -1142,6 +1160,18 @@ main (int argc, char **argv)
 
         case 'd':
           suffix_alphabet = "0123456789";
+          if (optarg)
+            {
+              unsigned long tmp;
+              if (xstrtoul (optarg, NULL, 10, &tmp, "") != LONGINT_OK)
+                {
+                  error (0, 0, _("%s: invalid count from numerical suffix number"),
+                         optarg);
+                  usage (EXIT_FAILURE);
+                }
+              else
+                suffix_count_from = tmp;
+            }
           break;
 
         case 'e':
@@ -1212,6 +1242,26 @@ main (int argc, char **argv)
       usage (EXIT_FAILURE);
     }
 
+  /* Check that the suffix length is greater enough for the numerical
+     suffix count from value.  */
+  if (suffix_count_from)
+    {
+      unsigned long start = suffix_count_from;
+      size_t length = suffix_length;
+
+      while (start)
+        {
+          if (length == 0)
+            {
+              error (0, 0, _("numerical suffix FROM number too hight\
+ for the suffix length"));
+              usage (EXIT_FAILURE);
+            }
+          start /= 10;
+          length--;
+        }
+    }
+
   /* Open the input file.  */
   if (! STREQ (infile, "-")
       && fd_reopen (STDIN_FILENO, infile, O_RDONLY, 0) < 0)
-- 
1.7.2.5

Message #32 received at 9085 <at> debbugs.gnu.org (full text, mbox):

From: Jim Meyering <jim <at> meyering.net>
To: Pádraig Brady <P <at> draigBrady.com>
Cc: 9085 <at> debbugs.gnu.org,
	Jérémy Compostella <jeremy.compostella <at> gmail.com>
Subject: Re: bug#9085: 'split' feature request: an option to uses e.g. '.001'
	as first suffix.
Date: Mon, 30 Jan 2012 20:14:23 +0100

Pádraig Brady wrote:

> On 01/30/2012 05:33 PM, Jérémy Compostella wrote:
>> Pádraig, Jim, others,
>>
>> - Solution 1:
>> Pádraig wrotes:
>>> I wonder might we have a separate option, --suffix-start, and
>>> theoretically that could accept alphabetic options too?  I'm not
>>> suggesting we do this, but it's worth discussion.
>> That's was my first idea but since your first mail subject was "split
>> --numeric-suffixes=N" I assumed that you already thought about it as a
>> bad solution. Wrong assumption I guess.
>>
>> - Solution 2:
>> Pádraig wrotes:
>>> Thinking a bit more about it, it's probably worth to split the short
>>> and long options. Have -d not take a param as before, and have
>>> --numeric-suffixes take an optional param.
>>> To do this, leave 'optional_argument' in the long_opts array, and just
>>> remove the :: from the getopts call.
>
> My vote is for solution 2.
> Less options = simpler interface for users.
> I don't think it's too onerous to mandate,
> numeric suffixes for this feature.

Same here.
Another reason to avoid adding --suffix<anything> is that it would
invalidate -- rendering ambiguous -- any existing use of split that takes
advantage of --suffix (or --s for that matter) being an abbreviation
of the --suffix-length option name.

Message #35 received at 9085 <at> debbugs.gnu.org (full text, mbox):

From: Jérémy Compostella <jeremy.compostella <at> gmail.com>
To: Jim Meyering <jim <at> meyering.net>
Cc: 9085 <at> debbugs.gnu.org, Pádraig Brady <P <at> draigbrady.com>
Subject: Re: bug#9085: 'split' feature request: an option to uses e.g. '.001'
	as first suffix.
Date: Mon, 30 Jan 2012 20:29:40 +0100

> Pádraig Brady wrote:
> > On 01/30/2012 05:33 PM, Jérémy Compostella wrote:
> >> Pádraig, Jim, others,
> >>
> >> - Solution 1:
> >> Pádraig wrotes:
> >>> I wonder might we have a separate option, --suffix-start, and
> >>> theoretically that could accept alphabetic options too?  I'm not
> >>> suggesting we do this, but it's worth discussion.
> >> That's was my first idea but since your first mail subject was "split
> >> --numeric-suffixes=N" I assumed that you already thought about it as a
> >> bad solution. Wrong assumption I guess.
> >>
> >> - Solution 2:
> >> Pádraig wrotes:
> >>> Thinking a bit more about it, it's probably worth to split the short
> >>> and long options. Have -d not take a param as before, and have
> >>> --numeric-suffixes take an optional param.
> >>> To do this, leave 'optional_argument' in the long_opts array, and just
> >>> remove the :: from the getopts call.
> >
> > My vote is for solution 2.
> > Less options = simpler interface for users.
> > I don't think it's too onerous to mandate,
> > numeric suffixes for this feature.
> 
> Same here.
> Another reason to avoid adding --suffix<anything> is that it would
> invalidate -- rendering ambiguous -- any existing use of split that takes
> advantage of --suffix (or --s for that matter) being an abbreviation
> of the --suffix-length option name.
OK I understand that too. However, IMHO it could be avoid with a not
"suffix" prefixed option name, like --numeric-suffixes does in a sense,
no ?

Anyway, I'm completely new in its project so I learn from you.

Cheers,

Jeremy

Message #38 received at 9085 <at> debbugs.gnu.org (full text, mbox):

From: Jérémy Compostella <jeremy.compostella <at> gmail.com>
To: Pádraig Brady <P <at> draigbrady.com>
Cc: 9085 <at> debbugs.gnu.org, Jim Meyering <jim <at> meyering.net>, coreutils <at> gnu.org
Subject: Re: bug#9085: 'split' feature request: an option to uses e.g. '.001'
	as first suffix.
Date: Mon, 06 Feb 2012 14:58:55 +0100

[Message part 1 (text/plain, inline)]

Pádraig, all,

I took into account general comments on my commits. I attached the
improved patch for feature. Improvements are:
- Add by file description,
- I put back accents on my name (Jérémy instead of Jeremy),
- I referenced from who this feature was requested.

I added a new dedicated tests suite too.

Cheers,

Jérémy
---

[0001-split-numeric-suffixes-new-optional-from-argument-bu.patch (text/x-diff, inline)]

From 71612b3319e1dbed84d1182470397718afccf846 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=A9r=C3=A9my=20Compostella?= <jeremy.compostella <at> gmail.com>
Date: Sun, 29 Jan 2012 15:20:31 +0100
Subject: [PATCH] split: --numeric-suffixes new optional "from" argument (bug#9085)

The split command now accepts a new optional "from" argument for the
--numeric-suffixes option. If this argument is specified, the numeric
suffix counts from this value, otherwise, like before, it counts from
0.

* src/split.c (next_file_name): Initialize the suffix index
accordingly to the count from value.
(main): Check that the suffix length is greater enough for the
numerical suffix count from value.
* doc/coreutils.texi (split invocation): Mention it.
* NEWS (New features): Mention it.
* tests/split/numeric: New file. --numeric-suffixes[=FROM] option
  tests.
* tests/Makefile.am (TESTS): Add it.
Requested by SciFi.
---
 NEWS                |    7 ++++++
 doc/coreutils.texi  |    5 ++-
 src/split.c         |   60 ++++++++++++++++++++++++++++++++++++++++++++++----
 tests/Makefile.am   |    1 +
 tests/split/numeric |   61 +++++++++++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 127 insertions(+), 7 deletions(-)
 create mode 100755 tests/split/numeric

diff --git a/NEWS b/NEWS
index 9eebbf6..f09d55d 100644
--- a/NEWS
+++ b/NEWS
@@ -2,6 +2,13 @@ GNU coreutils NEWS                                    -*- outline -*-
 
 * Noteworthy changes in release ?.? (????-??-??) [?]
 
+** New features
+
+   split now accept an optional "from" value for the
+   --numeric-suffixes option. If this argument is specified, the
+   numeric suffix counts from this value, otherwise, like before, it
+   counts from 0.
+
 ** Bug fixes
 
   mv now lets you move a symlink onto a same-inode destination file that
diff --git a/doc/coreutils.texi b/doc/coreutils.texi
index 52838e7..b9fb482 100644
--- a/doc/coreutils.texi
+++ b/doc/coreutils.texi
@@ -3084,10 +3084,11 @@ and so can be a pipe for example.
 Use suffixes of length @var{length}.  The default @var{length} is 2.
 
 @item -d
-@itemx --numeric-suffixes
+@itemx --numeric-suffixes[=@var{from}]
 @opindex -d
 @opindex --numeric-suffixes
-Use digits in suffixes rather than lower-case letters.
+Use digits in suffixes rather than lower-case letters. The numerical
+suffix counts from @var{from} if specified, 0 otherwise.
 
 @item -e
 @itemx --elide-empty-files
diff --git a/src/split.c b/src/split.c
index 1d0310c..c8e1a51 100644
--- a/src/split.c
+++ b/src/split.c
@@ -80,6 +80,9 @@ static size_t suffix_length;
 /* Alphabet of characters to use in suffix.  */
 static char const *suffix_alphabet = "abcdefghijklmnopqrstuvwxyz";
 
+/* Numerical suffix count from value.  */
+static unsigned long suffix_count_from;
+
 /* Name of input file.  May be "-".  */
 static char *infile;
 
@@ -122,7 +125,7 @@ static struct option const longopts[] =
   {"elide-empty-files", no_argument, NULL, 'e'},
   {"unbuffered", no_argument, NULL, 'u'},
   {"suffix-length", required_argument, NULL, 'a'},
-  {"numeric-suffixes", no_argument, NULL, 'd'},
+  {"numeric-suffixes", optional_argument, NULL, 'd'},
   {"filter", required_argument, NULL, FILTER_OPTION},
   {"verbose", no_argument, NULL, VERBOSE_OPTION},
   {"-io-blksize", required_argument, NULL,
@@ -195,7 +198,8 @@ Mandatory arguments to long options are mandatory for short options too.\n\
   -a, --suffix-length=N   use suffixes of length N (default %d)\n\
   -b, --bytes=SIZE        put SIZE bytes per output file\n\
   -C, --line-bytes=SIZE   put at most SIZE bytes of lines per output file\n\
-  -d, --numeric-suffixes  use numeric suffixes instead of alphabetic\n\
+  -d, --numeric-suffixes[=FROM]  use numeric suffixes instead of alphabetic.\n\
+                           When specified, start counting from FROM, 0 otherwise\n\
   -e, --elide-empty-files  do not generate empty output files with '-n'\n\
       --filter=COMMAND    write to shell COMMAND; file name is $FILE\n\
   -l, --lines=NUMBER      put NUMBER lines per output file\n\
@@ -231,6 +235,7 @@ next_file_name (void)
 {
   /* Index in suffix_alphabet of each character in the suffix.  */
   static size_t *sufindex;
+  size_t i = suffix_length;
 
   if (! outfile)
     {
@@ -243,9 +248,23 @@ next_file_name (void)
       outfile = xmalloc (outfile_length + 1);
       outfile_mid = outfile + outbase_length;
       memcpy (outfile, outbase, outbase_length);
-      memset (outfile_mid, suffix_alphabet[0], suffix_length);
-      outfile[outfile_length] = 0;
       sufindex = xcalloc (suffix_length, sizeof *sufindex);
+      /* Initialize the suffix index accordingly to the count from
+         value.  */
+      {
+        unsigned long left = suffix_count_from;
+        while (i-- != 0)
+          {
+            if (left)
+              {
+                sufindex[i] = left % 10;
+                left /= 10;
+              }
+            outfile_mid[i] = suffix_alphabet[sufindex[i]];
+          }
+      }
+
+      outfile[outfile_length] = 0;
 
 #if ! _POSIX_NO_TRUNC && HAVE_PATHCONF && defined _PC_NAME_MAX
       /* POSIX requires that if the output file name is too long for
@@ -265,7 +284,6 @@ next_file_name (void)
     {
       /* Increment the suffix in place, if possible.  */
 
-      size_t i = suffix_length;
       while (i-- != 0)
         {
           sufindex[i]++;
@@ -1142,6 +1160,18 @@ main (int argc, char **argv)
 
         case 'd':
           suffix_alphabet = "0123456789";
+          if (optarg)
+            {
+              unsigned long tmp;
+              if (xstrtoul (optarg, NULL, 10, &tmp, "") != LONGINT_OK)
+                {
+                  error (0, 0, _("%s: invalid count from numerical suffix number"),
+                         optarg);
+                  usage (EXIT_FAILURE);
+                }
+              else
+                suffix_count_from = tmp;
+            }
           break;
 
         case 'e':
@@ -1212,6 +1242,26 @@ main (int argc, char **argv)
       usage (EXIT_FAILURE);
     }
 
+  /* Check that the suffix length is greater enough for the numerical
+     suffix count from value.  */
+  if (suffix_count_from)
+    {
+      unsigned long start = suffix_count_from;
+      size_t length = suffix_length;
+
+      while (start)
+        {
+          if (length == 0)
+            {
+              error (0, 0, _("numerical suffix FROM number too hight\
+ for the suffix length"));
+              usage (EXIT_FAILURE);
+            }
+          start /= 10;
+          length--;
+        }
+    }
+
   /* Open the input file.  */
   if (! STREQ (infile, "-")
       && fd_reopen (STDIN_FILENO, infile, O_RDONLY, 0) < 0)
diff --git a/tests/Makefile.am b/tests/Makefile.am
index a94aaa2..62bbb66 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -259,6 +259,7 @@ TESTS =						\
   split/lines					\
   split/l-chunk					\
   split/r-chunk					\
+  split/numeric					\
   misc/stat-birthtime				\
   misc/stat-fmt					\
   misc/stat-hyphen				\
diff --git a/tests/split/numeric b/tests/split/numeric
new file mode 100755
index 0000000..5550d6f
--- /dev/null
+++ b/tests/split/numeric
@@ -0,0 +1,61 @@
+#!/bin/sh
+# Show that split --numeric-suffixes[=from] works.
+
+# Copyright (C) 2012 Free Software Foundation, Inc.
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+. "${srcdir=.}/init.sh"; path_prepend_ ../src
+print_ver_ split
+
+# Check default start from 0
+printf '1\n2\n3\n4\n5\n' > in || framework_failure_
+split --numeric-suffixes --lines=2 in > out || fail=1
+cat <<\EOF > exp-1
+1
+2
+EOF
+cat <<\EOF > exp-2
+3
+4
+EOF
+cat <<\EOF > exp-3
+5
+EOF
+compare exp-1 x00 || fail=1
+compare exp-2 x01 || fail=1
+compare exp-3 x02 || fail=1
+
+# Check --numeric-suffixes=X
+split --numeric-suffixes=1 --lines=2 in > out || fail=1
+cat <<\EOF > exp-1
+1
+2
+EOF
+cat <<\EOF > exp-2
+3
+4
+EOF
+cat <<\EOF > exp-3
+5
+EOF
+compare exp-1 x01 || fail=1
+compare exp-2 x02 || fail=1
+compare exp-3 x03 || fail=1
+
+# Check that split failed when suffix length is not greater enough for
+# the numerical suffix count from value
+fail=1 && split -a 3 --numeric-suffixes=1000 in > out 2> /dev/null || fail=0
+
+Exit $fail
-- 
1.7.2.5

Message #41 received at 9085 <at> debbugs.gnu.org (full text, mbox):

From: Jérémy Compostella <jeremy.compostella <at> gmail.com>
To: Pádraig Brady <P <at> draigbrady.com>
Cc: 9085 <at> debbugs.gnu.org, Jim Meyering <jim <at> meyering.net>, coreutils <at> gnu.org
Subject: Re: bug#9085: 'split' feature request: an option to uses e.g. '.001'
	as first suffix.
Date: Thu, 16 Feb 2012 22:30:19 +0100

[Message part 1 (text/plain, inline)]

Pádraig, all,

I rebased my branch for this feature and make the syntax-check
success. I attached the new patch which I hope will satisfy you.

Feel free to comment it, I will take into account whatever you want.

Cheers,

Jérémy

[Message part 2 (text/html, inline)]

[0001-split-numeric-suffixes-new-optional-from-argument-bu.patch (text/x-patch, attachment)]

Message #44 received at 9085 <at> debbugs.gnu.org (full text, mbox):

From: Pádraig Brady <P <at> draigBrady.com>
To: Jérémy Compostella
 <jeremy.compostella <at> gmail.com>
Cc: 9085 <at> debbugs.gnu.org, Jim Meyering <jim <at> meyering.net>, coreutils <at> gnu.org
Subject: Re: bug#9085: 'split' feature request: an option to uses e.g. '.001'
	as first suffix.
Date: Fri, 17 Feb 2012 02:13:13 +0000

[Message part 1 (text/plain, inline)]

On 02/16/2012 09:30 PM, Jérémy Compostella wrote:
> Pádraig, all,
> 
> I rebased my branch for this feature and make the syntax-check
> success. I attached the new patch which I hope will satisfy you.
> 
> Feel free to comment it, I will take into account whatever you want.

Thanks for continuing with this.
One general thing that might both improve
and simplify the implementation, is to
not to convert from string to int at all.

I.E. when processing the arg, just validate like:
if (strlen (optarg) != strspn (optarg, suffix_alphabet))
  error()
else
   /* skip over any leading 0, and use this as the start directly. */

Then the subsequent check for length and
the initialization of the file name should be simplified.

Also this removes the limitation of size of an unsigned int,
though that's not really a practical concern I suppose.

I've also attached some string and test cleanups,
to --amend into your patch.

cheers,
Pádraig.

[split-numeric-suffix-adjusments.diff (text/plain, attachment)]

Message #47 received at 9085 <at> debbugs.gnu.org (full text, mbox):

From: Jérémy Compostella <jeremy.compostella <at> gmail.com>
To: Pádraig Brady <P <at> draigbrady.com>
Cc: 9085 <at> debbugs.gnu.org, Jim Meyering <jim <at> meyering.net>, coreutils <at> gnu.org
Subject: Re: bug#9085: 'split' feature request: an option to uses e.g. '.001'
	as first suffix.
Date: Fri, 17 Feb 2012 18:56:54 +0100

[Message part 1 (text/plain, inline)]

> Thanks for continuing with this.
> One general thing that might both improve
> and simplify the implementation, is to
> not to convert from string to int at all.
>
> I.E. when processing the arg, just validate like:
> if (strlen (optarg) != strspn (optarg, suffix_alphabet))
>  error()
> else
>   /* skip over any leading 0, and use this as the start directly. */
>
> Then the subsequent check for length and
> the initialization of the file name should be simplified.
This is more like my first implementation indeed. But since I didn't
know about the strspn() function the code was a little bit more complex
without converting to int.

I attached the new patch. I tried to make it as simple as possible but
feel free to comment.

> Also this removes the limitation of size of an unsigned int,
> though that's not really a practical concern I suppose.
Fair point. IMHO, even if it's not a really practical concern
it's stupid to have such an easy to avoid restriction.

> I've also attached some string and test cleanups,
> to --amend into your patch.
Applied.

Cheers,

Jérémy

[Message part 2 (text/html, inline)]

[0001-split-numeric-suffixes-new-optional-from-argument-bu.patch (text/x-patch, attachment)]

Message #52 received at 9085-done <at> debbugs.gnu.org (full text, mbox):

From: Pádraig Brady <P <at> draigBrady.com>
To: Jérémy Compostella
 <jeremy.compostella <at> gmail.com>
Cc: 9085-done <at> debbugs.gnu.org, coreutils <at> gnu.org
Subject: Re: bug#9085: 'split' feature request: an option to uses e.g. '.001'
	as first suffix.
Date: Sat, 18 Feb 2012 02:17:23 +0000

On 02/17/2012 05:56 PM, Jérémy Compostella wrote:
> I attached the new patch. I tried to make it as simple as possible but
> feel free to comment.

Thanks!
I just grouped the operations in next_file_name() a little for clarity,
tweaked a couple of strings, and pushed.

cheers,
Pádraig.

Previous Next

GNU bug tracking system
Copyright (C) 1999 Darren O. Benham, 1997,2003 nCipher Corporation Ltd, 1994-97 Ian Jackson.