Looking for a library to split pathnames

[Sven-Thorsten Fahrbach]

Hi

Does anybody know of a library that offers a function to split
pathnames. It should work somewhat like the following code snippet:

-----------------
char *path = "/home/user/Documents/Textdocuments/Bills";
char **dirs;

splitPath(path, dirs);
------------------

`dirs' should then consist of:
dirs[0] == "home"
dirs[1] == "user"
....
dirs[4] == "Bills"

Does anybody know of a function like that?
Thanks for your help.

Sven-Thorsten Fahrbach

P.S.: It could also be a C++ function if there exists a better
equivalent or if it's easier to use. I come from a Perl background and
I'm not that comfortable with string manipulation in C.

[mark_bluemel]

Sven-Thorsten Fahrbach wrote:

Hi

Does anybody know of a library that offers a function to split
pathnames. It should work somewhat like the following code snippet:

I suspect someone will be along shortly to say this is Off-Topic :-)

The dirname() and basename() functions on un*x systems will do most of
what you need here.

If this is a homework question (it smells a bit like one), I'd look at
the following questions:-

* how do you work out how many elements are in the pathname?
* how do you allocate space to hold the array of pointers?
* how do you fill the array of pointers?

If you are going to work with C you may as well get to grips with
string handling. It's not _that_ difficult.

[Sven-Thorsten Fahrbach]

ma**********@po box.com wrote:

Sven-Thorsten Fahrbach wrote:

>Hi

Does anybody know of a library that offers a function to split
pathnames. It should work somewhat like the following code snippet:

I suspect someone will be along shortly to say this is Off-Topic :-)

Oops, sorry. I'm not a regular usenet user ;). I just didn't know where
else to post this.

>
The dirname() and basename() functions on un*x systems will do most of
what you need here.

Thanks, I'll have a look into that!

>
If this is a homework question (it smells a bit like one) [...]

No, it's not, honestly. ;) I'm trying to write a small tool which needs
to do this job. I'd have used Perl but I fear it might be too slow for
my purposes.

I'd look at
the following questions:-

* how do you work out how many elements are in the pathname?
* how do you allocate space to hold the array of pointers?
* how do you fill the array of pointers?

If you are going to work with C you may as well get to grips with
string handling. It's not _that_ difficult.

I know. I just haven't got enough practise. But even though it's not a
homework question it might still be a good exercise!

Thanks for your help!

Sven-Thorsten Fahrbach

[mark_bluemel]

Sven-Thorsten Fahrbach wrote:

ma**********@po box.com wrote:

Sven-Thorsten Fahrbach wrote:

Hi

Does anybody know of a library that offers a function to split
pathnames. It should work somewhat like the following code snippet:

I suspect someone will be along shortly to say this is Off-Topic :-)

Oops, sorry. I'm not a regular usenet user ;). I just didn't know where
else to post this.

If it's about things which are part of the portable C standard, this is
a good place. If it's more platform-specific, somewhere else may be
better (comp.unix.prog rammer?).

However, if we take it as a string handling and memory allocation
exercise, it's probably on-topic :-)

The dirname() and basename() functions on un*x systems will do most of
what you need here.

Thanks, I'll have a look into that!

If this is a homework question (it smells a bit like one) [...]

No, it's not, honestly. ;) I'm trying to write a small tool which needs
to do this job. I'd have used Perl but I fear it might be too slow for
my purposes.

I'd look at
the following questions:-

* how do you work out how many elements are in the pathname?
* how do you allocate space to hold the array of pointers?
* how do you fill the array of pointers?

If you are going to work with C you may as well get to grips with
string handling. It's not _that_ difficult.

I know. I just haven't got enough practise. But even though it's not a
homework question it might still be a good exercise!

OK - I'd count the number of elements by a pass through the string
counting "/" characters, and adjust appropriately for the possibility
of relative pathnames (no leading "/") and a null basename (a trailing
"/"), then malloc() or calloc() the space for the array of pointers.
Depending on whether you want to use a count of paths or have a null
pointer to delimit the array, you may need an extra slot in the array
(I quite like using a null as a delimiter).

Are you clear in your mind how you want to handle relative pathnames
and null basenames, by the way?

Then you could use strtok() - not the nicest function, but it would
work, to walk through the pathname picking out the individual elements
in turn.

[sbaker48]

Sven-Thorsten Fahrbach wrote:

Hi

Does anybody know of a library that offers a function to split
pathnames. It should work somewhat like the following code snippet:

I know this isn't _exactly_ what you asked for, but this is what I
generally use:

----------

#include <stdio.h>

int explode( char *str, char delim, char *parts[], int numparts )
{
char *c = str;
int p = 0;

parts[p++] = c;
while ( *c && p < numparts )
{
if ( *c == delim )
{
*c = '\0';
parts[p++] = c+1;
}
c++;
}

return p;
}

int main( int argc, char *argv[] )
{
int p,i;
char *dirs[20];
char path[] = "/home/user/Documents/Textdocuments/Bills";

p = explode( path, '/', dirs, 20 );

for ( i = 0; i < p; i++ )
printf( "%s\n", dirs[i] );

return 0;
}

----------

On the bad side, the string you pass in is changed by the function (all
of the delimiter characters have been set to nil). Also, you must guess
the maximum number of parts in advance. On the plus side, if you do not
mind those limitations, you do not have to deal with dynamic memory
allocation in the explode function.

Most of the time, those limitations are not a problem at all. It works
great as a quick CSV parser (I have a slightly more involved version
that deals with quotes).

Also note that as a path parser, path[0] is returned as an empty
string, since there is nothing before the first delimiter.

--Sean

[CBFalconer]

Sven-Thorsten Fahrbach wrote:

>
Does anybody know of a library that offers a function to split
pathnames. It should work somewhat like the following code snippet:

-----------------
char *path = "/home/user/Documents/Textdocuments/Bills";
char **dirs;

splitPath(path, dirs);
------------------

`dirs' should then consist of:
dirs[0] == "home"
dirs[1] == "user"
...
dirs[4] == "Bills"

Does anybody know of a function like that?

The following routine (published here before) should do it. Simply
use '/' as the token delimiter. Wrap it in something that
allocates the memory for dirs[n] to point to. strdup() may come in
handy here. (strdup is non-standard, but available on many
systems, or you can write it yourself).

If you are not worried about re-entrancy and/or altering the
original string, see strtok() (which is standard).

/* ------- file toksplit.h ----------*/
#ifndef H_toksplit_h
# define H_toksplit_h

# ifdef __cplusplus
extern "C" {
# endif

#include <stddef.h>

/* copy over the next token from an input string, after
skipping leading blanks (or other whitespace?). The
token is terminated by the first appearance of tokchar,
or by the end of the source string.

The caller must supply sufficient space in token to
receive any token, Otherwise tokens will be truncated.

Returns: a pointer past the terminating tokchar.

This will happily return an infinity of empty tokens if
called with src pointing to the end of a string. Tokens
will never include a copy of tokchar.

released to Public Domain, by C.B. Falconer.
Published 2006-02-20. Attribution appreciated.
*/

const char *toksplit(const char *src, /* Source of tokens */
char tokchar, /* token delimiting char */
char *token, /* receiver of parsed token */
size_t lgh); /* length token can receive */
/* not including final '\0' */

# ifdef __cplusplus
}
# endif
#endif
/* ------- end file toksplit.h ----------*/

/* ------- file toksplit.c ----------*/
#include "toksplit.h "

/* copy over the next token from an input string, after
skipping leading blanks (or other whitespace?). The
token is terminated by the first appearance of tokchar,
or by the end of the source string.

The caller must supply sufficient space in token to
receive any token, Otherwise tokens will be truncated.

Returns: a pointer past the terminating tokchar.

This will happily return an infinity of empty tokens if
called with src pointing to the end of a string. Tokens
will never include a copy of tokchar.

A better name would be "strtkn", except that is reserved
for the system namespace. Change to that at your risk.

released to Public Domain, by C.B. Falconer.
Published 2006-02-20. Attribution appreciated.
Revised 2006-06-13
*/

const char *toksplit(const char *src, /* Source of tokens */
char tokchar, /* token delimiting char */
char *token, /* receiver of parsed token */
size_t lgh) /* length token can receive */
/* not including final '\0' */
{
if (src) {
while (' ' == *src) src++;

while (*src && (tokchar != *src)) {
if (lgh) {
*token++ = *src;
--lgh;
}
src++;
}
if (*src && (tokchar == *src)) src++;
}
*token = '\0';
return src;
} /* toksplit */

#ifdef TESTING
#include <stdio.h>

#define ABRsize 6 /* length of acceptable token abbreviations */

/* ---------------- */

static void showtoken(int i, char *tok)
{
putchar(i + '1'); putchar(':');
puts(tok);
} /* showtoken */

/* ---------------- */

int main(void)
{
char teststring[] = "This is a test, ,, abbrev, more";

const char *t, *s = teststring;
int i;
char token[ABRsize + 1];

puts(teststring );
t = s;
for (i = 0; i < 4; i++) {
t = toksplit(t, ',', token, ABRsize);
showtoken(i, token);
}

puts("\nHow to detect 'no more tokens' while truncating");
t = s; i = 0;
while (*t) {
t = toksplit(t, ',', token, 3);
showtoken(i, token);
i++;
}

puts("\nUsing blanks as token delimiters");
t = s; i = 0;
while (*t) {
t = toksplit(t, ' ', token, ABRsize);
showtoken(i, token);
i++;
}
return 0;
} /* main */

#endif
/* ------- end file toksplit.c ----------*/

--
"The most amazing achievement of the computer software industry
is its continuing cancellation of the steady and staggering
gains made by the computer hardware industry..." - Petroski

--
Posted via a free Usenet account from http://www.teranews.com

[Michal Nazarewicz]

"sbaker48" <sb************ **@gmail.comwri tes:

Sven-Thorsten Fahrbach wrote:

>Hi

Does anybody know of a library that offers a function to split
pathnames. It should work somewhat like the following code snippet:

I know this isn't _exactly_ what you asked for, but this is what I
generally use:

----------

#include <stdio.h>

int explode( char *str, char delim, char *parts[], int numparts ) {
char *c = str;
int p = 0;

parts[p++] = c;
while ( *c && p < numparts ) {
if ( *c == delim ) {
*c = '\0';
parts[p++] = c+1;
}
c++;
}

return p;
}

On the bad side, the string you pass in is changed by the function (all
of the delimiter characters have been set to nil).

Duplicating the string shouldn't be a problem.

Also, you must guess the maximum number of parts in advance.

You can first scan the string and count how many delims are there.

Also note that as a path parser, path[0] is returned as an empty
string, since there is nothing before the first delimiter.

Unless the path is relative. :]

#v+
#include <string.h>

char **explode(char *str, const char *delim, size_t *num) {
size_t capacity = 16, n;
char **arr = malloc(capacity * sizeof *arr);

arr[0] = strtok(str, delim);
while (arr[n]) {
if (++n >= capacity) {
capacity += 16;
arr = (char**)realloc (arr, capacity * sizeof *arr);
}
arr[n] = strtok(0, delim);
}

if (num) *num = n;
return arr;
}
#v-

Returns a NULL terminated array of pointers to each item. In
aditional, if num is not NULL saves there number of elements.
--
Best regards, _ _
.o. | Liege of Serenly Enlightened Majesty of o' \,=./ `o
..o | Computer Science, Michal "mina86" Nazarewicz (o o)
ooo +--<mina86*tlen.pl >--<jid:mina86*jab ber.org>--ooO--(_)--Ooo--

[Coos Haak]

Op Thu, 21 Sep 2006 17:24:28 +0200 schreef Michal Nazarewicz:

"sbaker48" <sb************ **@gmail.comwri tes:

>Sven-Thorsten Fahrbach wrote:

>>Hi

Does anybody know of a library that offers a function to split
pathnames. It should work somewhat like the following code snippet:

I know this isn't _exactly_ what you asked for, but this is what I
generally use:

----------

#include <stdio.h>

int explode( char *str, char delim, char *parts[], int numparts ) {
char *c = str;
int p = 0;

parts[p++] = c;
while ( *c && p < numparts ) {
if ( *c == delim ) {
*c = '\0';
parts[p++] = c+1;
}
c++;
}

return p;
}

On the bad side, the string you pass in is changed by the function (all
of the delimiter characters have been set to nil).

Duplicating the string shouldn't be a problem.

>Also, you must guess the maximum number of parts in advance.

You can first scan the string and count how many delims are there.

>Also note that as a path parser, path[0] is returned as an empty
string, since there is nothing before the first delimiter.

Unless the path is relative. :]

#v+

Non-standard directive, <OT>gcc complains</OT>

#include <string.h>

char **explode(char *str, const char *delim, size_t *num) {
size_t capacity = 16, n;
char **arr = malloc(capacity * sizeof *arr);

What if the allocation fails?

>
arr[0] = strtok(str, delim);
while (arr[n]) {
if (++n >= capacity) {
capacity += 16;
arr = (char**)realloc (arr, capacity * sizeof *arr);

arr = realloc(arr, capacity * sizeof *arr);
What if the allocation fails?

}
arr[n] = strtok(0, delim);
}

if (num) *num = n;
return arr;
}
#v-

Non-standard directive, <OT>gcc complains</OT>
--
Coos

[CBFalconer]

Michal Nazarewicz wrote:

"sbaker48" <sb************ **@gmail.comwri tes:

>Sven-Thorsten Fahrbach wrote:

>>>
Does anybody know of a library that offers a function to split
pathnames. It should work somewhat like the following code snippet:

.... snip ...

>
#v+
#include <string.h>

char **explode(char *str, const char *delim, size_t *num) {
size_t capacity = 16, n;
char **arr = malloc(capacity * sizeof *arr);

You failed to test the result of this malloc, so the following
statment may well cause explosions, nasal demons, whatnot.

>
arr[0] = strtok(str, delim);
while (arr[n]) {
if (++n >= capacity) {
capacity += 16;
arr = (char**)realloc (arr, capacity * sizeof *arr);

Very bad code. First, never cast realloc (or malloc). You hid the
error of failing to #include <stdlib.h>. Never capture the result
of realloc in the original pointer, you should use something like:

if (tmp = realloc(arr, newsize)) arr = tmp;
else {
/* out of memory error recovery */
}

}
arr[n] = strtok(0, delim);
}

if (num) *num = n;
return arr;
}
#v-

What in heavens name are the #v+ and #v- for, apart from creating a
syntax error?

--
Some informative links:
news:news.annou nce.newusers
http://www.geocities.com/nnqweb/
http://www.catb.org/~esr/faqs/smart-questions.html
http://www.caliburn.nl/topposting.html
http://www.netmeister.org/news/learn2quote.html

--
Posted via a free Usenet account from http://www.teranews.com

[Michal Nazarewicz]

CBFalconer <cb********@yah oo.comwrites:

Michal Nazarewicz wrote:

> char **arr = malloc(capacity * sizeof *arr);

You failed to test the result of this malloc, so the following
statment may well cause explosions, nasal demons, whatnot.

True, but real operating systems terminates process with SIGSEGV. :P

> arr = (char**)realloc (arr, capacity * sizeof *arr);

Very bad code. First, never cast realloc (or malloc). You hid the
error of failing to #include <stdlib.h>. Never capture the result
of realloc in the original pointer, you should use something like:

True, cast was inserted by mistake.

What in heavens name are the #v+ and #v- for, apart from creating a
syntax error?

They say intelligent news- and mailreaders that the text between is
a source code listing or alike which ought to be displayed with
monospace font.

--
Best regards, _ _
.o. | Liege of Serenly Enlightened Majesty of o' \,=./ `o
..o | Computer Science, Michal "mina86" Nazarewicz (o o)
ooo +--<mina86*tlen.pl >--<jid:mina86*jab ber.org>--ooO--(_)--Ooo--