Make sure AI doesn't skip after collecting ammo. Fixes
bug #796
use std::ffi::CString;
use std::io::{ Read, Write, Seek, SeekFrom, Result };
use std::mem;
use libc::{ c_int, c_char, c_void };
use primitives::*;
use super::{ PhysFSContext };
use super::util::physfs_error_as_io_error;
#[link(name = "physfs")]
extern {
// valid filehandle on success, NULL on failure
fn PHYSFS_openAppend(filename: *const c_char) -> *const RawFile;
fn PHYSFS_openRead(filename: *const c_char) -> *const RawFile;
fn PHYSFS_openWrite(filename: *const c_char) -> *const RawFile;
// nonzero on success, 0 on failure (and the handle stays open)
// The docs make it sound like failure is rare.
fn PHYSFS_close(file: *const RawFile) -> c_int;
// Number of bytes read on success, -1 on failure.
fn PHYSFS_read(file: *const RawFile, buffer: *mut c_void,
obj_size: PHYSFS_uint32, obj_count: PHYSFS_uint32) -> PHYSFS_sint64;
// Number of bytes written on success, -1 on failure.
fn PHYSFS_write(file: *const RawFile, buffer: *const c_void,
obj_size: PHYSFS_uint32, obj_count: PHYSFS_uint32) -> PHYSFS_sint64;
// Flush buffered file; no-op for unbuffered files.
fn PHYSFS_flush(file: *const RawFile) -> c_int;
// Seek to position in file; nonzero on succss, zero on error.
fn PHYSFS_seek(file: *const RawFile, pos: PHYSFS_uint64) -> c_int;
// Current position in file, -1 on failure.
fn PHYSFS_tell(file: *const RawFile) -> PHYSFS_sint64;
// nonzero if EOF, zero if not.
fn PHYSFS_eof(file: *const RawFile) -> c_int;
// Determine file size; returns -1 if impossible
fn PHYSFS_fileLength(file: *const RawFile) -> PHYSFS_sint64;
}
/// Possible ways to open a file.
#[derive(Copy, Clone)]
pub enum Mode {
/// Append to the end of the file.
Append,
/// Read from the file.
Read,
/// Write to the file, overwriting previous data.
Write,
}
/// A wrapper for the PHYSFS_File type.
#[repr(C)]
struct RawFile {
opaque: *const c_void,
}
/// A file handle.
#[allow(dead_code)]
pub struct File<'f> {
raw: *const RawFile,
mode: Mode,
context: &'f PhysFSContext,
}
impl<'f> File<'f> {
/// Opens a file with a specific mode.
pub fn open<'g>(context: &'g PhysFSContext, filename: String, mode: Mode) -> Result<File<'g>> {
let c_filename = try!(CString::new(filename));
let raw = unsafe { match mode {
Mode::Append => PHYSFS_openAppend(c_filename.as_ptr()),
Mode::Read => PHYSFS_openRead(c_filename.as_ptr()),
Mode::Write => PHYSFS_openWrite(c_filename.as_ptr())
}};
if raw.is_null() {
Err(physfs_error_as_io_error())
}
else {
Ok(File{raw: raw, mode: mode, context: context})
}
}
/// Closes a file handle.
fn close(&self) -> Result<()> {
match unsafe {
PHYSFS_close(self.raw)
} {
0 => Err(physfs_error_as_io_error()),
_ => Ok(())
}
}
/// Checks whether eof is reached or not.
pub fn eof(&self) -> bool {
let ret = unsafe {
PHYSFS_eof(self.raw)
};
ret != 0
}
/// Determine length of file, if possible
pub fn len(&self) -> Result<u64> {
let len = unsafe { PHYSFS_fileLength(self.raw) };
if len >= 0 {
Ok(len as u64)
} else {
Err(physfs_error_as_io_error())
}
}
/// Determines current position within a file
pub fn tell(&self) -> Result<u64> {
let ret = unsafe {
PHYSFS_tell(self.raw)
};
match ret {
-1 => Err(physfs_error_as_io_error()),
_ => Ok(ret as u64)
}
}
}
impl<'f> Read for File<'f> {
/// Reads from a file
fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
let ret = unsafe {
PHYSFS_read(
self.raw,
buf.as_ptr() as *mut c_void,
mem::size_of::<u8>() as PHYSFS_uint32,
buf.len() as PHYSFS_uint32
)
};
match ret {
-1 => Err(physfs_error_as_io_error()),
_ => Ok(ret as usize)
}
}
}
impl<'f> Write for File<'f> {
/// Writes to a file.
/// This code performs no safety checks to ensure
/// that the buffer is the correct length.
fn write(&mut self, buf: &[u8]) -> Result<usize> {
let ret = unsafe {
PHYSFS_write(
self.raw,
buf.as_ptr() as *const c_void,
mem::size_of::<u8>() as PHYSFS_uint32,
buf.len() as PHYSFS_uint32
)
};
match ret {
-1 => Err(physfs_error_as_io_error()),
_ => Ok(ret as usize)
}
}
/// Flushes a file if buffered; no-op if unbuffered.
fn flush(&mut self) -> Result<()> {
let ret = unsafe {
PHYSFS_flush(self.raw)
};
match ret {
0 => Err(physfs_error_as_io_error()),
_ => Ok(())
}
}
}
impl<'f> Seek for File<'f> {
/// Seek to a new position within a file
fn seek(&mut self, pos: SeekFrom) -> Result<u64> {
let seek_pos = match pos {
SeekFrom::Start(n) => n as i64,
SeekFrom::End(n) => {
let len = try!(self.len());
n + len as i64
}
SeekFrom::Current(n) => {
let curr_pos = try!(self.tell());
n + curr_pos as i64
}
};
let result = unsafe {
PHYSFS_seek(
self.raw,
seek_pos as PHYSFS_uint64
)
};
if result == -1 {
return Err(physfs_error_as_io_error());
}
self.tell()
}
}
impl<'f> Drop for File<'f> {
fn drop(&mut self) {
let _ = self.close();
}
}