Greetings!

I already have a problem with std.path.getDirName, but that's another on-going
post.  However, what is the use of getBaseName?  Shouldn't it be getting the
last entry of a path?

Take a look at this piece of code:

import std.stdio;
import std.path;
void main ()
{
char[] dir0 = "c:\\this\\is\\a\\path\\long.pog";
char[] dir1 = "c:\\this\\is\\also\\a\\path\\";
writefln(std.path.getBaseName(dir0));
writefln(std.path.getBaseName(dir1));
}

when run, it outputs:

long.pog

And as you can see, the second line is empty.  That is wrong.  There is no such
a path as a blank or null value.  Yes, if I take the \ from the end it works.
However, this should be taken care by the function.  I should not need to do any
cleanup for a function when I have a legitimate path.  This also goes for
getDirName.  It should return the last directory name in a path.  Even though it
is a directory.  Otherwise, confusing outcomes will be the result.

thanks,

josé

"jicman" <jicman_member@pathlink.com> wrote in message
news:dbjis4$iet$1@digitaldaemon.com...
> I already have a problem with std.path.getDirName, but that's another
> on-going
> post.  However, what is the use of getBaseName?  Shouldn't it be getting
> the
> last entry of a path?

Maybe it's just a badly-named function.  Seems to me that it should be
called getFileName(), not getBaseName().

Here.  Have this.

char[] getLastPathElement(char[] path)
{
if(path.length==0)
return null;
if(path[length-1]=='\\' || path[length-1]=='/')
path.length=path.length-1;
return getBaseName(path);
}

> Take a look at this piece of code:
>
> import std.stdio;
> import std.path;
> void main ()
> {
> char[] dir0 = "c:\\this\\is\\a\\path\\long.pog";
> char[] dir1 = "c:\\this\\is\\also\\a\\path\\";
> writefln(std.path.getBaseName(dir0));
> writefln(std.path.getBaseName(dir1));
> }
>
> when run, it outputs:
>
> long.pog
>
>
> And as you can see, the second line is empty.  That is wrong.

If the name of the function were getFileName (which it should be), then no,
it's not wrong.

> There is no such
> a path as a blank or null value.  Yes, if I take the \ from the end it
> works.

That's because the function then thinks that "path" is the filename, and
returns that.

> However, this should be taken care by the function.  I should not need to
> do any
> cleanup for a function when I have a legitimate path.  This also goes for
> getDirName.  It should return the last directory name in a path.  Even
> though it
> is a directory.  Otherwise, confusing outcomes will be the result.

What do you mean?  getDirName functions just fine.

On Tue, 19 Jul 2005 19:04:36 +0000 (UTC), jicman wrote:

> Greetings!
>
> I already have a problem with std.path.getDirName, but that's another on-going
> post.  However, what is the use of getBaseName?  Shouldn't it be getting the
> last entry of a path?
>
> Take a look at this piece of code:
>
> import std.stdio;
> import std.path;
> void main ()
> {
> char[] dir0 = "c:\\this\\is\\a\\path\\long.pog";
> char[] dir1 = "c:\\this\\is\\also\\a\\path\\";
> writefln(std.path.getBaseName(dir0));
> writefln(std.path.getBaseName(dir1));
> }
>
> when run, it outputs:
>
> long.pog
>
>
> And as you can see, the second line is empty.  That is wrong.  There is no such
> a path as a blank or null value.  Yes, if I take the \ from the end it works.
> However, this should be taken care by the function.  I should not need to do any
> cleanup for a function when I have a legitimate path.  This also goes for
> getDirName.  It should return the last directory name in a path.  Even though it
> is a directory.  Otherwise, confusing outcomes will be the result.

I guess the names of these functions could be better, but the functions in
std.path are string manipulation functions and not file system functions.
You use them to get and set strings which represent files and paths, and
not actually touch the file or path itself. It means you can use them on
non-existing files and they still work. Check out the stuff in std.file to
check for the actual existence or not of files and paths.

I have had to supplement both modules with extra functions for my D
applications to date. I can post those if you'd like to check them out ;-)

--
Derek Parnell
Melbourne, Australia
20/07/2005 8:18:29 AM

Jarrett Billingsley says...
>
>news:dbjis4$iet$1@digitaldaemon.com...
>> I already have a problem with std.path.getDirName, but that's another
>> on-going
>> post.  However, what is the use of getBaseName?  Shouldn't it be getting
>> the
>> last entry of a path?
>
>Maybe it's just a badly-named function.  Seems to me that it should be
>called getFileName(), not getBaseName().

Ok, I guess I saw getBaseName and I thought it would always return the last item
of a path.  My mistake.

>Here.  Have this.
>
>char[] getLastPathElement(char[] path)
>{
>    if(path.length==0)
>        return null;
>    if(path[length-1]=='\\' || path[length-1]=='/')
>        path.length=path.length-1;
>    return getBaseName(path);
>}

Yep, already did it, except that I splitted to an array and use the last entry
of the array. :-)  Yours is too hard to read. ;-)  Just kidding.

>> Take a look at this piece of code:
>>
>> import std.stdio;
>> import std.path;
>> void main ()
>> {
>> char[] dir0 = "c:\\this\\is\\a\\path\\long.pog";
>> char[] dir1 = "c:\\this\\is\\also\\a\\path\\";
>> writefln(std.path.getBaseName(dir0));
>> writefln(std.path.getBaseName(dir1));
>> }
>>
>> when run, it outputs:
>>
>> long.pog
>>
>>
>> And as you can see, the second line is empty.  That is wrong.
>
>If the name of the function were getFileName (which it should be), then no,
>it's not wrong.

Right.  Again, the lack of documentation and the few hours trying to find a bug
was what caused my complaining.  My apologies.

>> There is no such
>> a path as a blank or null value.  Yes, if I take the \ from the end it
>> works.
>
>That's because the function then thinks that "path" is the filename, and
>returns that.

Well, that would have worked the way I wanted it to work, but it does not.
"path" does not get return.  Instead, null value is returned.  The other
question is, what if that "path" is a file without a .txt or a .* ending?

>
>> However, this should be taken care by the function.  I should not need to
>> do any
>> cleanup for a function when I have a legitimate path.  This also goes for
>> getDirName.  It should return the last directory name in a path.  Even
>> though it
>> is a directory.  Otherwise, confusing outcomes will be the result.
>
>What do you mean?  getDirName functions just fine.

Well, again, lack of documentation and expecting it to work like JScript was my
problem.  For example,

var fso, s = "";
var w = WScript;
fso = new ActiveXObject("Scripting.FileSystemObject");
w.Echo(fso.GetBaseName("c:\\logs\\JICW2klog"));

if you run it, with this command,

cscript filetest.js

you will get,

Microsoft (R) Windows Script Host Version 5.6

JICW2klog

Also, take a look at this D program,

import std.stdio;
import std.path;
import std.file;
void main ()
{
char[] dir1 = "c:\\this\\is\\a\\path\\";
char[] dir2 = "c:\\this\\is\\also\\a\\path";
char[] dir3 = "c:\\this\\is\\another\\path\\file.txt";
writefln(std.path.getDirName(dir1));
writefln(std.path.getDirName(dir2));
writefln(std.path.getDirName(dir3));
}

if you compile it and run it, you'll get,

c:\this\is\a\path
c:\this\is\also\a
c:\this\is\another\path

Which is not consistent, but anyway, I don't mean to go on.  I apologize.

thanks and sorry,

josé

Derek Parnell says...
>
>On Tue, 19 Jul 2005 19:04:36 +0000 (UTC), jicman wrote:
>
>> Greetings!
>>
>> I already have a problem with std.path.getDirName, but that's another on-going
>> post.  However, what is the use of getBaseName?  Shouldn't it be getting the
>> last entry of a path?
>>
>> Take a look at this piece of code:
>>
>> import std.stdio;
>> import std.path;
>> void main ()
>> {
>> char[] dir0 = "c:\\this\\is\\a\\path\\long.pog";
>> char[] dir1 = "c:\\this\\is\\also\\a\\path\\";
>> writefln(std.path.getBaseName(dir0));
>> writefln(std.path.getBaseName(dir1));
>> }
>>
>> when run, it outputs:
>>
>> long.pog
>>
>>
>> And as you can see, the second line is empty.  That is wrong.  There is no such
>> a path as a blank or null value.  Yes, if I take the \ from the end it works.
>> However, this should be taken care by the function.  I should not need to do any
>> cleanup for a function when I have a legitimate path.  This also goes for
>> getDirName.  It should return the last directory name in a path.  Even though it
>> is a directory.  Otherwise, confusing outcomes will be the result.
>
>I guess the names of these functions could be better, but the functions in
>std.path are string manipulation functions and not file system functions.
>You use them to get and set strings which represent files and paths, and
>not actually touch the file or path itself. It means you can use them on
>non-existing files and they still work. Check out the stuff in std.file to
>check for the actual existence or not of files and paths.
>
>I have had to supplement both modules with extra functions for my D
>applications to date. I can post those if you'd like to check them out ;-)

if you don't mind, I would surely use it.  Since I use your build tool all the
time, might as well start using some of your code also. ;-)

thanks,

josé

"jicman" <jicman_member@pathlink.com> wrote in message
news:dbkf7j$19h2$1@digitaldaemon.com...
> Also, take a look at this D program,
>
> import std.stdio;
> import std.path;
> import std.file;
> void main ()
> {
> char[] dir1 = "c:\\this\\is\\a\\path\\";
> char[] dir2 = "c:\\this\\is\\also\\a\\path";
> char[] dir3 = "c:\\this\\is\\another\\path\\file.txt";
> writefln(std.path.getDirName(dir1));
> writefln(std.path.getDirName(dir2));
> writefln(std.path.getDirName(dir3));
> }
>
> if you compile it and run it, you'll get,
>
> c:\this\is\a\path
> c:\this\is\also\a
> c:\this\is\another\path
>
> Which is not consistent, but anyway, I don't mean to go on.  I apologize.

Umm, yes, it actually is consistent!  The getDirName() function starts at
the end of the string and searches for the first / or \ it finds.  Then it
returns the slice of the string from the beginning until one before that
character.

dir1 has a \ at the end.  So the function returns immediately.

With dir2, "path" is _not_ part of the path, as far as the function is
concerned.  It is a filename.  It will go back to the  after "a", and return
up to that.

dir3 is the same situation as dir2.

Remember, these functions are just string manip!  No file system checking!
If they did do file system checking, you wouldn't even be able to do this:

if(std.file.exists(std.path.join(std.file.getcwd(),"blah.txt")))
...

Or:

char[] newname=std.path.join(std.file.getcwd(), "something.bmp");
File f=new File(newname, FileMode.Out);

In article <dblnfi$7el$1@digitaldaemon.com>, Jarrett Billingsley says...
>
>news:dbkf7j$19h2$1@digitaldaemon.com...
>> Also, take a look at this D program,
>>
>> import std.stdio;
>> import std.path;
>> import std.file;
>> void main ()
>> {
>> char[] dir1 = "c:\\this\\is\\a\\path\\";
>> char[] dir2 = "c:\\this\\is\\also\\a\\path";
>> char[] dir3 = "c:\\this\\is\\another\\path\\file.txt";
>> writefln(std.path.getDirName(dir1));
>> writefln(std.path.getDirName(dir2));
>> writefln(std.path.getDirName(dir3));
>> }
>>
>> if you compile it and run it, you'll get,
>>
>> c:\this\is\a\path
>> c:\this\is\also\a
>> c:\this\is\another\path
>>
>> Which is not consistent, but anyway, I don't mean to go on.  I apologize.
>
>Umm, yes, it actually is consistent!

It may be consistent with the search and split logic, but not consistent with
the directory structure.  This entry,

c:\path\to\file\

is the same as

c:\path\to\file

my friend.  There is no "" directory.  If you run these two same "directory
structure" examples with getDirName(), you'll get a different outcome.  I am no
longer talking about checking if it's file or directory.  I am now talking just
plain directory structure definition.

>  The getDirName() function starts at
>the end of the string and searches for the first / or \ it finds.  Then it
>returns the slice of the string from the beginning until one before that
>character.
Yes, which is exactly what is going on here.  However, it should check if the
last character is a \ and make an appropiate "directory structure" result.

>
>dir1 has a \ at the end.  So the function returns immediately.
>
>With dir2, "path" is _not_ part of the path, as far as the function is
>concerned.  It is a filename.  It will go back to the  after "a", and return
>up to that.
>
>dir3 is the same situation as dir2.
>
>Remember, these functions are just string manip!  No file system checking!
>If they did do file system checking, you wouldn't even be able to do this:
>
>if(std.file.exists(std.path.join(std.file.getcwd(),"blah.txt")))
>    ...
>
>Or:
>
>char[] newname=std.path.join(std.file.getcwd(), "something.bmp");
>File f=new File(newname, FileMode.Out);

I understand.  Thanks.

jic

"jicman" <jicman_member@pathlink.com> wrote in message
news:dbmdkb$rei$1@digitaldaemon.com...
> It may be consistent with the search and split logic, but not consistent
> with
> the directory structure.  This entry,
>
> c:\path\to\file\
>
> is the same as
>
> c:\path\to\file
>
> my friend.

The first is nothing but a pathname.  The second is a directory called
"c:\path\to\" with a filename of "file".  What exactly are you finding so

> There is no "" directory.  If you run these two same "directory
> structure" examples with getDirName(), you'll get a different outcome.  I
> am no
> longer talking about checking if it's file or directory.  I am now talking
> just
> plain directory structure definition.

Yes, you'll get a different outcome, because they _are_ different.  In
"directory structure definition", directories end in a \.  Full filenames
end with a letter.  End.

> Yes, which is exactly what is going on here.  However, it should check if
> the
> last character is a \ and make an appropiate "directory structure" result.

It does!

> I understand.  Thanks.

But.. but.. you're still arguing that you don't!

Jarrett Billingsley says...
>
>news:dbmdkb$rei$1@digitaldaemon.com...
>> It may be consistent with the search and split logic, but not consistent
>> with
>> the directory structure.  This entry,
>>
>> c:\path\to\file\
>>
>> is the same as
>>
>> c:\path\to\file
>>
>> my friend.
>
>The first is nothing but a pathname.  The second is a directory called
>"c:\path\to\" with a filename of "file".  What exactly are you finding so

Never mind.  I see that you're completely missing the point and so, why explain
it.  :-)  Don't worry about it.  I get it.

>
>> There is no "" directory.  If you run these two same "directory
>> structure" examples with getDirName(), you'll get a different outcome.  I
>> am no
>> longer talking about checking if it's file or directory.  I am now talking
>> just
>> plain directory structure definition.
>
>Yes, you'll get a different outcome, because they _are_ different.  In
>"directory structure definition", directories end in a \.  Full filenames
>end with a letter.  End.
>
>> Yes, which is exactly what is going on here.  However, it should check if
>> the
>> last character is a \ and make an appropiate "directory structure" result.
>
>It does!
>
>> I understand.  Thanks.
>
>But.. but.. you're still arguing that you don't!
>
>