| /* 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 */ |
| |
