Annotation of embedaddon/php/ext/sqlite/libsqlite/src/os.h, revision 1.1

1.1     ! misho       1: /*
        !             2: ** 2001 September 16
        !             3: **
        !             4: ** The author disclaims copyright to this source code.  In place of
        !             5: ** a legal notice, here is a blessing:
        !             6: **
        !             7: **    May you do good and not evil.
        !             8: **    May you find forgiveness for yourself and forgive others.
        !             9: **    May you share freely, never taking more than you give.
        !            10: **
        !            11: ******************************************************************************
        !            12: **
        !            13: ** This header file (together with is companion C source-code file
        !            14: ** "os.c") attempt to abstract the underlying operating system so that
        !            15: ** the SQLite library will work on both POSIX and windows systems.
        !            16: */
        !            17: #ifndef _SQLITE_OS_H_
        !            18: #define _SQLITE_OS_H_
        !            19: 
        !            20: /*
        !            21: ** Helpful hint:  To get this to compile on HP/UX, add -D_INCLUDE_POSIX_SOURCE
        !            22: ** to the compiler command line.
        !            23: */
        !            24: 
        !            25: /*
        !            26: ** These #defines should enable >2GB file support on Posix if the
        !            27: ** underlying operating system supports it.  If the OS lacks
        !            28: ** large file support, or if the OS is windows, these should be no-ops.
        !            29: **
        !            30: ** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
        !            31: ** on the compiler command line.  This is necessary if you are compiling
        !            32: ** on a recent machine (ex: RedHat 7.2) but you want your code to work
        !            33: ** on an older machine (ex: RedHat 6.0).  If you compile on RedHat 7.2
        !            34: ** without this option, LFS is enable.  But LFS does not exist in the kernel
        !            35: ** in RedHat 6.0, so the code won't work.  Hence, for maximum binary
        !            36: ** portability you should omit LFS.
        !            37: **
        !            38: ** Similar is true for MacOS.  LFS is only supported on MacOS 9 and later.
        !            39: */
        !            40: #ifndef SQLITE_DISABLE_LFS
        !            41: # define _LARGE_FILE       1
        !            42: # ifndef _FILE_OFFSET_BITS
        !            43: #   define _FILE_OFFSET_BITS 64
        !            44: # endif
        !            45: # define _LARGEFILE_SOURCE 1
        !            46: #endif
        !            47: 
        !            48: /*
        !            49: ** Temporary files are named starting with this prefix followed by 16 random
        !            50: ** alphanumeric characters, and no file extension. They are stored in the
        !            51: ** OS's standard temporary file directory, and are deleted prior to exit.
        !            52: ** If sqlite is being embedded in another program, you may wish to change the
        !            53: ** prefix to reflect your program's name, so that if your program exits
        !            54: ** prematurely, old temporary files can be easily identified. This can be done
        !            55: ** using -DTEMP_FILE_PREFIX=myprefix_ on the compiler command line.
        !            56: */
        !            57: #ifndef TEMP_FILE_PREFIX
        !            58: # define TEMP_FILE_PREFIX "sqlite_"
        !            59: #endif
        !            60: 
        !            61: /*
        !            62: ** Figure out if we are dealing with Unix, Windows or MacOS.
        !            63: **
        !            64: ** N.B. MacOS means Mac Classic (or Carbon). Treat Darwin (OS X) as Unix.
        !            65: **      The MacOS build is designed to use CodeWarrior (tested with v8)
        !            66: */
        !            67: #ifndef OS_UNIX
        !            68: # ifndef OS_WIN
        !            69: #  ifndef OS_MAC
        !            70: #    if defined(__MACOS__)
        !            71: #      define OS_MAC 1
        !            72: #      define OS_WIN 0
        !            73: #      define OS_UNIX 0
        !            74: #    elif defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__)
        !            75: #      define OS_MAC 0
        !            76: #      define OS_WIN 1
        !            77: #      define OS_UNIX 0
        !            78: #    else
        !            79: #      define OS_MAC 0
        !            80: #      define OS_WIN 0
        !            81: #      define OS_UNIX 1
        !            82: #    endif
        !            83: #  else
        !            84: #    define OS_WIN 0
        !            85: #    define OS_UNIX 0
        !            86: #  endif
        !            87: # else
        !            88: #  define OS_MAC 0
        !            89: #  define OS_UNIX 0
        !            90: # endif
        !            91: #else
        !            92: # define OS_MAC 0
        !            93: # ifndef OS_WIN
        !            94: #  define OS_WIN 0
        !            95: # endif
        !            96: #endif
        !            97: 
        !            98: /*
        !            99: ** A handle for an open file is stored in an OsFile object.
        !           100: */
        !           101: #if OS_UNIX
        !           102: # include <sys/types.h>
        !           103: # include <sys/stat.h>
        !           104: # include <fcntl.h>
        !           105: # include <unistd.h>
        !           106:   typedef struct OsFile OsFile;
        !           107:   struct OsFile {
        !           108:     struct openCnt *pOpen;    /* Info about all open fd's on this inode */
        !           109:     struct lockInfo *pLock;   /* Info about locks on this inode */
        !           110:     int fd;                   /* The file descriptor */
        !           111:     int locked;               /* True if this instance holds the lock */
        !           112:     int dirfd;                /* File descriptor for the directory */
        !           113:   };
        !           114: # define SQLITE_TEMPNAME_SIZE 200
        !           115: # if defined(HAVE_USLEEP) && HAVE_USLEEP
        !           116: #  define SQLITE_MIN_SLEEP_MS 1
        !           117: # else
        !           118: #  define SQLITE_MIN_SLEEP_MS 1000
        !           119: # endif
        !           120: #endif
        !           121: 
        !           122: #if OS_WIN
        !           123: #include <windows.h>
        !           124: #include <winbase.h>
        !           125:   typedef struct OsFile OsFile;
        !           126:   struct OsFile {
        !           127:     HANDLE h;               /* Handle for accessing the file */
        !           128:     int locked;             /* 0: unlocked, <0: write lock, >0: read lock */
        !           129:   };
        !           130: # if defined(_MSC_VER) || defined(__BORLANDC__)
        !           131:     typedef __int64 off_t;
        !           132: # else
        !           133: #  if !defined(_CYGWIN_TYPES_H)
        !           134:      typedef long long off_t;
        !           135: #    if defined(__MINGW32__)
        !           136: #      define  _OFF_T_
        !           137: #    endif
        !           138: #  endif
        !           139: # endif
        !           140: # define SQLITE_TEMPNAME_SIZE (MAX_PATH+50)
        !           141: # define SQLITE_MIN_SLEEP_MS 1
        !           142: #endif
        !           143: 
        !           144: #if OS_MAC
        !           145: # include <unistd.h>
        !           146: # include <Files.h>
        !           147:   typedef struct OsFile OsFile;
        !           148:   struct OsFile {
        !           149:     SInt16 refNum;           /* Data fork/file reference number */
        !           150:     SInt16 refNumRF;         /* Resource fork reference number (for locking) */
        !           151:     int locked;              /* 0: unlocked, <0: write lock, >0: read lock */
        !           152:     int delOnClose;          /* True if file is to be deleted on close */
        !           153:     char *pathToDel;         /* Name of file to delete on close */
        !           154:   };
        !           155: # ifdef _LARGE_FILE
        !           156:     typedef SInt64 off_t;
        !           157: # else
        !           158:     typedef SInt32 off_t;
        !           159: # endif
        !           160: # define SQLITE_TEMPNAME_SIZE _MAX_PATH
        !           161: # define SQLITE_MIN_SLEEP_MS 17
        !           162: #endif
        !           163: 
        !           164: int sqliteOsDelete(const char*);
        !           165: int sqliteOsFileExists(const char*);
        !           166: int sqliteOsFileRename(const char*, const char*);
        !           167: int sqliteOsOpenReadWrite(const char*, OsFile*, int*);
        !           168: int sqliteOsOpenExclusive(const char*, OsFile*, int);
        !           169: int sqliteOsOpenReadOnly(const char*, OsFile*);
        !           170: int sqliteOsOpenDirectory(const char*, OsFile*);
        !           171: int sqliteOsTempFileName(char*);
        !           172: int sqliteOsClose(OsFile*);
        !           173: int sqliteOsRead(OsFile*, void*, int amt);
        !           174: int sqliteOsWrite(OsFile*, const void*, int amt);
        !           175: int sqliteOsSeek(OsFile*, off_t offset);
        !           176: int sqliteOsSync(OsFile*);
        !           177: int sqliteOsTruncate(OsFile*, off_t size);
        !           178: int sqliteOsFileSize(OsFile*, off_t *pSize);
        !           179: int sqliteOsReadLock(OsFile*);
        !           180: int sqliteOsWriteLock(OsFile*);
        !           181: int sqliteOsUnlock(OsFile*);
        !           182: int sqliteOsRandomSeed(char*);
        !           183: int sqliteOsSleep(int ms);
        !           184: int sqliteOsCurrentTime(double*);
        !           185: void sqliteOsEnterMutex(void);
        !           186: void sqliteOsLeaveMutex(void);
        !           187: char *sqliteOsFullPathname(const char*);
        !           188: 
        !           189: 
        !           190: 
        !           191: #endif /* _SQLITE_OS_H_ */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>