On the Windows platform:

#    import std.stream;
#
#    void main()
#    {
#        File f = new File("foo"); // where foo does not exist
#    }

creates the file "foo", does not throw any kind of exception, and then carries on executing as though everything were hunky dory.

This is currently a very good reason not to use std.stream.File

Arcane Jill

Arcane Jill wrote:
> On the Windows platform:
> 
> #    import std.stream;
> #
> #    void main()
> #    {
> #        File f = new File("foo"); // where foo does not exist
> #    }
> 
> creates the file "foo", does not throw any kind of exception, and then carries
> on executing as though everything were hunky dory.

In accordance with the documentation.

----------
this()
this(char[] filename)
this(char[] filename, FileMode mode)
    Create the stream with no open file, an open file in read and write mode, or an open file with explicit file mode. mode, if given, is a combination of FileMode.In (indicating a file that can be read) and FileMode.Out (indicating a file that can be written). If the file does not exist, it is created.
----------

After all, your code does say "new File"!  Even though that isn't what it really means!

> This is currently a very good reason not to use std.stream.File

Yes, the whole File class could be more clearly defined.  At the moment, it seems you're meant to manually call std.file.exists first.  Chances are this isn't part of the normal program logic....

My idea would probably be something like

enum FILE_MODE {
	IN                    = 0b000001,
	OUT                   = 0b000010,
	CREATE_IF_NONEXISTENT = 0b000100,
	NEW_FILE              = 0b001100,    /*!< create new file,
	                                      prevent overwrite */
	OVERWRITE             = 0b001000,    /*!< create new file,
	                                      overwrite if necessary */
	APPEND                = 0b010000,    //!< start pointer at end
	EXCLUSIVE             = 0b100000     /*!< lock for exclusive
 	                                      access, if that follows */
}

Obviously some combinations don't make sense....

Stewart.

-- 
My e-mail is valid but not my primary mailbox, aside from its being the unfortunate victim of intensive mail-bombing at the moment.  Please keep replies on the 'group where everyone may benefit.

To get the behavior Jill describes on Windows, change the two occurrences of
OPEN_ALWAYS in stream.d to
 (mode&FileMode.Out)?OPEN_ALWAYS:OPEN_EXISTING
and recompile phobos. I don't know about Linux.

"Arcane Jill" <Arcane_member@pathlink.com> wrote in message news:cdlm9m$2kle$1@digitaldaemon.com...
> On the Windows platform:
>
> #    import std.stream;
> #
> #    void main()
> #    {
> #        File f = new File("foo"); // where foo does not exist
> #    }
>
> creates the file "foo", does not throw any kind of exception, and then
carries
> on executing as though everything were hunky dory.
>
> This is currently a very good reason not to use std.stream.File
>
> Arcane Jill
>
>

In article <cdlpci$2ma4$1@digitaldaemon.com>, Stewart Gordon says...
>
>Arcane Jill wrote:
>> On the Windows platform:
>> 
>> #    import std.stream;
>> #
>> #    void main()
>> #    {
>> #        File f = new File("foo"); // where foo does not exist
>> #    }

Whoops. Should have said:

import std.stream;

#    void main()
#    {
#        File f = new File("foo", FileMode.In); // where foo does not exist
#    }

Please observe the FileMode.In parameter

>> creates the file "foo", does not throw any kind of exception, and then carries on executing as though everything were hunky dory.

Is /this/ in accordance with the documentation?

Arcane Jill

Arcane Jill wrote:
> In article <cdlpci$2ma4$1@digitaldaemon.com>, Stewart Gordon says...
> 
>>Arcane Jill wrote:
>>
>>>On the Windows platform:
>>>
>>>#    import std.stream;
>>>#
>>>#    void main()
>>>#    {
>>>#        File f = new File("foo"); // where foo does not exist
>>>#    }
> 
> 
> Whoops. Should have said:
> 
> import std.stream;
> 
> #    void main()
> #    {
> #        File f = new File("foo", FileMode.In); // where foo does not exist
> #    }
> 
> Please observe the FileMode.In parameter
> 
> 
>>>creates the file "foo", does not throw any kind of exception, and then carries
>>>on executing as though everything were hunky dory.
> 
> 
> Is /this/ in accordance with the documentation?

Yes.  "If the file does not exist, it is created."  There's nothing about examining the mode parameter for how to behave; it only modifies what operations can be performed on the stream.

I do think the API's incorrectly designed, but it's not a bug.

Arcane Jill wrote:
> On the Windows platform:
> 
> #    import std.stream;
> #
> #    void main()
> #    {
> #        File f = new File("foo"); // where foo does not exist
> #    }
> 
> creates the file "foo", does not throw any kind of exception, and then carries
> on executing as though everything were hunky dory.
> 
> This is currently a very good reason not to use std.stream.File
> 
> Arcane Jill
> 
> 
You know! I remember when this feature operated the way you now expect it to. Others requested that it be changed and it was. Just goes to show: you can't please everyone. No matter how hard you try!

Andrew

Andrew Edwards wrote:

> Arcane Jill wrote:
> 
>> On the Windows platform:
>>
>> #    import std.stream;
>> #
>> #    void main()
>> #    {
>> #        File f = new File("foo"); // where foo does not exist
>> #    }
>>
>> creates the file "foo", does not throw any kind of exception, and then carries
>> on executing as though everything were hunky dory.
>>
>> This is currently a very good reason not to use std.stream.File
>>
>> Arcane Jill
>>
>>
> You know! I remember when this feature operated the way you now expect it to. Others requested that it be changed and it was. Just goes to show: you can't please everyone. No matter how hard you try!
> 
> Andrew

As a matter of fact, here's the post that prompted the change:

  http://www.digitalmars.com/d/archives/17539.html

Andrew Edwards wrote:
> 
> As a matter of fact, here's the post that prompted the change:
> 
>   http://www.digitalmars.com/d/archives/17539.html

Teaches me for opening my mouth too fast. He was talking about "FileMode.Out".

I'll shut up now!

On Wed, 21 Jul 2004 14:00:01 +0100, Stewart Gordon <smjg_1998@yahoo.com> wrote:
> Arcane Jill wrote:
>> On the Windows platform:
>>
>> #    import std.stream;
>> #
>> #    void main()
>> #    {
>> #        File f = new File("foo"); // where foo does not exist
>> #    }
>>
>> creates the file "foo", does not throw any kind of exception, and then carries
>> on executing as though everything were hunky dory.
>
> In accordance with the documentation.
>
> ----------
> this()
> this(char[] filename)
> this(char[] filename, FileMode mode)
>      Create the stream with no open file, an open file in read and write mode, or an open file with explicit file mode. mode, if given, is a combination of FileMode.In (indicating a file that can be read) and FileMode.Out (indicating a file that can be written). If the file does not exist, it is created.
> ----------
>
> After all, your code does say "new File"!  Even though that isn't what it really means!
>
>> This is currently a very good reason not to use std.stream.File
>
> Yes, the whole File class could be more clearly defined.  At the moment, it seems you're meant to manually call std.file.exists first.  Chances are this isn't part of the normal program logic....
>
> My idea would probably be something like
>
> enum FILE_MODE {
> 	IN                    = 0b000001,
> 	OUT                   = 0b000010,
> 	CREATE_IF_NONEXISTENT = 0b000100,
> 	NEW_FILE              = 0b001100,    /*!< create new file,
> 	                                      prevent overwrite */
> 	OVERWRITE             = 0b001000,    /*!< create new file,
> 	                                      overwrite if necessary */
> 	APPEND                = 0b010000,    //!< start pointer at end
> 	EXCLUSIVE             = 0b100000     /*!< lock for exclusive
>   	                                      access, if that follows */
> }
>
> Obviously some combinations don't make sense....


I suggested these a little while back:

READ
WRITE
CREATE
APPEND
NEW

allowing:

"r"  - READ        - read, fails if file does not exist.
"w"  - CREATE      - write, overwrite existing.
"a"  - APPEND      - write, create if not exist.
"r+" - READ|WRITE  - read, write, fails if file does not exist.
"w+" - READ|CREATE - read, write, overwrite existing.
"a+" - READ|APPEND - read, append, create if not exist.
""   - WRITE|NEW   - write, fail if file exist.

to mirror fopen capability _and_ add new WRITE|NEW capability.


I would extend File creating LockedFile and/or add a LockFile class to handle file locking as it is done differently on the various *NIX operating systems.

Regan

-- 
Using M2, Opera's revolutionary e-mail client: http://www.opera.com/m2/

On Thu, 22 Jul 2004 12:00:32 +1200, Regan Heath wrote:

> On Wed, 21 Jul 2004 14:00:01 +0100, Stewart Gordon <smjg_1998@yahoo.com> wrote:
>> Arcane Jill wrote:
>>> On the Windows platform:
>>>
>>> #    import std.stream;
>>> #
>>> #    void main()
>>> #    {
>>> #        File f = new File("foo"); // where foo does not exist
>>> #    }
>>>
>>> creates the file "foo", does not throw any kind of exception, and then
>>> carries
>>> on executing as though everything were hunky dory.
>>
>> In accordance with the documentation.
>>
>> ----------
>> this()
>> this(char[] filename)
>> this(char[] filename, FileMode mode)
>>      Create the stream with no open file, an open file in read and write
>> mode, or an open file with explicit file mode. mode, if given, is a
>> combination of FileMode.In (indicating a file that can be read) and
>> FileMode.Out (indicating a file that can be written). If the file does
>> not exist, it is created.
>> ----------
>>
>> After all, your code does say "new File"!  Even though that isn't what it really means!
>>
>>> This is currently a very good reason not to use std.stream.File
>>
>> Yes, the whole File class could be more clearly defined.  At the moment, it seems you're meant to manually call std.file.exists first.  Chances are this isn't part of the normal program logic....
>>
>> My idea would probably be something like
>>
>> enum FILE_MODE {
>> 	IN                    = 0b000001,
>> 	OUT                   = 0b000010,
>> 	CREATE_IF_NONEXISTENT = 0b000100,
>> 	NEW_FILE              = 0b001100,    /*!< create new file,
>> 	                                      prevent overwrite */
>> 	OVERWRITE             = 0b001000,    /*!< create new file,
>> 	                                      overwrite if necessary */
>> 	APPEND                = 0b010000,    //!< start pointer at end
>> 	EXCLUSIVE             = 0b100000     /*!< lock for exclusive
>>   	                                      access, if that follows */
>> }
>>
>> Obviously some combinations don't make sense....
> 
> I suggested these a little while back:
> 
> READ
> WRITE
> CREATE
> APPEND
> NEW
> 
> allowing:
> 
> "r"  - READ        - read, fails if file does not exist.
> "w"  - CREATE      - write, overwrite existing.
> "a"  - APPEND      - write, create if not exist.
> "r+" - READ|WRITE  - read, write, fails if file does not exist.
> "w+" - READ|CREATE - read, write, overwrite existing.
> "a+" - READ|APPEND - read, append, create if not exist.
> ""   - WRITE|NEW   - write, fail if file exist.
> 
> to mirror fopen capability _and_ add new WRITE|NEW capability.
> 
> I would extend File creating LockedFile and/or add a LockFile class to handle file locking as it is done differently on the various *NIX operating systems.
> 

Hmmmm...this got me a-thinkin'...

I came up with this...
The open() routine seems to controls four aspects:

  Access: Read, Write, Both, Neither
  File-Exists action: Use, Overwrite, Fail
  File-Not-Exists action: Create, Fail
  Initial Seek: Start-of-File (normal), End-of-File (append)

This leads to 48 different combinations, some of which are not useful (eg. neither read nor write, fails if exists and if not-exists, read starting from end of file, etc...). So after removing the useless combinations, we are left with 20 possible ones.

I've devised six codes that encompass these combinations:
R : read access from start of file
W : write access from start of file
A : write access from end of file
U : use existing file
O : overwrite existing file
C : create non-existing file

So the useful combinations that either open a file or fail are (I've also show Regan's equivalent codes) ...

RWUC      - read, write, use existing, create if not existing.
RAUC "a+" - read, append (to existing), create if not exist.
RWOC "w+" - read, write, overwrite existing(, create if not existing).
RWU  "r+" - read, write, fails if file does not exist.
RAU       - read, append to existing, fail if not exist.
RWC       - read, write, fail if exists, create if not existing.
RWO       - read, write, overwrite if exists, fail if not existing.
RAO       - read, append if exists, fail if not existing.
WUC       - write, use if exists, create if not existing.
AUC  "a"  - write(, append if exists), create if not exist.
WOC  "w"  - write, overwrite existing(, create if not existing).
RUC       - read, use if exists, create if not existing.
ROC       - read, overwrite if exists, create if not existing. (Used to
                 always create an empty file).
RU   "r"  - read, fails if file does not exist.
RC        - read, fail if exists, create if not existing. (Used to create
                 an empty file if it doesn't already exist).
RO        - read, overwrite if exists, fail if not existing. (Used to wipe
                 an existing file).
WU        - write, use if file exists, fail if not existing.
AU        - write, append if file exists, fail if not existing.
WC    ""  - write, fail if file exists(, create if not existing).
WO        - write, overwrite if exists, fail if not existing.(Used to
                 replace an existing file).


Of course, these don't take file locking into account ;-)

-- 
Derek
Melbourne, Australia
22/Jul/04 12:06:49 PM