844 lines
28 KiB
C
844 lines
28 KiB
C
/* target_generic_file - Native methods for file operations
|
|
Copyright (C) 1998, 2004 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
/*
|
|
Description: generic target defintions of file functions
|
|
Systems : all
|
|
*/
|
|
|
|
#ifndef __TARGET_GENERIC_FILE__
|
|
#define __TARGET_GENERIC_FILE__
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/* check if target_native_file.h included */
|
|
#ifndef __TARGET_NATIVE_FILE__
|
|
#error Do NOT INCLUDE generic target files! Include the corresponding native target files instead!
|
|
#endif
|
|
|
|
/****************************** Includes *******************************/
|
|
/* do not move; needed here because of some macro definitions */
|
|
#include "config.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
#include <fcntl.h>
|
|
|
|
#include "target_native.h"
|
|
#include "target_native_math_int.h"
|
|
|
|
/****************** Conditional compilation switches *******************/
|
|
|
|
/***************************** Constants *******************************/
|
|
#ifndef TARGET_NATIVE_FILE_FILEFLAG_NONE
|
|
#define TARGET_NATIVE_FILE_FILEFLAG_NONE 0
|
|
#endif
|
|
#ifndef TARGET_NATIVE_FILE_FILEFLAG_CREATE
|
|
#define TARGET_NATIVE_FILE_FILEFLAG_CREATE O_CREAT
|
|
#endif
|
|
#ifndef TARGET_NATIVE_FILE_FILEFLAG_CREATE_FORCE
|
|
#define TARGET_NATIVE_FILE_FILEFLAG_CREATE_FORCE (O_CREAT|O_EXCL)
|
|
#endif
|
|
#ifndef TARGET_NATIVE_FILE_FILEFLAG_READ
|
|
#define TARGET_NATIVE_FILE_FILEFLAG_READ O_RDONLY
|
|
#endif
|
|
#ifndef TARGET_NATIVE_FILE_FILEFLAG_WRITE
|
|
#define TARGET_NATIVE_FILE_FILEFLAG_WRITE O_WRONLY
|
|
#endif
|
|
#ifndef TARGET_NATIVE_FILE_FILEFLAG_READWRITE
|
|
#define TARGET_NATIVE_FILE_FILEFLAG_READWRITE O_RDWR
|
|
#endif
|
|
#ifndef TARGET_NATIVE_FILE_FILEFLAG_TRUNCATE
|
|
#define TARGET_NATIVE_FILE_FILEFLAG_TRUNCATE O_TRUNC
|
|
#endif
|
|
#ifndef TARGET_NATIVE_FILE_FILEFLAG_APPEND
|
|
#define TARGET_NATIVE_FILE_FILEFLAG_APPEND O_APPEND
|
|
#endif
|
|
#ifndef TARGET_NATIVE_FILE_FILEFLAG_SYNC
|
|
#if !defined (O_SYNC) && defined (O_FSYNC)
|
|
#define TARGET_NATIVE_FILE_FILEFLAG_SYNC O_FSYNC
|
|
#else
|
|
#define TARGET_NATIVE_FILE_FILEFLAG_SYNC O_SYNC
|
|
#endif
|
|
#endif
|
|
#ifndef TARGET_NATIVE_FILE_FILEFLAG_DSYNC
|
|
#ifdef O_DSYNC
|
|
#define TARGET_NATIVE_FILE_FILEFLAG_DSYNC 0
|
|
#else
|
|
#define TARGET_NATIVE_FILE_FILEFLAG_DSYNC TARGET_NATIVE_FILE_FILEFLAG_SYNC
|
|
#endif
|
|
#endif
|
|
#ifndef TARGET_NATIVE_FILE_FILEFLAG_BINARY
|
|
#define TARGET_NATIVE_FILE_FILEFLAG_BINARY O_BINARY
|
|
#endif
|
|
|
|
#ifndef TARGET_NATIVE_FILE_FILEPERMISSION_NORMAL
|
|
#define TARGET_NATIVE_FILE_FILEPERMISSION_NORMAL (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
|
|
#endif
|
|
|
|
#ifndef TARGET_NATIVE_FILE_FILEPERMISSION_PRIVATE
|
|
#define TARGET_NATIVE_FILE_FILEPERMISSION_PRIVATE (S_IRUSR | S_IWUSR)
|
|
#endif
|
|
|
|
#ifndef TARGET_NATIVE_FILE_FILEPERMISSION_READONLY
|
|
#define TARGET_NATIVE_FILE_FILEPERMISSION_READONLY (~(S_IWRITE|S_IWGRP|S_IWOTH))
|
|
#endif
|
|
|
|
/***************************** Datatypes *******************************/
|
|
|
|
/***************************** Variables *******************************/
|
|
|
|
/****************************** Macros *********************************/
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_OPEN
|
|
* Purpose : open a file
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : file is created if it does not exist
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_OPEN
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#define TARGET_NATIVE_FILE_OPEN(filename,filedescriptor,flags,permissions,result) \
|
|
do { \
|
|
filedescriptor=open(filename, \
|
|
flags, \
|
|
permissions \
|
|
); \
|
|
if (filedescriptor >= 0) \
|
|
fcntl (filedescriptor,F_SETFD,FD_CLOEXEC); \
|
|
result=(filedescriptor>=0)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while (0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_OPEN_CREATE
|
|
* Purpose : create a file
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : file is created if it does not exist
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_OPEN_CREATE
|
|
#define TARGET_NATIVE_FILE_OPEN_CREATE(filename,filedescriptor,result) \
|
|
TARGET_NATIVE_FILE_OPEN(filename,\
|
|
filedescriptor,\
|
|
TARGET_NATIVE_FILE_FILEFLAG_CREATE_FORCE, \
|
|
TARGET_NATIVE_FILE_FILEPERMISSION_NORMAL, \
|
|
result \
|
|
)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_OPEN_READ
|
|
* Purpose : open an existing file for reading
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_OPEN_READ
|
|
#define TARGET_NATIVE_FILE_OPEN_READ(filename,filedescriptor,result) \
|
|
TARGET_NATIVE_FILE_OPEN(filename, \
|
|
filedescriptor,\
|
|
TARGET_NATIVE_FILE_FILEFLAG_READ, \
|
|
TARGET_NATIVE_FILE_FILEPERMISSION_NORMAL, \
|
|
result \
|
|
)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_OPEN_WRITE
|
|
* Purpose : open an existing file for writing
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_OPEN_WRITE
|
|
#define TARGET_NATIVE_FILE_OPEN_WRITE(filename,filedescriptor,result) \
|
|
TARGET_NATIVE_FILE_OPEN(filename, \
|
|
filedescriptor, \
|
|
TARGET_NATIVE_FILE_FILEFLAG_WRITE, \
|
|
TARGET_NATIVE_FILE_FILEPERMISSION_NORMAL, \
|
|
result \
|
|
)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_OPEN_READWRITE
|
|
* Purpose : create/open a file for reading/writing
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : file is created if it does not exist
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_OPEN_READWRITE
|
|
#define TARGET_NATIVE_FILE_OPEN_READWRITE(filename,filedescriptor,result) \
|
|
TARGET_NATIVE_FILE_OPEN(filename, \
|
|
filedescriptor, \
|
|
TARGET_NATIVE_FILE_FILEFLAG_READWRITE, \
|
|
TARGET_NATIVE_FILE_FILEPERMISSION_NORMAL, \
|
|
result \
|
|
)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_OPEN_READWRITE
|
|
* Purpose : create/open a file for append
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : file is created if it does not exist
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_OPEN_APPEND
|
|
#define TARGET_NATIVE_FILE_OPEN_APPEND(filename,filedescriptor,result) \
|
|
TARGET_NATIVE_FILE_OPEN_APPEND(filename, \
|
|
filedescriptor, \
|
|
TARGET_NATIVE_FILE_FILEFLAG_CREATE_FORCE|TARGET_NATIVE_FILE_FILEFLAG_APPEND, \
|
|
TARGET_NATIVE_FILE_FILEPERMISSION_NORMAL, \
|
|
result \
|
|
)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_CLOSE
|
|
* Purpose : close a file
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_CLOSE
|
|
#include <unistd.h>
|
|
#define TARGET_NATIVE_FILE_CLOSE(filedescriptor,result) \
|
|
do { \
|
|
result=(close(filedescriptor)==0)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while (0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_VALID_FILE_DESCRIPTOR
|
|
* Purpose : check if file-descriptor is valid
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_VALID_FILE_DESCRIPTOR
|
|
#if defined(HAVE_FCNTL)
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#define TARGET_NATIVE_FILE_VALID_FILE_DESCRIPTOR(filedescriptor,result) \
|
|
do { \
|
|
result=(fcntl(filedescriptor,F_GETFL,0)!=-1)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while(0)
|
|
#elif defined(HAVE_FSTAT)
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#define TARGET_NATIVE_FILE_VALID_FILE_DESCRIPTOR(filedescriptor,result) \
|
|
do { \
|
|
struct stat __stat; \
|
|
\
|
|
result=(fstat(filedescriptor,&__stat)==0)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while(0)
|
|
#else
|
|
#error fcntl() nor fstat() available for checking if file descriptor is valid
|
|
#endif
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_TELL
|
|
* Purpose : get current file position
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_TELL
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
#define TARGET_NATIVE_FILE_TELL(filedescriptor,offset,result) \
|
|
do { \
|
|
offset=lseek(filedescriptor,TARGET_NATIVE_MATH_INT_INT64_CONST_0,SEEK_CUR); \
|
|
result=((offset)!=(off_t)-1)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while (0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_SEEK_BEGIN|CURRENT|END
|
|
* Purpose : set file position relativ to begin/current/end
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_SEEK_BEGIN
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
#define TARGET_NATIVE_FILE_SEEK_BEGIN(filedescriptor,offset,newoffset,result) \
|
|
do { \
|
|
newoffset=lseek(filedescriptor,offset,SEEK_SET); \
|
|
result=((newoffset)!=(off_t)-1)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while (0)
|
|
#endif
|
|
#ifndef TARGET_NATIVE_FILE_SEEK_CURRENT
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
#define TARGET_NATIVE_FILE_SEEK_CURRENT(filedescriptor,offset,newoffset,result) \
|
|
do { \
|
|
newoffset=lseek(filedescriptor,offset,SEEK_CUR); \
|
|
result=((newoffset)!=(off_t)-1)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while (0)
|
|
#endif
|
|
#ifndef TARGET_NATIVE_FILE_SEEK_END
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
#define TARGET_NATIVE_FILE_SEEK_END(filedescriptor,offset,newoffset,result) \
|
|
do { \
|
|
newoffset=lseek(filedescriptor,offset,SEEK_END); \
|
|
result=((newoffset)!=(off_t)-1)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while (0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_TRUNCATE
|
|
* Purpose : truncate a file
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_TRUNCATE
|
|
#include <unistd.h>
|
|
#define TARGET_NATIVE_FILE_TRUNCATE(filedescriptor,offset,result) \
|
|
do { \
|
|
result=(ftruncate(filedescriptor,offset)==0)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while (0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_SIZE
|
|
* Purpose : get size of file (in bytes)
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_SIZE
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#define TARGET_NATIVE_FILE_SIZE(filedescriptor,length,result) \
|
|
do { \
|
|
struct stat __statBuffer; \
|
|
\
|
|
result=(fstat(filedescriptor,&__statBuffer)==0)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
length=TARGET_NATIVE_MATH_INT_INT32_TO_INT64(__statBuffer.st_size); \
|
|
} while (0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_AVAILABLE
|
|
* Purpose : get available bytes for read
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_AVAILABLE
|
|
#ifdef HAVE_SYS_IOCTL_H
|
|
#define BSD_COMP /* Get FIONREAD on Solaris2 */
|
|
#include <sys/ioctl.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_FILIO_H /* Get FIONREAD on Solaris 2.5 */
|
|
#include <sys/filio.h>
|
|
#endif
|
|
#if defined (FIONREAD)
|
|
#define TARGET_NATIVE_FILE_AVAILABLE(filedescriptor,length,result) \
|
|
do { \
|
|
ssize_t __n; \
|
|
\
|
|
result=(ioctl(filedescriptor,FIONREAD,(char*)&__n)==0)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
length=TARGET_NATIVE_MATH_INT_INT32_TO_INT64(__n); \
|
|
} while (0)
|
|
#elif defined(HAVE_FSTAT)
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#define TARGET_NATIVE_FILE_AVAILABLE(filedescriptor,length,result) \
|
|
do { \
|
|
struct stat __statBuffer; \
|
|
off_t __n; \
|
|
\
|
|
length=0; \
|
|
\
|
|
if ((fstat(filedescriptor,&__statBuffer)==0) && S_ISREG(__statBuffer.st_mode)) \
|
|
{ \
|
|
__n=(lseek(filedescriptor,0,SEEK_CUR)); \
|
|
if (__n!=-1) \
|
|
{ \
|
|
length=TARGET_NATIVE_MATH_INT_INT32_TO_INT64(__statBuffer.st_size-__n); \
|
|
result=TARGET_NATIVE_OK; \
|
|
} \
|
|
else \
|
|
{ \
|
|
result=TARGET_NATIVE_ERROR; \
|
|
} \
|
|
} \
|
|
else \
|
|
{ \
|
|
result=TARGET_NATIVE_ERROR; \
|
|
} \
|
|
} while (0)
|
|
#elif defined(HAVE_SELECT)
|
|
#include <string.h>
|
|
#include <sys/select.h>
|
|
#define TARGET_NATIVE_FILE_AVAILABLE(filedescriptor,length,result) \
|
|
do { \
|
|
fd_set __filedescriptset; \
|
|
struct timeval __timeval; \
|
|
\
|
|
length=0; \
|
|
\
|
|
FD_ZERO(&__filedescriptset); \
|
|
FD_SET(filedescriptor,&__filedescriptset); \
|
|
memset(&__timeval,0,sizeof(__timeval)); \
|
|
switch (select(filedescriptor+1,&__filedescriptset,NULL,NULL,&__timeval)==0) \
|
|
{ \
|
|
case -1: result=TARGET_NATIVE_ERROR; break; \
|
|
case 0: length=JNI_JLONG_CONST_0; result=TARGET_NATIVE_OK; break; \
|
|
default: length=JNI_JLONG_CONST_1; result=TARGET_NATIVE_OK; break; \
|
|
} \
|
|
} while (0)
|
|
#else
|
|
#define TARGET_NATIVE_FILE_AVAILABLE(filedescriptor,length,result) \
|
|
do { \
|
|
errno=TARGET_NATIVE_ERROR_OPERATION_NOT_PERMITTED; \
|
|
length=0; \
|
|
result=TARGET_NATIVE_ERROR; \
|
|
} while (0)
|
|
#endif
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_READ|WRITE
|
|
* Purpose : read/write from/to frile
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_READ
|
|
#include <unistd.h>
|
|
#define TARGET_NATIVE_FILE_READ(filedescriptor,buffer,length,bytesRead,result) \
|
|
do { \
|
|
bytesRead=read(filedescriptor,buffer,length); \
|
|
result=(bytesRead!=-1)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while (0)
|
|
#endif
|
|
#ifndef TARGET_NATIVE_FILE_WRITE
|
|
#include <unistd.h>
|
|
#define TARGET_NATIVE_FILE_WRITE(filedescriptor,buffer,length,bytesWritten,result) \
|
|
do { \
|
|
bytesWritten=write(filedescriptor,buffer,length); \
|
|
result=(bytesWritten!=-1)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while (0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_SET_MODE_READONLY
|
|
* Purpose : set file mode to read-only
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_SET_MODE_READONLY
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#define TARGET_NATIVE_FILE_SET_MODE_READONLY(filename,result) \
|
|
do { \
|
|
struct stat __statBuffer; \
|
|
\
|
|
if (stat(filename,&__statBuffer)==0) { \
|
|
result=(chmod(filename,__statBuffer.st_mode & TARGET_NATIVE_FILE_FILEPERMISSION_READONLY)==0)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} else { \
|
|
result=TARGET_NATIVE_ERROR; \
|
|
} \
|
|
} while (0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_EXISTS
|
|
* Purpose : check if file exists
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_EXISTS
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#define TARGET_NATIVE_FILE_EXISTS(filename,result) \
|
|
do { \
|
|
struct stat __statBuffer; \
|
|
\
|
|
result=(stat(filename,&__statBuffer)==0)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while (0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_IS_FILE
|
|
* Purpose : check if directory entry is a file
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_IS_FILE
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#define TARGET_NATIVE_FILE_IS_FILE(filename,result) \
|
|
do { \
|
|
struct stat __statBuffer; \
|
|
\
|
|
result=((stat(filename,&__statBuffer)==0) && (S_ISREG(__statBuffer.st_mode)))?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while (0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_IS_DIRECTORY
|
|
* Purpose : check if directory entry is a directory
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_IS_DIRECTORY
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#define TARGET_NATIVE_FILE_IS_DIRECTORY(filename,result) \
|
|
do { \
|
|
struct stat __statBuffer; \
|
|
\
|
|
result=((stat(filename,&__statBuffer)==0) && (S_ISDIR(__statBuffer.st_mode)))?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while (0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_GET_LAST_MODIFIED
|
|
* Purpose : get last modification time of file (milliseconds)
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_GET_LAST_MODIFIED
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#define TARGET_NATIVE_FILE_GET_LAST_MODIFIED(filename,time,result) \
|
|
do { \
|
|
struct stat __statBuffer; \
|
|
\
|
|
time=TARGET_NATIVE_MATH_INT_INT64_CONST_0; \
|
|
if (stat(filename,&__statBuffer)==0) { \
|
|
time=TARGET_NATIVE_MATH_INT_INT64_MUL(TARGET_NATIVE_MATH_INT_INT32_TO_INT64(__statBuffer.st_mtime), \
|
|
TARGET_NATIVE_MATH_INT_INT32_TO_INT64(1000) \
|
|
); \
|
|
result=TARGET_NATIVE_OK; \
|
|
} else { \
|
|
result=TARGET_NATIVE_ERROR; \
|
|
} \
|
|
} while (0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_SET_LAST_MODIFIED
|
|
* Purpose : set last modification time of file (milliseconds)
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_SET_LAST_MODIFIED
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#ifdef HAVE_UTIME_H
|
|
#include <utime.h>
|
|
#elif HAVE_SYS_UTIME_H
|
|
#include <sys/utime.h>
|
|
#else
|
|
#error utime.h not found. Please check configuration.
|
|
#endif
|
|
#define TARGET_NATIVE_FILE_SET_LAST_MODIFIED(filename,time,result) \
|
|
do { \
|
|
struct stat __statBuffer; \
|
|
struct utimbuf __utimeBuffer; \
|
|
\
|
|
if (stat(filename,&__statBuffer)==0) { \
|
|
__utimeBuffer.actime =__statBuffer.st_atime; \
|
|
__utimeBuffer.modtime=TARGET_NATIVE_MATH_INT_INT64_TO_INT32(TARGET_NATIVE_MATH_INT_INT64_DIV(time, \
|
|
TARGET_NATIVE_MATH_INT_INT32_TO_INT64(1000) \
|
|
) \
|
|
); \
|
|
result=(utime(filename,&__utimeBuffer)==0)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} else { \
|
|
result=TARGET_NATIVE_ERROR; \
|
|
} \
|
|
} while (0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_DELETE
|
|
* Purpose : delete a file,link or directory
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_DELETE
|
|
#define TARGET_NATIVE_FILE_DELETE(filename,result) \
|
|
do { \
|
|
result=((unlink(filename)==0) || (rmdir(filename)==0))?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while (0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_RENAME
|
|
* Purpose : delete a file, link or directory
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_RENAME
|
|
#define TARGET_NATIVE_FILE_RENAME(oldfilename,newfilename,result) \
|
|
do { \
|
|
result=(rename(oldfilename,newfilename)==0)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while (0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_MAKE_DIR
|
|
* Purpose : create new directory
|
|
* Input : name - directory name
|
|
* Output : result - 1 if successful, 0 otherwise
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_MAKE_DIR
|
|
#include <sys/stat.h>
|
|
#define TARGET_NATIVE_FILE_MAKE_DIR(name,result) \
|
|
do { \
|
|
result=((mkdir(name,(S_IRWXO|S_IRWXG|S_IRWXU))==0)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR); \
|
|
} while (0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_GET_CWD
|
|
* Purpose : get current working directory
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_GET_CWD
|
|
#include <unistd.h>
|
|
#define TARGET_NATIVE_FILE_GET_CWD(path,maxPathLength,result) \
|
|
do {\
|
|
result=(getcwd(path,maxPathLength)!=NULL)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while (0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_OPEN_DIR
|
|
* Purpose : open directory for reading entries.
|
|
* Input : -
|
|
* Output : handle - handle if not error, NULL otherwise
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_OPEN_DIR
|
|
#include <sys/types.h>
|
|
#include <dirent.h>
|
|
#define TARGET_NATIVE_FILE_OPEN_DIR(filename,handle,result) \
|
|
do { \
|
|
handle=(void*)opendir(filename); \
|
|
result=(handle!=NULL)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while(0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_CLOSE_DIR
|
|
* Purpose : close directory
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_CLOSE_DIR
|
|
#include <sys/types.h>
|
|
#include <dirent.h>
|
|
#define TARGET_NATIVE_FILE_CLOSE_DIR(handle,result) \
|
|
do { \
|
|
closedir((DIR*)handle); \
|
|
result=TARGET_NATIVE_OK; \
|
|
} while(0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_READ_DIR
|
|
* Purpose : read directory entry
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
/* XXX ??? name als buffer? */
|
|
#ifndef TARGET_NATIVE_FILE_READ_DIR
|
|
#include <sys/types.h>
|
|
#include <dirent.h>
|
|
#define TARGET_NATIVE_FILE_READ_DIR(handle,name,result) \
|
|
do { \
|
|
struct dirent *__direntBuffer; \
|
|
\
|
|
name=NULL; \
|
|
\
|
|
__direntBuffer=readdir((DIR*)handle); \
|
|
if (__direntBuffer!=NULL) { \
|
|
name=__direntBuffer->d_name; \
|
|
result=TARGET_NATIVE_OK; \
|
|
} else { \
|
|
result=TARGET_NATIVE_ERROR; \
|
|
} \
|
|
} while (0)
|
|
#endif
|
|
|
|
/***********************************************************************\
|
|
* Name : TARGET_NATIVE_FILE_FSYNC
|
|
* Purpose : do filesystem sync
|
|
* Input : -
|
|
* Output : -
|
|
* Return : -
|
|
* Side-effect: unknown
|
|
* Notes : -
|
|
\***********************************************************************/
|
|
|
|
#ifndef TARGET_NATIVE_FILE_FSYNC
|
|
#define TARGET_NATIVE_FILE_FSYNC(filedescriptor,result) \
|
|
do { \
|
|
result=(fsync(filedescriptor)==0)?TARGET_NATIVE_OK:TARGET_NATIVE_ERROR; \
|
|
} while(0)
|
|
#endif
|
|
|
|
/***************************** Functions *******************************/
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* __TARGET_GENERIC_FILE__ */
|
|
|
|
/* end of file */
|
|
|