/*
* (c) The GRASP/AQUA Project, Glasgow University, 1994-1998
*
- * $Id: openFile.c,v 1.5 1999/01/23 17:44:40 sof Exp $
+ * $Id: openFile.c,v 1.11 1999/11/25 16:54:14 simonmar Exp $
*
* openFile Runtime Support
*/
#include <fcntl.h>
#endif
+#if defined(mingw32_TARGET_OS) && !defined(O_NOCTTY)
+#define O_NOCTTY 0
+#endif
+
IOFileObject*
-openStdFile(fd,flags,rd)
+openStdFile(fd,rd)
StgInt fd;
-StgInt flags;
StgInt rd;
{
IOFileObject* fo;
+ long fd_flags;
if ((fo = malloc(sizeof(IOFileObject))) == NULL)
return NULL;
fo->buf = NULL;
fo->bufWPtr = 0;
fo->bufRPtr = 0;
- fo->flags = flags | FILEOBJ_STD | ( rd ? FILEOBJ_READ : FILEOBJ_WRITE);
+ fo->flags = FILEOBJ_STD | ( rd ? FILEOBJ_READ : FILEOBJ_WRITE);
fo->connectedTo = NULL;
- return fo;
+
+ /* MS Win32 CRT doesn't support fcntl() -- the workaround is to
+ start using 'completion ports', but I'm punting on implementing
+ support for using those.
+ */
+#if !defined(_WIN32) || defined(__CYGWIN__) || defined(__CYGWIN32__)
+ /* set the non-blocking flag on this file descriptor */
+ fd_flags = fcntl(fd, F_GETFL);
+ fcntl(fd, F_SETFL, fd_flags | O_NONBLOCK);
+#endif
+
+ return fo;
}
#define OPENFILE_APPEND 0
#define OPENFILE_READ_WRITE 3
IOFileObject*
-openFile(file, how, binary, flags)
+openFile(file, how, binary)
StgByteArray file;
StgInt how;
StgInt binary;
-StgInt flags;
{
FILE *fp;
int fd;
int oflags;
- int exclusive;
+ int for_writing;
int created = 0;
struct stat sb;
IOFileObject* fo;
+ int flags = 0;
+
+#if defined(_WIN32) && !(defined(__CYGWIN__) || defined(__CYGWIN32__))
+#define O_NONBLOCK 0
+#endif
/*
* Since we aren't supposed to succeed when we're opening for writing and
switch (how) {
case OPENFILE_APPEND:
- oflags = O_WRONLY | O_NOCTTY | O_APPEND;
- exclusive = 1;
+ oflags = O_NONBLOCK | O_WRONLY | O_NOCTTY | O_APPEND;
+ for_writing = 1;
+ flags |= FILEOBJ_WRITE;
break;
case OPENFILE_WRITE:
- oflags = O_WRONLY | O_NOCTTY;
- exclusive = 1;
+ oflags = O_NONBLOCK | O_WRONLY | O_NOCTTY;
+ flags |= FILEOBJ_WRITE;
+ for_writing = 1;
break;
case OPENFILE_READ_ONLY:
- oflags = O_RDONLY | O_NOCTTY;
- exclusive = 0;
+ oflags = O_NONBLOCK | O_RDONLY | O_NOCTTY;
+ flags |= FILEOBJ_READ;
+ for_writing = 0;
break;
case OPENFILE_READ_WRITE:
- oflags = O_RDWR | O_NOCTTY;
- exclusive = 0;
+ oflags = O_NONBLOCK | O_RDWR | O_NOCTTY;
+ flags |= FILEOBJ_READ | FILEOBJ_WRITE;
+ for_writing = 1;
break;
default:
fprintf(stderr, "openFile: unknown mode `%d'\n", how);
}
#if HAVE_O_BINARY
- if (binary)
+ if (binary) {
oflags |= O_BINARY;
+ flags |= FILEOBJ_BINARY;
+ }
#endif
/* First try to open without creating */
return NULL;
} else {
/* If it is a dangling symlink, break off now, too. */
+#ifndef mingw32_TARGET_OS
struct stat st;
if ( lstat(file,&st) == 0) {
ghc_errtype = ERR_NOSUCHTHING;
ghc_errstr = "dangling symlink";
return NULL;
}
+#endif
}
/* Now try to create it */
while ((fd = open(file, oflags | O_CREAT | O_EXCL, 0666)) < 0) {
}
/* Use our own personal locking */
- if (lockFile(fd, exclusive) < 0) {
+ if (lockFile(fd, for_writing, 1/*enforce single-writer, if needs be.*/) < 0) {
cvtErrno();
switch (ghc_errno) {
default:
fo->fd = fd;
fo->buf = NULL;
+ fo->bufStart = 0;
fo->bufWPtr = 0;
fo->bufRPtr = 0;
- fo->flags = flags | ( (how == OPENFILE_READ_ONLY || how == OPENFILE_READ_WRITE) ? FILEOBJ_READ : 0)
- | ( (how == OPENFILE_APPEND || how == OPENFILE_READ_WRITE) ? FILEOBJ_WRITE : 0);
+ fo->flags = flags;
fo->connectedTo = NULL;
return fo;
}
/* `Lock' file descriptor and return file object. */
IOFileObject*
-openFd(fd,oflags,flags)
-StgInt fd;
-StgInt oflags;
-StgInt flags;
+openFd(StgInt fd,StgInt oflags,StgInt flags)
{
- int exclusive;
+ int for_writing;
FILE* fp;
IOFileObject* fo;
- if (lockFile(fd, exclusive) < 0) {
+ for_writing = ( ((oflags & O_WRONLY) || (oflags & O_RDWR)) ? 1 : 0);
+
+ if (lockFile(fd, for_writing, 1/* enforce single-writer */ ) < 0) {
cvtErrno();
switch (ghc_errno) {
default:
/* See openFileObject() comment */
if ((fo = malloc(sizeof(IOFileObject))) == NULL)
return NULL;
- fo->fd = fd;
- fo->buf = NULL;
- fo->bufWPtr = 0;
- fo->bufRPtr = 0;
- fo->flags = flags | ( oflags & O_RDONLY ? FILEOBJ_READ
+ fo->fd = fd;
+ fo->buf = NULL;
+ fo->bufStart = 0;
+ fo->bufWPtr = 0;
+ fo->bufRPtr = 0;
+ fo->flags = flags | ( oflags & O_RDONLY ? FILEOBJ_READ
: oflags & O_RDWR ? FILEOBJ_READ
: 0)
| ( oflags & O_WRONLY ? FILEOBJ_WRITE