wasCSharpSQLite – Rev 1
?pathlinks?
#undef DEBUG
/*
* FileChannel.java --
*
* Copyright (c) 1997 Sun Microsystems, Inc.
*
* See the file "license.terms" for information on usage and
* redistribution of this file, and for a DISCLAIMER OF ALL
* WARRANTIES.
*
* Included in SQLite3 port to C# for use in testharness only; 2008 Noah B Hart
*
* RCS @(#) $Id: FileChannel.java,v 1.20 2003/03/08 03:42:44 mdejong Exp $
*
*/
using System;
using System.IO;
namespace tcl.lang
{
/// <summary> Subclass of the abstract class Channel. It implements all of the
/// methods to perform read, write, open, close, etc on a file.
/// </summary>
class FileChannel : Channel
{
public override string ChanType
{
get
{
return "file";
}
}
override protected internal Stream InputStream
{
get
{
// return new FileInputStream(file.getFD());
return file;
}
}
override protected internal Stream OutputStream
{
get
{
// return new FileOutputStream(file.getFD());
return file;
}
}
/// <summary> The file needs to have a file pointer that can be moved randomly
/// within the file. The RandomAccessFile is the only java.io class
/// that allows this behavior.
/// </summary>
private FileStream file = null;
/// <summary> Open a file with the read/write permissions determined by modeFlags.
/// This method must be called before any other methods will function
/// properly.
///
/// </summary>
/// <param name="interp">currrent interpreter.
/// </param>
/// <param name="fileName">the absolute path or name of file in the current
/// directory to open
/// </param>
/// <param name="modeFlags">modes used to open a file for reading, writing, etc
/// </param>
/// <returns> the channelId of the file.
/// </returns>
/// <exception cref=""> TclException is thrown when the modeFlags try to open
/// a file it does not have permission for or if the
/// file dosent exist and CREAT wasnt specified.
/// </exception>
/// <exception cref=""> IOException is thrown when an IO error occurs that was not
/// correctly tested for. Most cases should be caught.
/// </exception>
internal string open( Interp interp, string fileName, int modeFlags )
{
mode = modeFlags;
FileInfo fileObj = FileUtil.getNewFileObj( interp, fileName );
FileMode fileMode = 0;
FileAccess fileAccess = 0;
if ( ( ( modeFlags & TclIO.CREAT ) != 0 ) && ( ( modeFlags & TclIO.EXCL ) != 0 ) )
{
fileMode = FileMode.CreateNew;
}
else if ( ( modeFlags & TclIO.CREAT ) != 0 )
{
fileMode = FileMode.Create;
}
else
{
fileMode = FileMode.Open;
}
if ( ( modeFlags & TclIO.TRUNC ) != 0 )
{
fileMode = fileMode & FileMode.Truncate;
}
if ( ( modeFlags & TclIO.APPEND ) != 0 )
{
fileMode = fileMode & FileMode.Append;
}
if ( ( modeFlags & TclIO.RDWR ) != 0 )
{
fileAccess = FileAccess.ReadWrite;
}
else if ( ( modeFlags & TclIO.RDONLY ) != 0 )
{
fileAccess = FileAccess.Read;
}
else if ( ( modeFlags & TclIO.WRONLY ) != 0 )
{
fileAccess = FileAccess.Write;
}
else
{
throw new TclRuntimeError( "FileChannel.java: invalid mode value" );
}
file = new FileStream( fileObj.FullName, fileMode, fileAccess, FileShare.ReadWrite );
string fName = TclIO.getNextDescriptor( interp, "file" );
ChanName = fName;
//Console.Out.WriteLine("",file.Name);
return fName;
}
/// <summary> Close the file. The file MUST be open or a TclRuntimeError
/// is thrown.
/// </summary>
internal override void close()
{
if ( file == null )
{
throw new TclRuntimeError( "FileChannel.close(): null file object" );
}
// Invoke super.close() first since it might write an eof char
try
{
base.close();
}
finally
{
// Console.Out.WriteLine("Debugg Closing {0}",file.Name);
file.Close();
}
}
/// <summary> Move the file pointer internal to the RandomAccessFile object.
/// The file MUST be open or a TclRuntimeError is thrown.
///
/// </summary>
/// <param name="offset">The number of bytes to move the file pointer.
/// </param>
/// <param name="inmode">to begin incrementing the file pointer; beginning,
/// current, or end of the file.
/// </param>
public override void seek( Interp interp, long offset, int inmode )
{
if ( file == null )
{
throw new TclRuntimeError( "FileChannel.seek(): null file object" );
}
//FIXME: Disallow seek on dead channels (raise TclPosixException ??)
//if (CheckForDeadChannel(NULL, statePtr)) {
// return Tcl_LongAsWide(-1);
//}
// Compute how much input and output is buffered. If both input and
// output is buffered, cannot compute the current position.
int inputBuffered = NumBufferedInputBytes;
int outputBuffered = NumBufferedOutputBytes;
if ( ( inputBuffered != 0 ) && ( outputBuffered != 0 ) )
{
throw new TclPosixException( interp, TclPosixException.EFAULT, true, "error during seek on \"" + ChanName + "\"" );
}
// If we are seeking relative to the current position, compute the
// corrected offset taking into account the amount of unread input.
if ( inmode == TclIO.SEEK_CUR )
{
offset -= inputBuffered;
}
// The seekReset method will discard queued input and
// reset flags like EOF and BLOCKED.
if ( input != null )
{
input.seekReset();
}
// FIXME: Next block is disabled since non-blocking is not implemented.
// If the channel is in asynchronous output mode, switch it back
// to synchronous mode and cancel any async flush that may be
// scheduled. After the flush, the channel will be put back into
// asynchronous output mode.
bool wasAsync = false;
//if (false && !Blocking)
//{
// wasAsync = true;
// Blocking = true;
// if (BgFlushScheduled)
// {
// //scheduleBgFlush();
// }
//}
// If there is data buffered in curOut then mark the
// channel as ready to flush before invoking flushChannel.
if ( output != null )
{
output.seekCheckBuferReady();
}
// If the flush fails we cannot recover the original position. In
// that case the seek is not attempted because we do not know where
// the access position is - instead we return the error. FlushChannel
// has already called Tcl_SetErrno() to report the error upwards.
// If the flush succeeds we do the seek also.
if ( output != null && output.flushChannel( null, false ) != 0 )
{
// FIXME: IS this the proper action to take on error?
throw new IOException( "flush error while seeking" );
}
else
{
// Now seek to the new position in the channel as requested by the
// caller.
long actual_offset;
switch ( inmode )
{
case TclIO.SEEK_SET:
{
actual_offset = offset;
break;
}
case TclIO.SEEK_CUR:
{
actual_offset = file.Position + offset;
break;
}
case TclIO.SEEK_END:
{
actual_offset = file.Length + offset;
break;
}
default:
{
throw new TclRuntimeError( "invalid seek mode" );
}
}
// A negative offset to seek() would raise an IOException, but
// we want to raise an invalid argument error instead
if ( actual_offset < 0 )
{
throw new TclPosixException( interp, TclPosixException.EINVAL, true, "error during seek on \"" + ChanName + "\"" );
}
file.Seek( actual_offset, SeekOrigin.Begin );
}
// Restore to nonblocking mode if that was the previous behavior.
//
// NOTE: Even if there was an async flush active we do not restore
// it now because we already flushed all the queued output, above.
if ( wasAsync )
{
Blocking = false;
}
}
/// <summary> Tcl_Tell -> tell
///
/// Return the current offset of the file pointer in number of bytes from
/// the beginning of the file. The file MUST be open or a TclRuntimeError
/// is thrown.
///
/// </summary>
/// <returns> The current value of the file pointer.
/// </returns>
public override long tell()
{
if ( file == null )
{
throw new TclRuntimeError( "FileChannel.tell(): null file object" );
}
int inputBuffered = NumBufferedInputBytes;
int outputBuffered = NumBufferedOutputBytes;
if ( ( inputBuffered != 0 ) && ( outputBuffered != 0 ) )
{
// FIXME: Posix error EFAULT ?
return -1;
}
long curPos = file.Position;
if ( curPos == -1 )
{
// FIXME: Set errno here?
return -1;
}
if ( inputBuffered != 0 )
{
return curPos - inputBuffered;
}
return curPos + outputBuffered;
}
/// <summary> If the file dosent exist then a TclExcpetion is thrown.
///
/// </summary>
/// <param name="interp">currrent interpreter.
/// </param>
/// <param name="fileObj">a java.io.File object of the file for this channel.
/// </param>
private void checkFileExists( Interp interp, FileInfo fileObj )
{
bool tmpBool;
if ( File.Exists( fileObj.FullName ) )
tmpBool = true;
else
tmpBool = Directory.Exists( fileObj.FullName );
if ( !tmpBool )
{
throw new TclPosixException( interp, TclPosixException.ENOENT, true, "couldn't open \"" + fileObj.Name + "\"" );
}
}
/// <summary> Checks the read/write permissions on the File object. If inmode is less
/// than 0 it checks for read permissions, if mode greater than 0 it checks
/// for write permissions, and if it equals 0 then it checks both.
///
/// </summary>
/// <param name="interp">currrent interpreter.
/// </param>
/// <param name="fileObj">a java.io.File object of the file for this channel.
/// </param>
/// <param name="inmode">what permissions to check for.
/// </param>
private void checkReadWritePerm( Interp interp, FileInfo fileObj, int inmode )
{
bool error = false;
if ( inmode <= 0 )
{
// HACK
// if (!fileObj.canRead())
// {
// error = true;
// }
}
if ( inmode >= 0 )
{
if ( !SupportClass.FileCanWrite( fileObj ) )
{
error = true;
}
}
if ( error )
{
throw new TclPosixException( interp, TclPosixException.EACCES, true, "couldn't open \"" + fileObj.Name + "\"" );
}
}
}
}