コード例 #1
0
	static bool TruncateFileDefault(Stream& file, uint64 size)
	{
		// Default implementation

		// Getting the current end of file
		if (not file.seekFromEndOfFile(0))
			return false;
		ssize_t end = (ssize_t) file.tell();

		#	ifndef YUNI_OS_MSVC
		bool result = (0 == ::ftruncate(FILENO(file.nativeHandle()), (off_t) size));
		#	else
		bool result = (0 == _chsize_s(FILENO(file.nativeHandle()), (sint64) size));
		#	endif
		if (result)
		{
			// if the file was already bigger than the new size, there is nothing to do
			if ((uint64)end >= size)
				return true;

			if (not file.seekFromBeginning(end))
				return false;

			enum
			{
				bufferSize = 1024 * 1024
			};
			size -= (uint64) end;

			if (size)
			{
				char* zero = new char[bufferSize];
				(void)::memset(zero, '\0', sizeof(char) * bufferSize);

				while (size > bufferSize)
				{
					if (bufferSize != file.write(zero, bufferSize))
					{
						delete[] zero;
						return false;
					}
					size -= bufferSize;
				}

				if (size)
				{
					if (size != file.write(zero, size))
					{
						delete[] zero;
						return false;
					}
				}
				delete[] zero;
			}
			return true;
		}
		return false;
	}
コード例 #2
0
ファイル: qfile_unix.cpp プロジェクト: kthxbyte/QT2-Linaro
bool QFile::open( int m, FILE *f )
{
    if ( isOpen() ) {
#if defined(CHECK_RANGE)
	qWarning( "QFile::open: File already open" );
#endif
	return FALSE;
    }
    init();
    setMode( m &~IO_Raw );
    setState( IO_Open );
    fh = f;
    ext_f = TRUE;
    STATBUF st;
    FSTAT( FILENO(fh), &st );
    ioIndex = (int)ftell( fh );
    if ( (st.st_mode & STAT_MASK) != STAT_REG || f == stdin ) { //stdin is non seekable
	// non-seekable
	setType( IO_Sequential );
	length = INT_MAX;
    } else {
	length = (int)st.st_size;
	if ( !(flags()&IO_Truncate) && length == 0 && isReadable() ) {
	    // try if you can read from it (if you can, it's a sequential
	    // device; e.g. a file in the /proc filesystem)
	    int c = getch();
	    if ( c != -1 ) {
		ungetch(c);
		setType( IO_Sequential );
		length = INT_MAX;
	    }
	}
    }
    return TRUE;
}
コード例 #3
0
ファイル: qfile.cpp プロジェクト: kthxbyte/Qt1.45-Linaro
bool QFile::open( int m, FILE *f )
{
    if ( isOpen() ) {
#if defined(CHECK_RANGE)
	warning( "QFile::open: File already open" );
#endif
	return FALSE;
    }
    init();
    setMode( m &~IO_Raw );
    setState( IO_Open );
    fh = f;
    ext_f = TRUE;
    STATBUF st;
    FSTAT( FILENO(fh), &st );
    index = (int)ftell( fh );
    if ( (st.st_mode & STAT_MASK) != STAT_REG ) {
	// non-seekable
	setType( IO_Sequential );
	length = INT_MAX;
    } else {
	length = (int)st.st_size;
    }
    return TRUE;
}
コード例 #4
0
ファイル: s_paus.c プロジェクト: hkmoffat/cantera
s_paus(char *s, ftnlen n)
#endif
{
	fprintf(stderr, "PAUSE ");
	if(n > 0)
		fprintf(stderr, " %.*s", (int)n, s);
	fprintf(stderr, " statement executed\n");
	if( ISATTY(FILENO(stdin)) )
		s_1paus(stdin);
	else {
#ifdef MSDOS
		FILE *fin;
		fin = fopen("con", "r");
		if (!fin) {
			fprintf(stderr, "s_paus: can't open con!\n");
			fflush(stderr);
			exit(1);
			}
		s_1paus(fin);
		fclose(fin);
#else
		fprintf(stderr,
		"To resume execution, execute a   kill -%d %d   command\n",
			PAUSESIG, getpid() );
		signal1(PAUSESIG, waitpause);
		fflush(stderr);
		pause();
#endif
		}
	fprintf(stderr, "Execution resumes after PAUSE.\n");
	fflush(stderr);
	return 0; /* NOT REACHED */
#ifdef __cplusplus
	}
コード例 #5
0
ファイル: fseek.c プロジェクト: NanXiao/illumos-joyent
int
fseek(FILE *iop, long offset, int ptrname)
{
	off_t	p;
	rmutex_t *lk;

	FLOCKFILE(lk, iop);
	iop->_flag &= ~_IOEOF;

	if (!(iop->_flag & _IOREAD) && !(iop->_flag & (_IOWRT | _IORW))) {
		errno = EBADF;
		FUNLOCKFILE(lk);
		return (-1);
	}

	if (iop->_flag & _IOREAD) {
		if (ptrname == 1 && iop->_base && !(iop->_flag&_IONBF)) {
			offset -= iop->_cnt;
		}
	} else if (iop->_flag & (_IOWRT | _IORW)) {
		if (_fflush_u(iop) == EOF) {
			FUNLOCKFILE(lk);
			return (-1);
		}
	}
	iop->_cnt = 0;
	iop->_ptr = iop->_base;
	if (iop->_flag & _IORW) {
		iop->_flag &= ~(_IOREAD | _IOWRT);
	}
	p = lseek(FILENO(iop), (off_t)offset, ptrname);
	FUNLOCKFILE(lk);
	return ((p == (off_t)-1) ? -1: 0);
}
コード例 #6
0
ファイル: qfile_unix.cpp プロジェクト: kthxbyte/QT2-Linaro
int QFile::handle() const
{
    if ( !isOpen() )
	return -1;
    else if ( fh )
	return FILENO( fh );
    else
	return fd;
}
コード例 #7
0
ファイル: qfile.cpp プロジェクト: kthxbyte/Qt1.45-Linaro
uint QFile::size() const
{
    STATBUF st;
    if ( isOpen() )
	FSTAT( fh ? FILENO(fh) : fd, &st );
    else
	STAT( fn, &st );
    return st.st_size;
}
コード例 #8
0
	bool Stream::lockExclusive()
	{
		# ifndef YUNI_OS_WINDOWS
		return pFd ? (0 == flock(FILENO(pFd), LOCK_EX)) : false;
		# else
		// warning The implementation is missing on Windows (#346)
		assert("Stream::lock: the implementation is missing on Windows, see ticket #346");
		return false;
		# endif
	}
コード例 #9
0
ファイル: Gnuplot.hpp プロジェクト: osandov/tetrak-cpp
	explicit Gnuplot(const std::string cmd = "gnuplot") : 
					 boost::iostreams::stream<boost::iostreams::file_descriptor_sink>(
					 FILENO(pout = POPEN(cmd.c_str(), "w")),
					 boost::iostreams::never_close_handle),
					 pout(pout), // keeps '-Weff++' quiet
					 gp_pty(NULL),
					 debug_messages(false)
	{
		*this << std::scientific << std::setprecision(18);  // refer <iomanip>
	}
コード例 #10
0
ファイル: qfile_unix.cpp プロジェクト: kthxbyte/QT2-Linaro
uint QFile::size() const
{
    STATBUF st;
    if ( isOpen() ) {
	FSTAT( fh ? FILENO(fh) : fd, &st );
    } else {
	STAT( QFile::encodeName(fn), &st );
    }
    return st.st_size;
}
コード例 #11
0
	void Stream::unlock()
	{
		# ifndef YUNI_OS_WINDOWS
		if (pFd)
			flock(FILENO(pFd), LOCK_UN);
		# else
		// warning The implementation is missing on Windows (#346)
		assert("Stream::lock: the implementation is missing on Windows, see ticket #346");
		# endif
	}
コード例 #12
0
ファイル: getpass.c プロジェクト: andreiw/polaris
static char *
__getpass(const char *prompt, int size)
{
	struct termio ttyb;
	unsigned short flags;
	char *p;
	int c;
	FILE	*fi;
	char *pbuf = tsdalloc(_T_GETPASS, MAXPASSWD + 1, NULL);
	void	(*sig)(int);
	rmutex_t *lk;

	if (pbuf == NULL ||
	    (fi = fopen("/dev/tty", "rF")) == NULL)
		return (NULL);
	setbuf(fi, NULL);
	sig = signal(SIGINT, catch);
	intrupt = 0;
	(void) ioctl(FILENO(fi), TCGETA, &ttyb);
	flags = ttyb.c_lflag;
	ttyb.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL);
	(void) ioctl(FILENO(fi), TCSETAF, &ttyb);
	FLOCKFILE(lk, stderr);
	(void) fputs(prompt, stderr);
	p = pbuf;
	while (!intrupt &&
		(c = GETC(fi)) != '\n' && c != '\r' && c != EOF) {
		if (p < &pbuf[ size ])
			*p++ = (char)c;
	}
	*p = '\0';
	ttyb.c_lflag = flags;
	(void) ioctl(FILENO(fi), TCSETAW, &ttyb);
	(void) PUTC('\n', stderr);
	FUNLOCKFILE(lk);
	(void) signal(SIGINT, sig);
	(void) fclose(fi);
	if (intrupt)
		(void) kill(getpid(), SIGINT);
	return (pbuf);
}
コード例 #13
0
const CHR *AudioIO::detectSourceType(const CHR *const fileName, const bool verbose)
{
	if (verbose)
	{
		PRINT_NFO(TXT("------- Audio I/O -------"));
	}
	
	uint8_t type = AUDIO_LIB_NULL;
	const bool bStdIn = (STRCASECMP(fileName, TXT("-")) == 0);

	if (bStdIn || PATH_ISREG(fileName))
	{
		if (FILE *const file = bStdIn ? stdin : FOPEN(fileName, TXT("rb")))
		{
			if (FD_ISREG(FILENO(file)))
			{
				for (size_t i = 0; g_audioIO_mapping[i].id; ++i)
				{
					if (verbose)
					{
						PRINT2_NFO(TXT("Trying input module ") FMT_CHR TXT("..."), g_audioIO_mapping[i].name);
					}
					if (checkFileType(g_audioIO_mapping[i].checkFileType, file))
					{
						type = g_audioIO_mapping[i].id;
						if (verbose)
						{
							PRINT_NFO(TXT("succeeded."));
						}
						break;
					}
				}
			}
			if (!bStdIn)
			{
				fclose(file);
			}
		}
	}

	if (verbose)
	{
		if(type == AUDIO_LIB_NULL)
		{
			PRINT_NFO(TXT("No suitable input module found -> falling back to default!"));
		}
		PRINT_NFO(TXT("------- Audio I/O -------\n"));
	}

	return getLibName(type);
}
コード例 #14
0
	bool Stream::truncate(uint64 size, bool ensureAllocation)
	{
		if (pFd)
		{
			int fd = FILENO(pFd);

			if (not ensureAllocation)
			{
				# ifndef YUNI_OS_MSVC
				return (0 == ::ftruncate(fd, (off_t) size));
				# else
				return (0 == _chsize_s(fd, (sint64) size));
				# endif
			}
			else
			{
				# ifdef YUNI_HAS_POSIX_FALLOCATE
				return (0 == posix_fallocate(fd, 0, (off_t) size));
				# else

				# ifdef YUNI_OS_MAC
				// On OS X, we can use fcntl(F_PREALLOCATE) to emulate posix_fallocate
				// (but ftruncate must be called anyway)
				fstore_t store;
				memset(&store, 0, sizeof(store));
				store.fst_flags    = F_ALLOCATECONTIG;
				store.fst_posmode  = F_PEOFPOSMODE;
				store.fst_length   = (off_t) size;

				if (-1 == fcntl(fd, F_PREALLOCATE, &store))
				{
					// OK, perhaps we are too fragmented, allocate non-continuous
					store.fst_flags = F_ALLOCATEALL;
					if (-1 == fcntl(fd, F_PREALLOCATE, &store))
						return false;
				}
				return (0 == ::ftruncate(fd, (off_t) size));

				# else

				return TruncateFileDefault(*this, size);

				# endif // OS X
				# endif // POSIX_FALLOCATE
			}
		}
		return false;
	}
コード例 #15
0
ファイル: terminfo.c プロジェクト: akr/ruby-terminfo
/*
 * TermInfo.tiocgwinsz(io) => [row, col]
 *
 * TermInfo.tiocgwinsz returns the screen size of the terminal refered by io,
 * using TIOCGWINSZ ioctl.
 */
static VALUE
rt_tiocgwinsz(VALUE self, VALUE io)
{
#ifdef TIOCGWINSZ
  rb_io_t *fptr;
  struct winsize sz;
  int ret;

  GetOpenFile(io, fptr);

  ret = ioctl(FILENO(fptr), TIOCGWINSZ, &sz);
  if (ret == -1) rb_raise(rb_eIOError, "TIOCGWINSZ failed");

  return rb_ary_new3(2, INT2NUM(sz.ws_row), INT2NUM(sz.ws_col));
#else
  rb_notimplement();
#endif
}
コード例 #16
0
ファイル: genericLogger.c プロジェクト: kimhanse/kollos
MARPAWRAPPER_EXPORT void _genericLogger_defaultCallback(const void *userDatavp, const genericLoggerLevel_t leveli, const char *msgs) {
  /* We are NOT going to do a general log4c mechanism (this can come later) */
  /* I.e. we are fixing the default output to be: DD/MM/YYYY hh::mm::ss PREFIX MESSAGE */
  const char *prefixs =
    (leveli == GENERICLOGGER_LOGLEVEL_TRACE    ) ? "TRACE"     :
    (leveli == GENERICLOGGER_LOGLEVEL_DEBUG    ) ? "DEBUG"     :
    (leveli == GENERICLOGGER_LOGLEVEL_INFO     ) ? "INFO"      :
    (leveli == GENERICLOGGER_LOGLEVEL_NOTICE   ) ? "NOTICE"    :
    (leveli == GENERICLOGGER_LOGLEVEL_WARNING  ) ? "WARNING"   :
    (leveli == GENERICLOGGER_LOGLEVEL_ERROR    ) ? "ERROR"     :
    (leveli == GENERICLOGGER_LOGLEVEL_CRITICAL ) ? "CRITICAL"  :
    (leveli == GENERICLOGGER_LOGLEVEL_ALERT    ) ? "ALERT"     :
    (leveli == GENERICLOGGER_LOGLEVEL_EMERGENCY) ? "EMERGENCY" :
    "UNKOWN";
  char *dates = dateBuilder("%d/%m/%Y %H:%M:%S");
  char *localMsgs = messageBuilder("%s %9s %s\n", dates, prefixs, (msgs != NULL) ? (char *) msgs : (char *) GENERICLOGGER_LOG_NO_MESSAGE);
  char *p = localMsgs;
#ifdef FILENO
  int filenoStderr = FILENO(stderr);
#ifdef SYS_FILENO_IS_FILENO
  ssize_t bytesWriten = 0;
#else
  size_t bytesWriten = 0;
#endif
  size_t  count;
#endif

#ifdef FILENO
  count = strlen(p);
  while (bytesWriten < count) {
    bytesWriten += SYS_WRITE(filenoStderr, p+bytesWriten, count-bytesWriten);
  }
#else
  /* Note: this is not asynchroneous safe */
  fprintf(stderr, "%s", p);
#endif

  if (dates != dateBuilder_internalErrors()) {
    free(dates);
  }
  if (localMsgs != messageBuilder_internalErrors()) {
    free(localMsgs);
  }
}
コード例 #17
0
ファイル: terminfo.c プロジェクト: akr/ruby-terminfo
/*
 * TermInfo.tiocswinsz(io, row, col)
 *
 * TermInfo.tiocgwinsz update the screen size information of the terminal refered by io,
 * using TIOCSWINSZ ioctl.
 *
 * It returns nil.
 */
static VALUE
rt_tiocswinsz(VALUE self, VALUE io, VALUE row, VALUE col)
{
#ifdef TIOCSWINSZ
  rb_io_t *fptr;
  struct winsize sz;
  int ret;

  GetOpenFile(io, fptr);

  sz.ws_row = NUM2INT(row);
  sz.ws_col = NUM2INT(col);

  ret = ioctl(FILENO(fptr), TIOCSWINSZ, &sz);
  if (ret == -1) rb_raise(rb_eIOError, "TIOCSWINSZ failed");

  return Qnil;
#else
  rb_notimplement();
#endif
}
コード例 #18
0
int CStdLibFileIO::GetHandle()
{
    return FILENO(m_pFile);
}
コード例 #19
0
ファイル: qfile_win32.cpp プロジェクト: albert-github/doxygen
uint QFile::size() const
{
    STATBUF st;
    if ( isOpen() ) {
	FSTAT( fh ? FILENO(fh) : fd, &st );
        return st.st_size;
    } else {
#if defined(__CYGWIN32_)
	STAT( QFile::encodeName(fn), &st );
#else
        QString str = fn;
        reslashify(str);
#ifdef QT_LARGEFILE_SUPPORT
        if ( _wstati64( (wchar_t*) str.ucs2(), &st ) != -1 ) {
#else
        if ( _wstat( (wchar_t*) str.ucs2(), &st ) != -1 ) {
#endif
#endif
            return st.st_size;
        }
    }
    return 0;
}

/*!
  \fn int QFile::at() const
  Returns the file index.
  \sa size()
*/

/*!
  Sets the file index to \e pos. Returns TRUE if successful, otherwise FALSE.

  Example:
  \code
    QFile f( "data.bin" );
    f.open( IO_ReadOnly );			// index set to 0
    f.at( 100 );				// set index to 100
    f.at( f.at()+50 );				// set index to 150
    f.at( f.size()-80 );			// set index to 80 before EOF
    f.close();
  \endcode

  \warning The result is undefined if the file was \link open() opened\endlink
  using the \c IO_Append specifier.

  \sa size(), open()
*/

bool QFile::at( int pos )
{
    if ( !isOpen() ) {
#if defined(CHECK_STATE)
	qWarning( "QFile::at: File is not open" );
#endif
	return FALSE;
    }
    bool ok;
    if ( isRaw() ) {				// raw file
	pos = (int)LSEEK(fd, pos, SEEK_SET);
	ok = pos != -1;
    } else {					// buffered file
	ok = fseek(fh, pos, SEEK_SET) == 0;
    }
    if ( ok )
	ioIndex = pos;
#if defined(CHECK_RANGE)
    else
	qWarning( "QFile::at: Cannot set file position %d", pos );
#endif
    return ok;
}

/*!
  Reads at most \e len bytes from the file into \e p and returns the
  number of bytes actually read.

  Returns -1 if a serious error occurred.

  \warning We have experienced problems with some C libraries when a buffered
  file is opened for both reading and writing. If a read operation takes place
  immediately after a write operation, the read buffer contains garbage data.
  Worse, the same garbage is written to the file. Calling flush() before
  readBlock() solved this problem.

  \sa writeBlock()
*/

int QFile::readBlock( char *p, uint len )
{
#if defined(CHECK_NULL)
    if ( !p )
	qWarning( "QFile::readBlock: Null pointer error" );
#endif
#if defined(CHECK_STATE)
    if ( !isOpen() ) {				// file not open
	qWarning( "QFile::readBlock: File not open" );
	return -1;
    }
    if ( !isReadable() ) {			// reading not permitted
	qWarning( "QFile::readBlock: Read operation not permitted" );
	return -1;
    }
#endif
    int nread;					// number of bytes read
    if ( isRaw() ) {				// raw file
	nread = READ( fd, p, len );
	if ( len && nread <= 0 ) {
	    nread = 0;
	    setStatus(IO_ReadError);
	}
    } else {					// buffered file
	nread = (int)fread( p, 1, len, fh );
	if ( (uint)nread != len ) {
	    if ( ferror( fh ) || nread==0 )
		setStatus(IO_ReadError);
	}
    }
    ioIndex += nread;
    return nread;
}

/*! \overload int writeBlock( const QByteArray& data )
*/

/*! \reimp

  Writes \e len bytes from \e p to the file and returns the number of
  bytes actually written.

  Returns -1 if a serious error occurred.

  \warning When working with buffered files, data may not be written
  to the file at once. Call flush() to make sure the data is really
  written.

  \sa readBlock()
*/

int QFile::writeBlock( const char *p, uint len )
{
#if defined(CHECK_NULL)
    if ( p == 0 && len != 0 )
	qWarning( "QFile::writeBlock: Null pointer error" );
#endif
#if defined(CHECK_STATE)
    if ( !isOpen() ) {				// file not open
	qWarning( "QFile::writeBlock: File not open" );
	return -1;
    }
    if ( !isWritable() ) {			// writing not permitted
	qWarning( "QFile::writeBlock: Write operation not permitted" );
	return -1;
    }
#endif
    int nwritten;				// number of bytes written
    if ( isRaw() )				// raw file
	nwritten = WRITE( fd, p, len );
    else					// buffered file
	nwritten = (int)fwrite( p, 1, len, fh );
    if ( nwritten != (int)len ) {		// write error
	if ( errno == ENOSPC )			// disk is full
	    setStatus( IO_ResourceError );
	else
	    setStatus( IO_WriteError );
	if ( isRaw() )				// recalc file position
	    ioIndex = (int)LSEEK( fd, 0, SEEK_CUR );
	else
	    ioIndex = fseek( fh, 0, SEEK_CUR );
    } else {
	ioIndex += nwritten;
    }
    if ( ioIndex > length )			// update file length
	length = ioIndex;
    return nwritten;
}

/*!
  Returns the file handle of the file.

  This is a small positive integer, suitable for use with C library
  functions such as fdopen() and fcntl(), as well as with QSocketNotifier.

  If the file is not open or there is an error, handle() returns -1.

  \sa QSocketNotifier
*/

int QFile::handle() const
{
    if ( !isOpen() )
	return -1;
    else if ( fh )
	return FILENO( fh );
    else
	return fd;
}

/*!
  Closes an open file.

  The file is not closed if it was opened with an existing file handle.
  If the existing file handle is a \c FILE*, the file is flushed.
  If the existing file handle is an \c int file descriptor, nothing
  is done to the file.

  Some "write-behind" filesystems may report an unspecified error on
  closing the file. These errors only indicate that something may
  have gone wrong since the previous open(). In such a case status()
  reports IO_UnspecifiedError after close(), otherwise IO_Ok.

  \sa open(), flush()
*/


void QFile::close()
{
    bool ok = FALSE;
    if ( isOpen() ) {				// file is not open
	if ( fh ) {				// buffered file
	    if ( ext_f )
		ok = fflush( fh ) != -1;	// flush instead of closing
	    else
		ok = fclose( fh ) != -1;
	} else {				// raw file
	    if ( ext_f )
		ok = TRUE;			// cannot close
	    else
		ok = CLOSE( fd ) != -1;
	}
	init();					// restore internal state
    }
    if (!ok)
	setStatus (IO_UnspecifiedError);

    return;
}
コード例 #20
0
ファイル: qfile_unix.cpp プロジェクト: kthxbyte/QT2-Linaro
bool QFile::open( int m )
{
    if ( isOpen() ) {				// file already open
#if defined(CHECK_STATE)
	qWarning( "QFile::open: File already open" );
#endif
	return FALSE;
    }
    if ( fn.isNull() ) {			// no file name defined
#if defined(CHECK_NULL)
	qWarning( "QFile::open: No file name specified" );
#endif
	return FALSE;
    }
    init();					// reset params
    setMode( m );
    if ( !(isReadable() || isWritable()) ) {
#if defined(CHECK_RANGE)
	qWarning( "QFile::open: File access not specified" );
#endif
	return FALSE;
    }
    bool ok = TRUE;
    STATBUF st;
    if ( isRaw() ) {				// raw file I/O
	int oflags = OPEN_RDONLY;
	if ( isReadable() && isWritable() )
	    oflags = OPEN_RDWR;
	else if ( isWritable() )
	    oflags = OPEN_WRONLY;
	if ( flags() & IO_Append ) {		// append to end of file?
	    if ( flags() & IO_Truncate )
		oflags |= (OPEN_CREAT | OPEN_TRUNC);
	    else
		oflags |= (OPEN_APPEND | OPEN_CREAT);
	    setFlags( flags() | IO_WriteOnly ); // append implies write
	} else if ( isWritable() ) {		// create/trunc if writable
	    if ( flags() & IO_Truncate )
		oflags |= (OPEN_CREAT | OPEN_TRUNC);
	    else
		oflags |= OPEN_CREAT;
	}
#if defined(HAS_TEXT_FILEMODE)
	if ( isTranslated() )
	    oflags |= OPEN_TEXT;
	else
	    oflags |= OPEN_BINARY;
#endif
#if defined(HAS_ASYNC_FILEMODE)
	if ( isAsynchronous() )
	    oflags |= OPEN_ASYNC;
#endif
	fd = OPEN( QFile::encodeName(fn), oflags, 0666 );

	if ( fd != -1 ) {			// open successful
	    FSTAT( fd, &st ); // get the stat for later usage
	} else {
	    ok = FALSE;
	}
    } else {					// buffered file I/O
	QCString perm;
	char perm2[4];
	bool try_create = FALSE;
	if ( flags() & IO_Append ) {		// append to end of file?
	    setFlags( flags() | IO_WriteOnly ); // append implies write
	    perm = isReadable() ? "a+" : "a";
	} else {
	    if ( isReadWrite() ) {
		if ( flags() & IO_Truncate ) {
		    perm = "w+";
		} else {
		    perm = "r+";
		    try_create = TRUE;		// try to create if not exists
		}
	    } else if ( isReadable() ) {
		perm = "r";
	    } else if ( isWritable() ) {
		perm = "w";
	    }
	}
	qstrcpy( perm2, perm );
#if defined(HAS_TEXT_FILEMODE)
	if ( isTranslated() )
	    strcat( perm2, "t" );
	else
	    strcat( perm2, "b" );
#endif
	while (1) { // At most twice

	    fh = fopen( QFile::encodeName(fn), perm2 );

	    if ( !fh && try_create ) {
		perm2[0] = 'w';			// try "w+" instead of "r+"
		try_create = FALSE;
	    } else {
		break;
	    }
	}
	if ( fh ) {
	    FSTAT( FILENO(fh), &st ); // get the stat for later usage
	} else {
	    ok = FALSE;
	}
    }
    if ( ok ) {
	setState( IO_Open );
	// on successful open the file stat was got; now test what type
	// of file we have
	if ( (st.st_mode & STAT_MASK) != STAT_REG ) {
	    // non-seekable
	    setType( IO_Sequential );
	    length = INT_MAX;
	    ioIndex  = (flags() & IO_Append) == 0 ? 0 : length;
	} else {
	    length = (int)st.st_size;
	    ioIndex  = (flags() & IO_Append) == 0 ? 0 : length;
	    if ( !(flags()&IO_Truncate) && length == 0 && isReadable() ) {
		// try if you can read from it (if you can, it's a sequential
		// device; e.g. a file in the /proc filesystem)
		int c = getch();
		if ( c != -1 ) {
		    ungetch(c);
		    setType( IO_Sequential );
		    length = INT_MAX;
		}
	    }
	}
    } else {
	init();
	if ( errno == EMFILE )			// no more file handles/descrs
	    setStatus( IO_ResourceError );
	else
	    setStatus( IO_OpenError );
    }
    return ok;
}
コード例 #21
0
ファイル: qfile.cpp プロジェクト: kthxbyte/Qt1.45-Linaro
bool QFile::open( int m )
{
    if ( isOpen() ) {				// file already open
#if defined(CHECK_STATE)
	warning( "QFile::open: File already open" );
#endif
	return FALSE;
    }
    if ( fn.isNull() ) {			// no file name defined
#if defined(CHECK_NULL)
	warning( "QFile::open: No file name specified" );
#endif
	return FALSE;
    }
    init();					// reset params
    setMode( m );
    if ( !(isReadable() || isWritable()) ) {
#if defined(CHECK_RANGE)
	warning( "QFile::open: File access not specified" );
#endif
	return FALSE;
    }
    bool ok = TRUE;
    if ( isRaw() ) {				// raw file I/O
	int oflags = OPEN_RDONLY;
	if ( isReadable() && isWritable() )
	    oflags = OPEN_RDWR;
	else if ( isWritable() )
	    oflags = OPEN_WRONLY;
	if ( flags() & IO_Append ) {		// append to end of file?
	    if ( flags() & IO_Truncate )
		oflags |= (OPEN_CREAT | OPEN_TRUNC);
	    else
		oflags |= (OPEN_APPEND | OPEN_CREAT);
	    setFlags( flags() | IO_WriteOnly ); // append implies write
	} else if ( isWritable() ) {		// create/trunc if writable
	    if ( flags() & IO_Truncate )
		oflags |= (OPEN_CREAT | OPEN_TRUNC);
	    else
		oflags |= OPEN_CREAT;
	}
#if defined(HAS_TEXT_FILEMODE) && !defined(_OS_MAC_)
	if ( isTranslated() )
	    oflags |= OPEN_TEXT;
	else
	    oflags |= OPEN_BINARY;
#endif
#if defined(HAS_ASYNC_FILEMODE)
	if ( isAsynchronous() )
	    oflags |= OPEN_ASYNC;
#endif
	fd = OPEN( (const char *)fn, oflags, 0666 );
	if ( fd != -1 ) {			// open successful
	    STATBUF st;
	    FSTAT( fd, &st );
	    length = (int)st.st_size;
	    index  = (flags() & IO_Append) == 0 ? 0 : length;
	} else {
	    ok = FALSE;
	}
    } else {					// buffered file I/O
	const char *perm = 0;
	char perm2[4];
	bool try_create = FALSE;
	if ( flags() & IO_Append ) {		// append to end of file?
	    setFlags( flags() | IO_WriteOnly ); // append implies write
	    perm = isReadable() ? "a+" : "a";
	} else {
	    if ( isReadWrite() ) {
		if ( flags() & IO_Truncate ) {
		    perm = "w+";
		} else {
		    perm = "r+";
		    try_create = TRUE;		// try to create if not exists
		}
	    } else if ( isReadable() ) {
		perm = "r";
	    } else if ( isWritable() ) {
		perm = "w";
	    }
	}
	strcpy( perm2, perm );
#if defined(HAS_TEXT_FILEMODE)
	if ( isTranslated() )
	    strcat( perm2, "t" );
	else
	    strcat( perm2, "b" );
#endif
	fh = fopen( (const char *)fn, perm2 );
	if ( !fh && try_create ) {
	    perm2[0] = 'w';			// try "w+" instead of "r+"
	    fh = fopen( (const char *)fn, perm2 );
	}
	if ( fh ) {
	    STATBUF st;
	    FSTAT( FILENO(fh), &st );
	    length = (int)st.st_size;
	    index  = (flags() & IO_Append) == 0 ? 0 : length;
	} else {
	    ok = FALSE;
	}
    }
    if ( ok ) {
	setState( IO_Open );
    } else {
	init();
	if ( errno == EMFILE )			// no more file handles/descrs
	    setStatus( IO_ResourceError );
	else
	    setStatus( IO_OpenError );
    }
    return ok;
}
コード例 #22
0
char* MemoryMapping::map(char* buffer, 
						 int buffersize, 
						 FILE* file, 
						 int offset) 
{
#ifdef _MSC_VER

	HANDLE filehandle = (HANDLE) _get_osfhandle(FILENO(file));

	HANDLE filemapping = ::CreateFileMappingA(
		filehandle, 
		&MMAP_SECURITY_ATTRIBUTES,
		PAGE_READONLY | SEC_COMMIT, 
		0, 
		0,
		0);

	if (0 == filemapping) return MAP_FAILED;

	DWORD alignedoffset = (offset / getPageSize()) * getPageSize();
	DWORD alignment = offset - alignedoffset;

	LPVOID mappedmemory = ::MapViewOfFile(
		filemapping,
		FILE_MAP_READ,
		0, 
		alignedoffset, 
		0);

	::CloseHandle(filemapping);

	if (0 != mappedmemory)
	{
		return ((char*) mappedmemory) + alignment;
	}
	else	
	{
		return 0;
	}

#else

	int filehandle = FILENO(file);

	int protection = PROT_READ;
	int flags = MAP_PRIVATE;

	int alignedoffset = (offset / getpagesize()) * getpagesize();
	int alignment = offset - alignedoffset;
	int alignedlength = ((buffersize / getpagesize()) + 1) * getpagesize();

	char* result = (char*) ::mmap(
		(void*) buffer, 
		alignedlength, 
		protection,
		flags, 
		filehandle, 
		alignedoffset);

	return ((char*) -1) == result ? 0 : result + alignment;

#endif
}