lucy-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mar...@apache.org
Subject svn commit: r930438 - in /lucene/lucy/trunk/core/Lucy: Store/ Test/Store/
Date Fri, 02 Apr 2010 23:36:48 GMT
Author: marvin
Date: Fri Apr  2 23:36:47 2010
New Revision: 930438

URL: http://svn.apache.org/viewvc?rev=930438&view=rev
Log:
Switch over to stdint.h types within core/Lucy/Store and core/Lucy/Test/Store.

Modified:
    lucene/lucy/trunk/core/Lucy/Store/CompoundFileReader.bp
    lucene/lucy/trunk/core/Lucy/Store/CompoundFileReader.c
    lucene/lucy/trunk/core/Lucy/Store/CompoundFileWriter.bp
    lucene/lucy/trunk/core/Lucy/Store/CompoundFileWriter.c
    lucene/lucy/trunk/core/Lucy/Store/FSFileHandle.bp
    lucene/lucy/trunk/core/Lucy/Store/FSFileHandle.c
    lucene/lucy/trunk/core/Lucy/Store/FSFolder.bp
    lucene/lucy/trunk/core/Lucy/Store/FSFolder.c
    lucene/lucy/trunk/core/Lucy/Store/FileHandle.bp
    lucene/lucy/trunk/core/Lucy/Store/FileHandle.c
    lucene/lucy/trunk/core/Lucy/Store/FileWindow.bp
    lucene/lucy/trunk/core/Lucy/Store/FileWindow.c
    lucene/lucy/trunk/core/Lucy/Store/Folder.bp
    lucene/lucy/trunk/core/Lucy/Store/Folder.c
    lucene/lucy/trunk/core/Lucy/Store/InStream.bp
    lucene/lucy/trunk/core/Lucy/Store/InStream.c
    lucene/lucy/trunk/core/Lucy/Store/OutStream.bp
    lucene/lucy/trunk/core/Lucy/Store/OutStream.c
    lucene/lucy/trunk/core/Lucy/Store/RAMDirHandle.bp
    lucene/lucy/trunk/core/Lucy/Store/RAMDirHandle.c
    lucene/lucy/trunk/core/Lucy/Store/RAMFileHandle.bp
    lucene/lucy/trunk/core/Lucy/Store/RAMFileHandle.c
    lucene/lucy/trunk/core/Lucy/Store/RAMFolder.bp
    lucene/lucy/trunk/core/Lucy/Store/RAMFolder.c
    lucene/lucy/trunk/core/Lucy/Test/Store/MockFileHandle.bp
    lucene/lucy/trunk/core/Lucy/Test/Store/MockFileHandle.c
    lucene/lucy/trunk/core/Lucy/Test/Store/TestFSFileHandle.c
    lucene/lucy/trunk/core/Lucy/Test/Store/TestFSFolder.c
    lucene/lucy/trunk/core/Lucy/Test/Store/TestFolderCommon.bp
    lucene/lucy/trunk/core/Lucy/Test/Store/TestFolderCommon.c
    lucene/lucy/trunk/core/Lucy/Test/Store/TestIOPrimitives.c
    lucene/lucy/trunk/core/Lucy/Test/Store/TestInStream.c

Modified: lucene/lucy/trunk/core/Lucy/Store/CompoundFileReader.bp
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/CompoundFileReader.bp?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/CompoundFileReader.bp (original)
+++ lucene/lucy/trunk/core/Lucy/Store/CompoundFileReader.bp Fri Apr  2 23:36:47 2010
@@ -20,7 +20,7 @@ class Lucy::Store::CompoundFileReader cn
     Folder       *real_folder;
     Hash         *records;
     InStream     *instream;
-    i32_t         format;
+    int32_t       format;
 
     inert incremented nullable CompoundFileReader*
     open(Folder *folder);
@@ -55,7 +55,7 @@ class Lucy::Store::CompoundFileReader cn
 
     incremented nullable FileHandle*
     Local_Open_FileHandle(CompoundFileReader *self, const CharBuf *name, 
-                          u32_t flags);
+                          uint32_t flags);
 
     incremented nullable InStream*
     Local_Open_In(CompoundFileReader *self, const CharBuf *name);
@@ -77,7 +77,7 @@ class Lucy::Store::CFReaderDirHandle cni
 
     CompoundFileReader *cf_reader;
     VArray             *elems;
-    i32_t               tick;
+    int32_t             tick;
 
     inert incremented CFReaderDirHandle*
     new(CompoundFileReader *cf_reader);

Modified: lucene/lucy/trunk/core/Lucy/Store/CompoundFileReader.c
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/CompoundFileReader.c?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/CompoundFileReader.c (original)
+++ lucene/lucy/trunk/core/Lucy/Store/CompoundFileReader.c Fri Apr  2 23:36:47 2010
@@ -34,7 +34,7 @@ CFReader_do_open(CompoundFileReader *sel
     }
     else {
         Obj *format = Hash_Fetch_Str(metadata, "format", 6);
-        self->format = format ? (i32_t)Obj_To_I64(format) : 0;
+        self->format = format ? (int32_t)Obj_To_I64(format) : 0;
         self->records = (Hash*)INCREF(Hash_Fetch_Str(metadata, "files", 5));
         if (self->format < 1) { 
             error = Err_new(CB_newf(
@@ -115,7 +115,7 @@ CFReader_set_path(CompoundFileReader *se
 
 FileHandle*
 CFReader_local_open_filehandle(CompoundFileReader *self, 
-                               const CharBuf *name, u32_t flags)
+                               const CharBuf *name, uint32_t flags)
 {
     Hash *entry = (Hash*)Hash_Fetch(self->records, (Obj*)name);
     FileHandle *fh = NULL;
@@ -295,7 +295,7 @@ CFReaderDH_next(CFReaderDirHandle *self)
 {
     if (self->elems) {
         self->tick++;
-        if (self->tick < (i32_t)VA_Get_Size(self->elems)) {
+        if (self->tick < (int32_t)VA_Get_Size(self->elems)) {
             CharBuf *path = (CharBuf*)CERTIFY(
                 VA_Fetch(self->elems, self->tick), CHARBUF);
             CB_Mimic(self->entry, (Obj*)path);

Modified: lucene/lucy/trunk/core/Lucy/Store/CompoundFileWriter.bp
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/CompoundFileWriter.bp?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/CompoundFileWriter.bp (original)
+++ lucene/lucy/trunk/core/Lucy/Store/CompoundFileWriter.bp Fri Apr  2 23:36:47 2010
@@ -18,7 +18,7 @@ class Lucy::Store::CompoundFileWriter cn
 
     Folder      *folder;
 
-    inert i32_t current_file_format;
+    inert int32_t current_file_format;
 
     inert incremented CompoundFileWriter*
     new(Folder *folder);

Modified: lucene/lucy/trunk/core/Lucy/Store/CompoundFileWriter.c
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/CompoundFileWriter.c?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/CompoundFileWriter.c (original)
+++ lucene/lucy/trunk/core/Lucy/Store/CompoundFileWriter.c Fri Apr  2 23:36:47 2010
@@ -8,7 +8,7 @@
 #include "Lucy/Util/IndexFileNames.h"
 #include "Lucy/Util/Json.h"
 
-i32_t CFWriter_current_file_format = 2;
+int32_t CFWriter_current_file_format = 2;
 
 /* Helper which does the heavy lifting for CFWriter_consolidate. */
 static void
@@ -83,7 +83,7 @@ S_do_consolidate(CompoundFileWriter *sel
     VArray    *merged       = VA_new(VA_Get_Size(files));
     CharBuf   *cf_file     = (CharBuf*)ZCB_WRAP_STR("cf.dat", 6);
     OutStream *outstream    = Folder_Open_Out(folder, (CharBuf*)cf_file);
-    u32_t      i, max;
+    uint32_t   i, max;
     bool_t     rename_success;
 
     if (!outstream) { RETHROW(INCREF(Err_get_error())); }
@@ -102,7 +102,7 @@ S_do_consolidate(CompoundFileWriter *sel
         if (!CB_Ends_With_Str(infilename, ".json", 5)) {
             InStream *instream   = Folder_Open_In(folder, infilename);
             Hash     *file_data  = Hash_new(2);
-            i64_t     offset, len;
+            int64_t   offset, len;
 
             if (!instream) { RETHROW(INCREF(Err_get_error())); }
 

Modified: lucene/lucy/trunk/core/Lucy/Store/FSFileHandle.bp
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/FSFileHandle.bp?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/FSFileHandle.bp (original)
+++ lucene/lucy/trunk/core/Lucy/Store/FSFileHandle.bp Fri Apr  2 23:36:47 2010
@@ -8,8 +8,8 @@ class Lucy::Store::FSFileHandle cnick FS
     int    fd;
     void  *win_fhandle;
     void  *win_maphandle;
-    i64_t  len;
-    i64_t  page_size;
+    int64_t  len;
+    int64_t  page_size;
     char  *buf;
 
     /** Return a new FSFileHandle, or set Err_error and return NULL if
@@ -19,24 +19,24 @@ class Lucy::Store::FSFileHandle cnick FS
      * @param flags FileHandle constructor flags.
      */
     inert incremented nullable FSFileHandle* 
-    open(const CharBuf *path = NULL, u32_t flags);
+    open(const CharBuf *path = NULL, uint32_t flags);
 
     inert nullable FSFileHandle* 
-    do_open(FSFileHandle *self, const CharBuf *path = NULL, u32_t flags);
+    do_open(FSFileHandle *self, const CharBuf *path = NULL, uint32_t flags);
 
     bool_t
-    Window(FSFileHandle *self, FileWindow *window, i64_t offset, i64_t len);
+    Window(FSFileHandle *self, FileWindow *window, int64_t offset, int64_t len);
 
     bool_t
     Release_Window(FSFileHandle *self, FileWindow *window);
 
     bool_t
-    Read(FSFileHandle *self, char *dest, i64_t offset, size_t len);
+    Read(FSFileHandle *self, char *dest, int64_t offset, size_t len);
 
     bool_t
     Write(FSFileHandle *self, const void *data, size_t len);
 
-    i64_t
+    int64_t
     Length(FSFileHandle *self);
 
     bool_t

Modified: lucene/lucy/trunk/core/Lucy/Store/FSFileHandle.c
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/FSFileHandle.c?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/FSFileHandle.c (original)
+++ lucene/lucy/trunk/core/Lucy/Store/FSFileHandle.c Fri Apr  2 23:36:47 2010
@@ -25,7 +25,7 @@
 
 /* Convert FileHandle flags to POSIX flags. */
 static INLINE int
-SI_posix_flags(u32_t fh_flags)
+SI_posix_flags(uint32_t fh_flags)
 {
     int posix_flags = 0;
     if (fh_flags & FH_WRITE_ONLY) { posix_flags |= O_WRONLY; }
@@ -48,16 +48,16 @@ SI_posix_flags(u32_t fh_flags)
  * and set Err_error.
  */
 static INLINE void*
-SI_map(FSFileHandle *self, i64_t offset, i64_t len);
+SI_map(FSFileHandle *self, int64_t offset, int64_t len);
 
 /* Release a memory mapped region assigned by SI_map. 
  */
 static INLINE bool_t
-SI_unmap(FSFileHandle *self, char *ptr, i64_t len);
+SI_unmap(FSFileHandle *self, char *ptr, int64_t len);
 
 /* 32-bit or 64-bit inlined helpers for FSFH_window. */
 static INLINE bool_t
-SI_window(FSFileHandle *self, FileWindow *window, i64_t offset, i64_t len);
+SI_window(FSFileHandle *self, FileWindow *window, int64_t offset, int64_t len);
 
 /* Architecture- and OS- specific initialization for a read-only FSFileHandle.
  */
@@ -71,14 +71,14 @@ SI_close_win_handles(FSFileHandle *self)
 #endif
 
 FSFileHandle*
-FSFH_open(const CharBuf *path, u32_t flags) 
+FSFH_open(const CharBuf *path, uint32_t flags) 
 {
     FSFileHandle *self = (FSFileHandle*)VTable_Make_Obj(FSFILEHANDLE);
     return FSFH_do_open(self, path, flags);
 }
 
 FSFileHandle*
-FSFH_do_open(FSFileHandle *self, const CharBuf *path, u32_t flags) 
+FSFH_do_open(FSFileHandle *self, const CharBuf *path, uint32_t flags) 
 {
     FH_do_open((FileHandle*)self, path, flags);
     if (!path || !CB_Get_Size(path)) {
@@ -110,7 +110,7 @@ FSFH_do_open(FSFileHandle *self, const C
                 return NULL;
             }
             else {
-                i64_t check_val = lseek64(self->fd, I64_C(0), SEEK_SET);
+                int64_t check_val = lseek64(self->fd, I64_C(0), SEEK_SET);
                 if (check_val == -1) {
                     Err_set_error(Err_new(CB_newf("lseek64 on %o failed: %s", 
                         self->path, strerror(errno))));
@@ -181,18 +181,18 @@ FSFH_write(FSFileHandle *self, const voi
 {
     if (len) { 
         /* Write data, track file length, check for errors. */
-        i64_t check_val = write(self->fd, data, len);
+        int64_t check_val = write(self->fd, data, len);
         self->len += check_val;
         if (check_val != len) {
             if (check_val == -1) {
                 Err_set_error(Err_new(CB_newf(
                     "Error when writing %u64 bytes: %s",
-                    (u64_t)len, strerror(errno))));
+                    (uint64_t)len, strerror(errno))));
             }
             else {
                 Err_set_error(Err_new(CB_newf(
                     "Attempted to write %u64 bytes, but wrote %i64", 
-                    (u64_t)len, check_val)));
+                    (uint64_t)len, check_val)));
             }
             return false;
         }
@@ -201,16 +201,16 @@ FSFH_write(FSFileHandle *self, const voi
     return true;
 }
 
-i64_t
+int64_t
 FSFH_length(FSFileHandle *self)
 {
     return self->len;
 }
 
 bool_t
-FSFH_window(FSFileHandle *self, FileWindow *window, i64_t offset, i64_t len)
+FSFH_window(FSFileHandle *self, FileWindow *window, int64_t offset, int64_t len)
 {
-    const i64_t end = offset + len;
+    const int64_t end = offset + len;
     if (!(self->flags & FH_READ_ONLY)) {
         Err_set_error(Err_new(CB_newf("Can't read from write-only handle")));
         return false;
@@ -236,7 +236,7 @@ FSFH_window(FSFileHandle *self, FileWind
 #if IS_64_BIT
 
 static INLINE bool_t
-SI_window(FSFileHandle *self, FileWindow *window, i64_t offset, i64_t len)
+SI_window(FSFileHandle *self, FileWindow *window, int64_t offset, int64_t len)
 {
 	FileWindow_Set_Window(window, self->buf + offset, offset, len);
 	return true;
@@ -251,9 +251,9 @@ FSFH_release_window(FSFileHandle *self, 
 }
 
 bool_t
-FSFH_read(FSFileHandle *self, char *dest, i64_t offset, size_t len)
+FSFH_read(FSFileHandle *self, char *dest, int64_t offset, size_t len)
 {
-    const i64_t end = offset + len;
+    const int64_t end = offset + len;
 
     if (self->flags & FH_WRITE_ONLY) {
         Err_set_error(Err_new(CB_newf(
@@ -268,7 +268,7 @@ FSFH_read(FSFileHandle *self, char *dest
     else if (end > self->len) {
         Err_set_error(Err_new(CB_newf(
             "Tried to read past EOF: offset %i64 + request %u64 > len %i64", 
-            offset, (u64_t)len, self->len)));
+            offset, (uint64_t)len, self->len)));
         return false;
     }
     memcpy(dest, self->buf + offset, len);
@@ -280,7 +280,7 @@ FSFH_read(FSFileHandle *self, char *dest
 #else
 
 static INLINE bool_t
-SI_window(FSFileHandle *self, FileWindow *window, i64_t offset, i64_t len)
+SI_window(FSFileHandle *self, FileWindow *window, int64_t offset, int64_t len)
 {
 	/* Release the previously mmap'd region, if any. */
 	FSFH_release_window(self, window);
@@ -289,9 +289,9 @@ SI_window(FSFileHandle *self, FileWindow
 		/* Start map on a page boundary.  Ensure that the window is at
 		 * least wide enough to view all the data spec'd in the original
 		 * request. */
-		const i64_t remainder       = offset % self->page_size;
-		const i64_t adjusted_offset = offset - remainder;
-		const i64_t adjusted_len    = len + remainder;
+		const int64_t remainder       = offset % self->page_size;
+		const int64_t adjusted_offset = offset - remainder;
+		const int64_t adjusted_len    = len + remainder;
 		char *const buf 
 			= (char*)SI_map(self, adjusted_offset, adjusted_len);
 		if (len && buf == NULL) {
@@ -341,7 +341,7 @@ SI_init_read_only(FSFileHandle *self)
         return false;
     }
     else {
-        i64_t check_val = lseek64(self->fd, I64_C(0), SEEK_SET);
+        int64_t check_val = lseek64(self->fd, I64_C(0), SEEK_SET);
         if (check_val == -1) {
             Err_set_error(Err_new(CB_newf("lseek64 on %o failed: %s",
                 self->path, strerror(errno))));
@@ -362,7 +362,7 @@ SI_init_read_only(FSFileHandle *self)
 }
 
 static INLINE void*
-SI_map(FSFileHandle *self, i64_t offset, i64_t len)
+SI_map(FSFileHandle *self, int64_t offset, int64_t len)
 {
     void *buf = NULL;
 
@@ -382,7 +382,7 @@ SI_map(FSFileHandle *self, i64_t offset,
 }
 
 static INLINE bool_t
-SI_unmap(FSFileHandle *self, char *buf, i64_t len)
+SI_unmap(FSFileHandle *self, char *buf, int64_t len)
 {
     if (buf != NULL) {
         if (munmap(buf, len)) {
@@ -396,9 +396,9 @@ SI_unmap(FSFileHandle *self, char *buf, 
 
 #if !IS_64_BIT
 bool_t
-FSFH_read(FSFileHandle *self, char *dest, i64_t offset, size_t len)
+FSFH_read(FSFileHandle *self, char *dest, int64_t offset, size_t len)
 {
-    i64_t check_val;
+    int64_t check_val;
     
     /* Sanity check. */
     if (offset < 0) {
@@ -409,16 +409,16 @@ FSFH_read(FSFileHandle *self, char *dest
 
     /* Read. */
     check_val = pread64(self->fd, dest, len, offset);
-    if (check_val != (i64_t)len) {
+    if (check_val != (int64_t)len) {
         if (check_val == -1) {
             Err_set_error(Err_new(CB_newf(
                 "Tried to read %u64 bytes, got %i64: %s",
-                (u64_t)len, check_val, strerror(errno))));
+                (uint64_t)len, check_val, strerror(errno))));
         }
         else {
             Err_set_error(Err_new(CB_newf(
                 "Tried to read %u64 bytes, got %i64", 
-                (u64_t)len, check_val)));
+                (uint64_t)len, check_val)));
         }
         return false;
     }
@@ -489,13 +489,13 @@ SI_init_read_only(FSFileHandle *self)
 }
 
 static INLINE void*
-SI_map(FSFileHandle *self, i64_t offset, i64_t len)
+SI_map(FSFileHandle *self, int64_t offset, int64_t len)
 {
     void *buf = NULL;
 
     if (len) {
         /* Read-only memory map. */
-        u64_t offs = (u64_t)offset;
+        uint64_t offs = (uint64_t)offset;
         DWORD file_offset_hi = offs >> 32;
         DWORD file_offset_lo = offs & 0xFFFFFFFF;
         size_t amount = (size_t)len;
@@ -519,7 +519,7 @@ SI_map(FSFileHandle *self, i64_t offset,
 }
 
 static INLINE bool_t
-SI_unmap(FSFileHandle *self, char *buf, i64_t len)
+SI_unmap(FSFileHandle *self, char *buf, int64_t len)
 {
     if (buf != NULL) {
         if (!UnmapViewOfFile(buf)) {
@@ -563,12 +563,12 @@ SI_close_win_handles(FSFileHandle *self)
 
 #if !IS_64_BIT
 bool_t
-FSFH_read(FSFileHandle *self, char *dest, i64_t offset, size_t len)
+FSFH_read(FSFileHandle *self, char *dest, int64_t offset, size_t len)
 {
     BOOL check_val;
     DWORD got;
     OVERLAPPED read_op_state;
-    u64_t offs = (u64_t)offset;
+    uint64_t offs = (uint64_t)offset;
 
     read_op_state.hEvent     = NULL;
     read_op_state.OffsetHigh = offs >> 32;
@@ -585,7 +585,7 @@ FSFH_read(FSFileHandle *self, char *dest
      * argument, so throw a sensible error rather than wrap around. */
     if (len > U32_MAX) {
         Err_set_error(Err_new(CB_newf(
-            "Can't read more than 4 GB (%u64)", (u64_t)len))); 
+            "Can't read more than 4 GB (%u64)", (uint64_t)len))); 
         return false;
     }
 
@@ -603,7 +603,7 @@ FSFH_read(FSFileHandle *self, char *dest
     if (!check_val) {
         char *win_error = Err_win_error();
         Err_set_error(Err_new(CB_newf("Failed to read %u64 bytes: %s",
-            (u64_t)len, win_error)));
+            (uint64_t)len, win_error)));
         FREEMEM(win_error);
         return false;
     }

Modified: lucene/lucy/trunk/core/Lucy/Store/FSFolder.bp
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/FSFolder.bp?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/FSFolder.bp (original)
+++ lucene/lucy/trunk/core/Lucy/Store/FSFolder.bp Fri Apr  2 23:36:47 2010
@@ -36,7 +36,7 @@ class Lucy::Store::FSFolder extends Lucy
 
     incremented nullable FileHandle*
     Local_Open_FileHandle(FSFolder *self, const CharBuf *name, 
-                          u32_t flags);
+                          uint32_t flags);
 
     incremented nullable DirHandle*
     Local_Open_Dir(FSFolder *self);

Modified: lucene/lucy/trunk/core/Lucy/Store/FSFolder.c
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/FSFolder.c?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/FSFolder.c (original)
+++ lucene/lucy/trunk/core/Lucy/Store/FSFolder.c Fri Apr  2 23:36:47 2010
@@ -90,7 +90,7 @@ FSFolder_check(FSFolder *self)
 }
 
 FileHandle*
-FSFolder_local_open_filehandle(FSFolder *self, const CharBuf *name, u32_t flags)
+FSFolder_local_open_filehandle(FSFolder *self, const CharBuf *name, uint32_t flags)
 {
     CharBuf      *fullpath = FULLPATH(self, name);
     FSFileHandle *fh = FSFH_open(fullpath, flags);
@@ -305,7 +305,7 @@ bool_t
 S_is_local_entry(const CharBuf *path)
 {
     ZombieCharBuf *scratch = ZCB_WRAP(path);
-    u32_t code_point;
+    uint32_t code_point;
     while (0 != (code_point = ZCB_Nip_One(scratch))) {
         if (code_point == '/') { return false; }
     }

Modified: lucene/lucy/trunk/core/Lucy/Store/FileHandle.bp
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/FileHandle.bp?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/FileHandle.bp (original)
+++ lucene/lucy/trunk/core/Lucy/Store/FileHandle.bp Fri Apr  2 23:36:47 2010
@@ -20,7 +20,7 @@ abstract class Lucy::Store::FileHandle c
     extends Lucy::Object::Obj {
 
     CharBuf *path;
-    u32_t    flags;
+    uint32_t flags;
 
     /** Abstract constructor.
      *
@@ -29,7 +29,7 @@ abstract class Lucy::Store::FileHandle c
      * behaviors.
      */
     inert nullable FileHandle*
-    do_open(FileHandle *self, const CharBuf *path = NULL, u32_t flags);
+    do_open(FileHandle *self, const CharBuf *path = NULL, uint32_t flags);
 
     /** Ensure that the FileWindow's buffer provides access to file data for
      * <code>len</code> bytes starting at <code>offset</code>. 
@@ -40,7 +40,7 @@ abstract class Lucy::Store::FileHandle c
      * @return true on success, false on failure (sets Err_error)
      */
     abstract bool_t
-    Window(FileHandle *self, FileWindow *window, i64_t offset, i64_t len);
+    Window(FileHandle *self, FileWindow *window, int64_t offset, int64_t len);
 
     /** Clean up the FileWindow, doing whatever is necessary to free its
      * buffer and reset its internal variables.
@@ -58,7 +58,7 @@ abstract class Lucy::Store::FileHandle c
      * @return true on success, false on failure (sets Err_error)
      */
     abstract bool_t
-    Read(FileHandle *self, char *dest, i64_t offset, size_t len);
+    Read(FileHandle *self, char *dest, int64_t offset, size_t len);
 
     /** Write supplied content.
      *
@@ -72,7 +72,7 @@ abstract class Lucy::Store::FileHandle c
     /** Return the current length of the file in bytes, or set Err_error and
      * return -1 on failure.
      */
-    abstract i64_t 
+    abstract int64_t 
     Length(FileHandle *self);
 
     /** Advisory call alerting the FileHandle that it should prepare to occupy
@@ -81,7 +81,7 @@ abstract class Lucy::Store::FileHandle c
      * @return true on success, false on failure (sets Err_error).
      */
     bool_t
-    Grow(FileHandle *self, i64_t len);
+    Grow(FileHandle *self, int64_t len);
 
     /** Close the FileHandle, possibly releasing resources.  Implementations
      * should be be able to handle multiple invocations, returning success
@@ -120,7 +120,7 @@ __C__
  * they're the canary in the coal mine for detecting object-destruction memory
  * leaks.
  */
-extern chy_i32_t lucy_FH_object_count; 
+extern int32_t lucy_FH_object_count; 
 
 /* Default size for the memory buffer used by both InStream and OutStream.
  */

Modified: lucene/lucy/trunk/core/Lucy/Store/FileHandle.c
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/FileHandle.c?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/FileHandle.c (original)
+++ lucene/lucy/trunk/core/Lucy/Store/FileHandle.c Fri Apr  2 23:36:47 2010
@@ -5,10 +5,10 @@
 
 #include "Lucy/Store/FileHandle.h"
 
-i32_t FH_object_count = 0;
+int32_t FH_object_count = 0;
 
 FileHandle*
-FH_do_open(FileHandle *self, const CharBuf *path, u32_t flags)
+FH_do_open(FileHandle *self, const CharBuf *path, uint32_t flags)
 {
     self->path    = path ? CB_Clone(path) : CB_new(0);
     self->flags   = flags;
@@ -32,7 +32,7 @@ FH_destroy(FileHandle *self)
 }
 
 bool_t
-FH_grow(FileHandle *self, i64_t length)
+FH_grow(FileHandle *self, int64_t length)
 {
     UNUSED_VAR(self);
     UNUSED_VAR(length);

Modified: lucene/lucy/trunk/core/Lucy/Store/FileWindow.bp
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/FileWindow.bp?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/FileWindow.bp (original)
+++ lucene/lucy/trunk/core/Lucy/Store/FileWindow.bp Fri Apr  2 23:36:47 2010
@@ -5,8 +5,8 @@ parcel Lucy;
 class Lucy::Store::FileWindow extends Lucy::Object::Obj {
 
     char    *buf;
-    i64_t    offset;
-    i64_t    len;
+    int64_t  offset;
+    int64_t  len;
 
     inert FileWindow*
     init(FileWindow *self);
@@ -15,10 +15,10 @@ class Lucy::Store::FileWindow extends Lu
     new();
 
     void
-    Set_Offset(FileWindow *self, i64_t offset);
+    Set_Offset(FileWindow *self, int64_t offset);
 
     void
-    Set_Window(FileWindow *self, char *buf, i64_t offset, i64_t len);
+    Set_Window(FileWindow *self, char *buf, int64_t offset, int64_t len);
 }
 
 /* Copyright 2009 The Apache Software Foundation

Modified: lucene/lucy/trunk/core/Lucy/Store/FileWindow.c
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/FileWindow.c?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/FileWindow.c (original)
+++ lucene/lucy/trunk/core/Lucy/Store/FileWindow.c Fri Apr  2 23:36:47 2010
@@ -17,7 +17,7 @@ FileWindow_init(FileWindow *self)
 }
 
 void
-FileWindow_set_offset(FileWindow *self, i64_t offset)
+FileWindow_set_offset(FileWindow *self, int64_t offset)
 {
     if (self->buf != NULL) {
         if (offset != self->offset) {
@@ -29,7 +29,7 @@ FileWindow_set_offset(FileWindow *self, 
 }
 
 void
-FileWindow_set_window(FileWindow *self, char *buf, i64_t offset, i64_t len)
+FileWindow_set_window(FileWindow *self, char *buf, int64_t offset, int64_t len)
 {
     self->buf    = buf;
     self->offset = offset;

Modified: lucene/lucy/trunk/core/Lucy/Store/Folder.bp
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/Folder.bp?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/Folder.bp (original)
+++ lucene/lucy/trunk/core/Lucy/Store/Folder.bp Fri Apr  2 23:36:47 2010
@@ -54,7 +54,7 @@ abstract class Lucy::Store::Folder exten
      * @return a FileHandle.
      */
     public incremented nullable FileHandle*
-    Open_FileHandle(Folder *self, const CharBuf *path, u32_t flags);
+    Open_FileHandle(Folder *self, const CharBuf *path, uint32_t flags);
 
     /** Open a DirHandle or set Err_error and return NULL on failure.
      *
@@ -198,7 +198,7 @@ abstract class Lucy::Store::Folder exten
      * on failure.
      */
     abstract incremented nullable FileHandle*
-    Local_Open_FileHandle(Folder *self, const CharBuf *name, u32_t flags);
+    Local_Open_FileHandle(Folder *self, const CharBuf *name, uint32_t flags);
 
     /** Open an InStream for a local file, or set Err_error and return NULL on
      * failure. 

Modified: lucene/lucy/trunk/core/Lucy/Store/Folder.c
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/Folder.c?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/Folder.c (original)
+++ lucene/lucy/trunk/core/Lucy/Store/Folder.c Fri Apr  2 23:36:47 2010
@@ -90,7 +90,7 @@ Folder_local_open_in(Folder *self, const
 OutStream*
 Folder_open_out(Folder *self, const CharBuf *path)
 {
-    const u32_t flags = FH_WRITE_ONLY | FH_CREATE | FH_EXCLUSIVE;
+    const uint32_t flags = FH_WRITE_ONLY | FH_CREATE | FH_EXCLUSIVE;
     FileHandle *fh = Folder_Open_FileHandle(self, path, flags);
     OutStream *outstream = NULL;
     if (fh) { 
@@ -107,7 +107,7 @@ Folder_open_out(Folder *self, const Char
 }
 
 FileHandle*
-Folder_open_filehandle(Folder *self, const CharBuf *path, u32_t flags)
+Folder_open_filehandle(Folder *self, const CharBuf *path, uint32_t flags)
 {
     Folder *enclosing_folder = Folder_Enclosing_Folder(self, path);
     FileHandle *fh = NULL;
@@ -357,7 +357,7 @@ Folder_slurp_file(Folder *self, const Ch
         RETHROW(INCREF(Err_get_error())); 
     }
     else {
-        u64_t length = InStream_Length(instream);
+        uint64_t length = InStream_Length(instream);
 
         if (length >= SIZE_MAX) {
             InStream_Close(instream);
@@ -417,7 +417,7 @@ static Folder*
 S_enclosing_folder(Folder *self, ZombieCharBuf *path) 
 {
     size_t path_component_len = 0;
-    u32_t code_point;
+    uint32_t code_point;
 
     /* Strip trailing slash. */
     if (ZCB_Code_Point_From(path, 0) == '/') { ZCB_Chop(path, 1); }

Modified: lucene/lucy/trunk/core/Lucy/Store/InStream.bp
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/InStream.bp?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/InStream.bp (original)
+++ lucene/lucy/trunk/core/Lucy/Store/InStream.bp Fri Apr  2 23:36:47 2010
@@ -17,8 +17,8 @@ parcel Lucy;
  */
 class Lucy::Store::InStream extends Lucy::Object::Obj {
 
-    i64_t       offset;
-    i64_t       len;
+    int64_t     offset;
+    int64_t     len;
     char       *buf;          
     char       *limit;
     CharBuf    *filename; 
@@ -46,8 +46,8 @@ class Lucy::Store::InStream extends Lucy
      * @param len Length of the file as seen by the new InStream.
      */
     incremented InStream* 
-    Reopen(InStream *self, const CharBuf *filename = NULL, i64_t offset, 
-           i64_t len);
+    Reopen(InStream *self, const CharBuf *filename = NULL, int64_t offset, 
+           int64_t len);
 
     /** Clone the InStream.  Clones share the same underlying FileHandle and
      * start at the current file position, but are able to seek and read
@@ -68,16 +68,16 @@ class Lucy::Store::InStream extends Lucy
     /** Seek to <code>target</code>.
      */
     final void 
-    Seek(InStream *self, i64_t target);
+    Seek(InStream *self, int64_t target);
 
     /** Return the current file position.
      */
-    final i64_t 
+    final int64_t 
     Tell(InStream *self);
 
     /** Return the length of the "file" in bytes.
      */
-    final i64_t 
+    final int64_t 
     Length(InStream *self);
 
     /** Fill the InStream's buffer, letting the FileHandle decide how many bytes
@@ -89,7 +89,7 @@ class Lucy::Store::InStream extends Lucy
     /** Pour an exact number of bytes into the InStream's buffer.
      */
     void
-    Fill(InStream *self, i64_t amount);
+    Fill(InStream *self, int64_t amount);
 
     /** Get the InStream's buffer.  Check to see whether <code>request</code>
      * bytes are already in the buffer.  If not, fill the buffer with either
@@ -116,32 +116,32 @@ class Lucy::Store::InStream extends Lucy
 
     /** Read a signed 8-bit integer.
      */
-    final i8_t 
+    final int8_t 
     Read_I8(InStream *self);
 
     /** Read an unsigned 8-bit integer.
      */
-    final u8_t 
+    final uint8_t 
     Read_U8(InStream *self);
 
     /** Read a signed 32-bit integer.
      */
-    final i32_t 
+    final int32_t 
     Read_I32(InStream *self);
 
     /** Read an unsigned 32-bit integer.
      */
-    final u32_t 
+    final uint32_t 
     Read_U32(InStream *self);
 
     /** Read a signed 64-bit integer.
      */
-    final i64_t 
+    final int64_t 
     Read_I64(InStream *self);
 
     /** Read an unsigned 64-bit integer.
      */
-    final u64_t 
+    final uint64_t 
     Read_U64(InStream *self);
 
     /** Read an IEEE 764 32-bit floating point number.
@@ -156,13 +156,13 @@ class Lucy::Store::InStream extends Lucy
 
     /** Read in a compressed 32-bit unsigned integer.
      */
-    u32_t 
+    uint32_t 
     Read_C32(InStream *self);
 
     /** Read a 64-bit integer, using the same encoding as a C32 but occupying
      * as many as 10 bytes.
      */
-    final u64_t 
+    final uint64_t 
     Read_C64(InStream *self);
 
     /** Read the bytes for a C32/C64 into <code>buf</code>.  Return the number

Modified: lucene/lucy/trunk/core/Lucy/Store/InStream.c
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/InStream.c?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/InStream.c (original)
+++ lucene/lucy/trunk/core/Lucy/Store/InStream.c Fri Apr  2 23:36:47 2010
@@ -10,7 +10,7 @@
 #include "Lucy/Store/RAMFileHandle.h"
 
 /* Inlined version of InStream_Tell. */
-static INLINE i64_t
+static INLINE int64_t
 SI_tell(InStream *self);
 
 /* Inlined version of InStream_Read_Bytes. */
@@ -18,12 +18,12 @@ static INLINE void
 SI_read_bytes(InStream *self, char* buf, size_t len);
 
 /* Inlined version of InStream_Read_U8. */
-static INLINE u8_t
+static INLINE uint8_t
 SI_read_u8(InStream *self);
 
 /* Ensure that the buffer contains exactly the specified amount of data. */
 static void
-S_fill(InStream *self, i64_t amount);
+S_fill(InStream *self, int64_t amount);
 
 /* Refill the buffer, with either IO_STREAM_BUF_SIZE bytes or all remaining
  * file content -- whichever is smaller. Throw an error if we're at EOF and
@@ -107,8 +107,8 @@ InStream_destroy(InStream *self)
 }
 
 InStream*
-InStream_reopen(InStream *self, const CharBuf *filename, i64_t offset, 
-                i64_t len)
+InStream_reopen(InStream *self, const CharBuf *filename, int64_t offset, 
+                int64_t len)
 {
     if (!self->file_handle) { 
         THROW(ERR, "Can't Reopen() closed InStream %o", self->filename);
@@ -144,9 +144,9 @@ static int64_t 
 S_refill(InStream *self) 
 {
     /* Determine the amount to request. */
-    const i64_t sub_file_pos = SI_tell(self);
-    const i64_t remaining    = self->len - sub_file_pos;
-    const i64_t amount       = remaining < IO_STREAM_BUF_SIZE 
+    const int64_t sub_file_pos = SI_tell(self);
+    const int64_t remaining    = self->len - sub_file_pos;
+    const int64_t amount       = remaining < IO_STREAM_BUF_SIZE 
                              ? remaining 
                              : IO_STREAM_BUF_SIZE;
     if (!remaining) {
@@ -167,12 +167,12 @@ InStream_refill(InStream *self)
 }
 
 static void
-S_fill(InStream *self, i64_t amount) 
+S_fill(InStream *self, int64_t amount) 
 {
     FileWindow *const window     = self->window;
-    const i64_t virtual_file_pos = SI_tell(self);
-    const i64_t real_file_pos    = virtual_file_pos + self->offset;
-    const i64_t remaining        = self->len - virtual_file_pos;
+    const int64_t virtual_file_pos = SI_tell(self);
+    const int64_t real_file_pos    = virtual_file_pos + self->offset;
+    const int64_t remaining        = self->len - virtual_file_pos;
 
     /* Throw an error if the requested amount would take us beyond EOF. */
     if (amount > remaining) {
@@ -199,17 +199,17 @@ S_fill(InStream *self, i64_t amount) 
 }
 
 void
-InStream_fill(InStream *self, i64_t amount)
+InStream_fill(InStream *self, int64_t amount)
 {
     S_fill(self, amount);
 }
 
 void
-InStream_seek(InStream *self, i64_t target) 
+InStream_seek(InStream *self, int64_t target) 
 {
     FileWindow *const window = self->window;
-    i64_t virtual_window_top = window->offset - self->offset;
-    i64_t virtual_window_end = virtual_window_top + window->len;
+    int64_t virtual_window_top = window->offset - self->offset;
+    int64_t virtual_window_end = virtual_window_top + window->len;
 
     if (target < 0) {
         THROW(ERR, "Can't Seek '%o' to negative target %i64", self->filename,
@@ -236,21 +236,21 @@ InStream_seek(InStream *self, i64_t targ
     }
 }
 
-static INLINE i64_t
+static INLINE int64_t
 SI_tell(InStream *self)
 {
     FileWindow *const window = self->window;
-    i64_t pos_in_buf = PTR2I64(self->buf) - PTR2I64(window->buf);
+    int64_t pos_in_buf = PTR2I64(self->buf) - PTR2I64(window->buf);
     return pos_in_buf + window->offset - self->offset;
 }
 
-i64_t
+int64_t
 InStream_tell(InStream *self) 
 {
     return SI_tell(self);
 }
 
-i64_t
+int64_t
 InStream_length(InStream *self)
 {
     return self->len;
@@ -259,16 +259,16 @@ InStream_length(InStream *self)
 char*
 InStream_buf(InStream *self, size_t request)
 {
-    const i64_t bytes_in_buf = PTR2I64(self->limit) - PTR2I64(self->buf);
+    const int64_t bytes_in_buf = PTR2I64(self->limit) - PTR2I64(self->buf);
 
     /* It's common for client code to overestimate how much is needed, because
      * the request has to figure in worst-case for compressed data.  However,
      * if we can still serve them everything they request (e.g. they ask for 5
      * bytes, they really need 1 byte, and there's 1k in the buffer), we can
      * skip the following refill block. */
-    if ((i64_t)request > bytes_in_buf) {
-        const i64_t remaining_in_file = self->len - SI_tell(self);
-        i64_t amount = request;
+    if ((int64_t)request > bytes_in_buf) {
+        const int64_t remaining_in_file = self->len - SI_tell(self);
+        int64_t amount = request;
 
         /* Try to bump up small requests. */
         if (amount < IO_STREAM_BUF_SIZE) { amount = IO_STREAM_BUF_SIZE; }
@@ -290,12 +290,12 @@ void
 InStream_advance_buf(InStream *self, char *buf)
 {
     if (buf > self->limit) {
-        i64_t overrun = PTR2I64(buf) - PTR2I64(self->limit);
+        int64_t overrun = PTR2I64(buf) - PTR2I64(self->limit);
         THROW(ERR, "Supplied value is %i64 bytes beyond end of buffer",
             overrun);
     }
     else if (buf < self->buf) {
-        i64_t underrun = PTR2I64(self->buf) - PTR2I64(buf);
+        int64_t underrun = PTR2I64(self->buf) - PTR2I64(buf);
         THROW(ERR, "Can't Advance_Buf backwards: (underrun: %i64))", underrun);
     }
     else {
@@ -312,8 +312,8 @@ InStream_read_bytes(InStream *self, char
 static INLINE void
 SI_read_bytes(InStream *self, char* buf, size_t len) 
 {
-    const i64_t available = PTR2I64(self->limit) - PTR2I64(self->buf);
-    if (available >= (i64_t)len) {
+    const int64_t available = PTR2I64(self->limit) - PTR2I64(self->buf);
+    if (available >= (int64_t)len) {
         /* Request is entirely within buffer, so copy. */
         memcpy(buf, self->buf, len);
         self->buf += len;
@@ -343,8 +343,8 @@ SI_read_bytes(InStream *self, char* buf,
         else {
             /* Too big to handle via the buffer, so resort to a brute-force
              * read. */
-            const i64_t sub_file_pos  = SI_tell(self);
-            const i64_t real_file_pos = sub_file_pos + self->offset;
+            const int64_t sub_file_pos  = SI_tell(self);
+            const int64_t real_file_pos = sub_file_pos + self->offset;
             bool_t success 
                 = FH_Read(self->file_handle, buf, real_file_pos, len);
             if (!success) {
@@ -355,29 +355,29 @@ SI_read_bytes(InStream *self, char* buf,
     }
 }
 
-i8_t
+int8_t
 InStream_read_i8(InStream *self)
 {
-    return (i8_t)SI_read_u8(self);
+    return (int8_t)SI_read_u8(self);
 }
 
-static INLINE u8_t
+static INLINE uint8_t
 SI_read_u8(InStream *self)
 {
     if (self->buf >= self->limit) { S_refill(self); }
-    return (u8_t)*self->buf++;
+    return (uint8_t)*self->buf++;
 }
 
-u8_t
+uint8_t
 InStream_read_u8(InStream *self)
 {
     return SI_read_u8(self);
 }
 
-static INLINE u32_t
+static INLINE uint32_t
 SI_read_u32(InStream *self) 
 {
-    u32_t retval;
+    uint32_t retval;
     SI_read_bytes(self, (char*)&retval, 4);
 #ifdef LITTLE_END 
     retval = NumUtil_decode_bigend_u32((char*)&retval);
@@ -385,22 +385,22 @@ SI_read_u32(InStream *self) 
     return retval;
 }
 
-u32_t
+uint32_t
 InStream_read_u32(InStream *self)
 {
     return SI_read_u32(self);
 }
 
-i32_t
+int32_t
 InStream_read_i32(InStream *self)
 {
-    return (i32_t)SI_read_u32(self);
+    return (int32_t)SI_read_u32(self);
 }
 
-static INLINE u64_t
+static INLINE uint64_t
 SI_read_u64 (InStream *self) 
 {
-    u64_t retval;
+    uint64_t retval;
     SI_read_bytes(self, (char*)&retval, 8);
 #ifdef LITTLE_END 
     retval = NumUtil_decode_bigend_u64((char*)&retval);
@@ -408,22 +408,22 @@ SI_read_u64 (InStream *self) 
     return retval;
 }
 
-u64_t
+uint64_t
 InStream_read_u64(InStream *self)
 {
     return SI_read_u64(self);
 }
 
-i64_t
+int64_t
 InStream_read_i64(InStream *self)
 {
-    return (i64_t)SI_read_u64(self);
+    return (int64_t)SI_read_u64(self);
 }
 
 float
 InStream_read_f32(InStream *self)
 {
-    union { float f; u32_t u32; } duo;
+    union { float f; uint32_t u32; } duo;
     SI_read_bytes(self, (char*)&duo, sizeof(float));
 #ifdef LITTLE_END 
     duo.u32 = NumUtil_decode_bigend_u32(&duo.u32);
@@ -434,7 +434,7 @@ InStream_read_f32(InStream *self)
 double
 InStream_read_f64(InStream *self)
 {
-    union { double d; u64_t u64; } duo;
+    union { double d; uint64_t u64; } duo;
     SI_read_bytes(self, (char*)&duo, sizeof(double));
 #ifdef LITTLE_END 
     duo.u64 = NumUtil_decode_bigend_u64(&duo.u64);
@@ -442,12 +442,12 @@ InStream_read_f64(InStream *self)
     return duo.d;
 }
 
-u32_t 
+uint32_t 
 InStream_read_c32(InStream *self) 
 {
-    u32_t retval = 0;
+    uint32_t retval = 0;
     while (1) {
-        const u8_t ubyte = SI_read_u8(self);
+        const uint8_t ubyte = SI_read_u8(self);
         retval = (retval << 7) | (ubyte & 0x7f);
         if ((ubyte & 0x80) == 0)
             break;
@@ -455,12 +455,12 @@ InStream_read_c32(InStream *self) 
     return retval;
 }
 
-u64_t 
+uint64_t 
 InStream_read_c64(InStream *self) 
 {
-    u64_t retval = 0;
+    uint64_t retval = 0;
     while (1) {
-        const u8_t ubyte = SI_read_u8(self);
+        const uint8_t ubyte = SI_read_u8(self);
         retval = (retval << 7) | (ubyte & 0x7f);
         if ((ubyte & 0x80) == 0)
             break;
@@ -471,11 +471,11 @@ InStream_read_c64(InStream *self) 
 int
 InStream_read_raw_c64(InStream *self, char *buf) 
 {
-    u8_t *dest = (u8_t*)buf;
+    uint8_t *dest = (uint8_t*)buf;
     do {
         *dest = SI_read_u8(self);
     } while ((*dest++ & 0x80) != 0);
-    return dest - (u8_t*)buf;
+    return dest - (uint8_t*)buf;
 }
 
 /* Copyright 2009 The Apache Software Foundation

Modified: lucene/lucy/trunk/core/Lucy/Store/OutStream.bp
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/OutStream.bp?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/OutStream.bp (original)
+++ lucene/lucy/trunk/core/Lucy/Store/OutStream.bp Fri Apr  2 23:36:47 2010
@@ -14,7 +14,7 @@ parcel Lucy;
 class Lucy::Store::OutStream extends Lucy::Object::Obj {
 
     char          *buf;
-    i64_t          buf_start;
+    int64_t        buf_start;
     size_t         buf_pos;
     FileHandle    *file_handle;
     CharBuf       *path;
@@ -34,7 +34,7 @@ class Lucy::Store::OutStream extends Luc
 
     /** Return the current file position. 
      */
-    final i64_t 
+    final int64_t 
     Tell(OutStream *self);
 
     /** Write 0 or more null bytes to the OutStream until its file position is
@@ -52,14 +52,14 @@ class Lucy::Store::OutStream extends Luc
 
     /** Return the current length of the file in bytes.
      */
-    final i64_t 
+    final int64_t 
     Length(OutStream *self);
 
     /** Advisory call informing the OutStream that it should prepare to occupy
      * <code>length</code> bytes.
      */
     void
-    Grow(OutStream *self, i64_t length);
+    Grow(OutStream *self, int64_t length);
 
     /** Write <code>len</code> bytes from <code>buf</code> to the OutStream.
      */
@@ -69,42 +69,42 @@ class Lucy::Store::OutStream extends Luc
     /** Write a signed 8-bit integer. 
      */
     final void
-    Write_I8(OutStream *self, i8_t value);
+    Write_I8(OutStream *self, int8_t value);
 
     /** Write an unsigned 8-bit integer. 
      */
     final void
-    Write_U8(OutStream *self, u8_t value);
+    Write_U8(OutStream *self, uint8_t value);
 
     /** Write a signed 32-bit integer.
      */
     final void
-    Write_I32(OutStream *self, i32_t value);
+    Write_I32(OutStream *self, int32_t value);
 
     /** Write an unsigned 32-bit integer.
      */
     final void
-    Write_U32(OutStream *self, u32_t value);
+    Write_U32(OutStream *self, uint32_t value);
 
     /** Write a signed 64-bit integer.
      */
     final void
-    Write_I64(OutStream *self, i64_t value);
+    Write_I64(OutStream *self, int64_t value);
 
     /** Write an unsigned 64-bit integer.
      */
     final void
-    Write_U64(OutStream *self, u64_t value);
+    Write_U64(OutStream *self, uint64_t value);
 
     /** Write a 32-bit integer using a compressed format.
      */
     final void
-    Write_C32(OutStream *self, u32_t value);
+    Write_C32(OutStream *self, uint32_t value);
 
     /** Write a 64-bit integer using a compressed format.
      */
     final void
-    Write_C64(OutStream *self, u64_t value);
+    Write_C64(OutStream *self, uint64_t value);
 
     /** Write an IEEE 764 32-bit floating point number in big-endian byte
      * order.

Modified: lucene/lucy/trunk/core/Lucy/Store/OutStream.c
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/OutStream.c?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/OutStream.c (original)
+++ lucene/lucy/trunk/core/Lucy/Store/OutStream.c Fri Apr  2 23:36:47 2010
@@ -15,7 +15,7 @@ SI_write_bytes(OutStream *self, const vo
 
 /* Inlined version of OutStream_Write_C32. */
 static INLINE void
-SI_write_c32(OutStream *self, u32_t value);
+SI_write_c32(OutStream *self, uint32_t value);
 
 /* Flush content in the buffer to the FileHandle. */
 static void
@@ -88,7 +88,7 @@ void 
 OutStream_absorb(OutStream *self, InStream *instream) 
 {
     char buf[IO_STREAM_BUF_SIZE];
-    i64_t  bytes_left = InStream_Length(instream);
+    int64_t  bytes_left = InStream_Length(instream);
 
     /* Read blocks of content into an intermediate buffer, than write them to
      * the OutStream. 
@@ -108,14 +108,14 @@ OutStream_absorb(OutStream *self, InStre
 }
 
 void
-OutStream_grow(OutStream *self, i64_t length)
+OutStream_grow(OutStream *self, int64_t length)
 {
     if (!FH_Grow(self->file_handle, length)) {
         RETHROW(INCREF(Err_get_error()));
     }
 }
 
-i64_t
+int64_t
 OutStream_tell(OutStream *self) 
 {
     return self->buf_start + self->buf_pos;
@@ -149,7 +149,7 @@ S_flush(OutStream *self)
     self->buf_pos = 0;
 }
 
-i64_t
+int64_t
 OutStream_length(OutStream *self) 
 {
     return OutStream_tell(self);
@@ -186,7 +186,7 @@ SI_write_bytes(OutStream *self, const vo
 }
 
 static INLINE void
-SI_write_u8(OutStream *self, u8_t value)
+SI_write_u8(OutStream *self, uint8_t value)
 {
     if (self->buf_pos >= IO_STREAM_BUF_SIZE) {
         S_flush(self);
@@ -195,19 +195,19 @@ SI_write_u8(OutStream *self, u8_t value)
 }
 
 void
-OutStream_write_i8(OutStream *self, i8_t value) 
+OutStream_write_i8(OutStream *self, int8_t value) 
 {
-    SI_write_u8(self, (u8_t)value);
+    SI_write_u8(self, (uint8_t)value);
 }
 
 void
-OutStream_write_u8(OutStream *self, u8_t value) 
+OutStream_write_u8(OutStream *self, uint8_t value) 
 {
     SI_write_u8(self, value);
 }
 
 static INLINE void 
-SI_write_u32(OutStream *self, u32_t value) 
+SI_write_u32(OutStream *self, uint32_t value) 
 {
 #ifdef BIG_END
     SI_write_bytes(self, &value, 4);
@@ -220,38 +220,38 @@ SI_write_u32(OutStream *self, u32_t valu
 }
 
 void 
-OutStream_write_i32(OutStream *self, i32_t value) 
+OutStream_write_i32(OutStream *self, int32_t value) 
 {
-    SI_write_u32(self, (u32_t)value);
+    SI_write_u32(self, (uint32_t)value);
 }
 
 void 
-OutStream_write_u32(OutStream *self, u32_t value) 
+OutStream_write_u32(OutStream *self, uint32_t value) 
 {
     SI_write_u32(self, value);
 }
 
 static INLINE void
-SI_write_u64(OutStream *self, u64_t value) 
+SI_write_u64(OutStream *self, uint64_t value) 
 {
 #ifdef BIG_END
     SI_write_bytes(self, &value, 8);
 #else 
-    char  buf[sizeof(u64_t)];
+    char  buf[sizeof(uint64_t)];
     char *buf_copy = buf;
     NumUtil_encode_bigend_u64(value, &buf_copy);
-    SI_write_bytes(self, buf, sizeof(u64_t));
+    SI_write_bytes(self, buf, sizeof(uint64_t));
 #endif
 }
 
 void 
-OutStream_write_i64(OutStream *self, i64_t value) 
+OutStream_write_i64(OutStream *self, int64_t value) 
 {
-    SI_write_u64(self, (u64_t)value);
+    SI_write_u64(self, (uint64_t)value);
 }
 
 void 
-OutStream_write_u64(OutStream *self, u64_t value) 
+OutStream_write_u64(OutStream *self, uint64_t value) 
 {
     SI_write_u64(self, value);
 }
@@ -275,16 +275,16 @@ OutStream_write_f64(OutStream *self, dou
 }
 
 void
-OutStream_write_c32(OutStream *self, u32_t value) 
+OutStream_write_c32(OutStream *self, uint32_t value) 
 {
     SI_write_c32(self, value);
 }
 
 static INLINE void
-SI_write_c32(OutStream *self, u32_t value) 
+SI_write_c32(OutStream *self, uint32_t value) 
 {
-    u8_t buf[C32_MAX_BYTES];
-    u8_t *ptr = buf + sizeof(buf) - 1;
+    uint8_t buf[C32_MAX_BYTES];
+    uint8_t *ptr = buf + sizeof(buf) - 1;
 
     /* Write last byte first, which has no continue bit. */
     *ptr = value & 0x7f;
@@ -300,10 +300,10 @@ SI_write_c32(OutStream *self, u32_t valu
 }
 
 void
-OutStream_write_c64(OutStream *self, u64_t value) 
+OutStream_write_c64(OutStream *self, uint64_t value) 
 {
-    u8_t buf[C64_MAX_BYTES];
-    u8_t *ptr = buf + sizeof(buf) - 1;
+    uint8_t buf[C64_MAX_BYTES];
+    uint8_t *ptr = buf + sizeof(buf) - 1;
 
     /* Write last byte first, which has no continue bit. */
     *ptr = value & 0x7f;
@@ -321,7 +321,7 @@ OutStream_write_c64(OutStream *self, u64
 void
 OutStream_write_string(OutStream *self, const char *string, size_t len) 
 {
-    SI_write_c32(self, (u32_t)len);
+    SI_write_c32(self, (uint32_t)len);
     SI_write_bytes(self, string, len);
 }
 

Modified: lucene/lucy/trunk/core/Lucy/Store/RAMDirHandle.bp
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/RAMDirHandle.bp?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/RAMDirHandle.bp (original)
+++ lucene/lucy/trunk/core/Lucy/Store/RAMDirHandle.bp Fri Apr  2 23:36:47 2010
@@ -7,7 +7,7 @@ class Lucy::Store::RAMDirHandle cnick RA
 
     RAMFolder *folder;
     VArray    *elems;
-    i32_t      tick;
+    int32_t    tick;
 
     inert incremented RAMDirHandle*
     new(RAMFolder *folder);

Modified: lucene/lucy/trunk/core/Lucy/Store/RAMDirHandle.c
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/RAMDirHandle.c?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/RAMDirHandle.c (original)
+++ lucene/lucy/trunk/core/Lucy/Store/RAMDirHandle.c Fri Apr  2 23:36:47 2010
@@ -42,7 +42,7 @@ RAMDH_next(RAMDirHandle *self)
 {
     if (self->elems) {
         self->tick++;
-        if (self->tick < (i32_t)VA_Get_Size(self->elems)) {
+        if (self->tick < (int32_t)VA_Get_Size(self->elems)) {
             CharBuf *path = (CharBuf*)CERTIFY(
                 VA_Fetch(self->elems, self->tick), CHARBUF);
             CB_Mimic(self->entry, (Obj*)path);

Modified: lucene/lucy/trunk/core/Lucy/Store/RAMFileHandle.bp
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/RAMFileHandle.bp?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/RAMFileHandle.bp (original)
+++ lucene/lucy/trunk/core/Lucy/Store/RAMFileHandle.bp Fri Apr  2 23:36:47 2010
@@ -9,10 +9,10 @@ class Lucy::Store::RAMFileHandle cnick R
     extends Lucy::Store::FileHandle {
 
     RAMFile *ram_file;
-    i64_t    len;
+    int64_t  len;
 
     inert incremented nullable RAMFileHandle*
-    open(const CharBuf *path = NULL, u32_t flags, RAMFile *file = NULL);
+    open(const CharBuf *path = NULL, uint32_t flags, RAMFile *file = NULL);
 
     /** 
      * Return a new RAMFileHandle, or set Err_error and return NULL on
@@ -24,7 +24,7 @@ class Lucy::Store::RAMFileHandle cnick R
      * must be passed or an error will occur.
      */
     inert nullable RAMFileHandle*
-    do_open(RAMFileHandle *self, const CharBuf *path = NULL, u32_t flags,
+    do_open(RAMFileHandle *self, const CharBuf *path = NULL, uint32_t flags,
             RAMFile *file = NULL);
 
     /** Access the backing RAMFile. 
@@ -33,24 +33,24 @@ class Lucy::Store::RAMFileHandle cnick R
     Get_File(RAMFileHandle *self);
 
     bool_t 
-    Grow(RAMFileHandle *self, i64_t len);
+    Grow(RAMFileHandle *self, int64_t len);
 
     public void
     Destroy(RAMFileHandle *self);
 
     bool_t
-    Window(RAMFileHandle *self, FileWindow *window, i64_t offset, i64_t len);
+    Window(RAMFileHandle *self, FileWindow *window, int64_t offset, int64_t len);
 
     bool_t 
     Release_Window(RAMFileHandle *self, FileWindow *window);
 
     bool_t
-    Read(RAMFileHandle *self, char *dest, i64_t offset, size_t len);
+    Read(RAMFileHandle *self, char *dest, int64_t offset, size_t len);
 
     bool_t
     Write(RAMFileHandle *self, const void *data, size_t len);
 
-    i64_t
+    int64_t
     Length(RAMFileHandle *self);
 
     bool_t

Modified: lucene/lucy/trunk/core/Lucy/Store/RAMFileHandle.c
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/RAMFileHandle.c?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/RAMFileHandle.c (original)
+++ lucene/lucy/trunk/core/Lucy/Store/RAMFileHandle.c Fri Apr  2 23:36:47 2010
@@ -8,14 +8,14 @@
 #include "Lucy/Store/FileWindow.h"
 
 RAMFileHandle*
-RAMFH_open(const CharBuf *path, u32_t flags, RAMFile *file) 
+RAMFH_open(const CharBuf *path, uint32_t flags, RAMFile *file) 
 {
     RAMFileHandle *self = (RAMFileHandle*)VTable_Make_Obj(RAMFILEHANDLE);
     return RAMFH_do_open(self, path, flags, file);
 }
 
 RAMFileHandle*
-RAMFH_do_open(RAMFileHandle *self, const CharBuf *path, u32_t flags, 
+RAMFH_do_open(RAMFileHandle *self, const CharBuf *path, uint32_t flags, 
               RAMFile *file) 
 {
     bool_t must_create = (flags & (FH_CREATE | FH_EXCLUSIVE))
@@ -65,9 +65,9 @@ RAMFH_destroy(RAMFileHandle *self) 
 }
 
 bool_t
-RAMFH_window(RAMFileHandle *self, FileWindow *window, i64_t offset, i64_t len)
+RAMFH_window(RAMFileHandle *self, FileWindow *window, int64_t offset, int64_t len)
 {
-    i64_t end = offset + len;
+    int64_t end = offset + len;
     if (!(self->flags & FH_READ_ONLY)) {
         Err_set_error(Err_new(CB_newf("Can't read from write-only handle")));
         return false;
@@ -99,9 +99,9 @@ RAMFH_release_window(RAMFileHandle *self
 }
 
 bool_t
-RAMFH_read(RAMFileHandle *self, char *dest, i64_t offset, size_t len)
+RAMFH_read(RAMFileHandle *self, char *dest, int64_t offset, size_t len)
 {
-    i64_t end = offset + len;
+    int64_t end = offset + len;
     if (!(self->flags & FH_READ_ONLY)) {
         Err_set_error(Err_new(CB_newf("Can't read from write-only handle")));
         return false;
@@ -114,7 +114,7 @@ RAMFH_read(RAMFileHandle *self, char *de
     else if (end > self->len) {
         Err_set_error(Err_new(CB_newf(
             "Attempt to read %u64 bytes starting at %i64 goes past EOF %u64",
-            (u64_t)len, offset, self->len)));
+            (uint64_t)len, offset, self->len)));
         return false;
     }
     else {
@@ -138,12 +138,12 @@ RAMFH_write(RAMFileHandle *self, const v
 }
 
 bool_t
-RAMFH_grow(RAMFileHandle *self, i64_t len)
+RAMFH_grow(RAMFileHandle *self, int64_t len)
 {
     if (len > I32_MAX) {
         Err_set_error(Err_new(CB_newf(
             "Can't support RAM files of size %i64 (> %i32)", len, 
-            (i32_t)I32_MAX)));
+            (int32_t)I32_MAX)));
         return false;
     }
     else if (self->ram_file->read_only) {
@@ -160,7 +160,7 @@ RAMFH_grow(RAMFileHandle *self, i64_t le
 RAMFile*
 RAMFH_get_file(RAMFileHandle *self) { return self->ram_file; }
 
-i64_t
+int64_t
 RAMFH_length(RAMFileHandle *self)
 {
     return self->len;

Modified: lucene/lucy/trunk/core/Lucy/Store/RAMFolder.bp
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/RAMFolder.bp?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/RAMFolder.bp (original)
+++ lucene/lucy/trunk/core/Lucy/Store/RAMFolder.bp Fri Apr  2 23:36:47 2010
@@ -27,7 +27,7 @@ class Lucy::Store::RAMFolder extends Luc
     Close(RAMFolder *self);
 
     incremented nullable FileHandle*
-    Local_Open_FileHandle(RAMFolder *self, const CharBuf *name, u32_t flags);
+    Local_Open_FileHandle(RAMFolder *self, const CharBuf *name, uint32_t flags);
 
     incremented nullable DirHandle*
     Local_Open_Dir(RAMFolder *self);

Modified: lucene/lucy/trunk/core/Lucy/Store/RAMFolder.c
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Store/RAMFolder.c?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Store/RAMFolder.c (original)
+++ lucene/lucy/trunk/core/Lucy/Store/RAMFolder.c Fri Apr  2 23:36:47 2010
@@ -60,7 +60,7 @@ RAMFolder_local_mkdir(RAMFolder *self, c
 
 FileHandle*
 RAMFolder_local_open_filehandle(RAMFolder *self, const CharBuf *name, 
-                                u32_t flags)
+                                uint32_t flags)
 {
     RAMFileHandle *fh;
     CharBuf *fullpath = S_fullpath(self, name);
@@ -251,7 +251,7 @@ S_rename_or_hard_link(RAMFolder *self, c
         }
     }
     else {
-        THROW(ERR, "Unexpected op: %i32", (i32_t)op);
+        THROW(ERR, "Unexpected op: %i32", (int32_t)op);
     }
 
     return true;

Modified: lucene/lucy/trunk/core/Lucy/Test/Store/MockFileHandle.bp
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Test/Store/MockFileHandle.bp?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Test/Store/MockFileHandle.bp (original)
+++ lucene/lucy/trunk/core/Lucy/Test/Store/MockFileHandle.bp Fri Apr  2 23:36:47 2010
@@ -4,21 +4,21 @@ parcel Lucy;
  */ 
 class Lucy::Store::MockFileHandle extends Lucy::Store::FileHandle {
 
-    i64_t len;
+    int64_t len;
 
     inert incremented MockFileHandle*
-    new(const CharBuf *path = NULL, i64_t length);
+    new(const CharBuf *path = NULL, int64_t length);
 
     inert MockFileHandle*
-    init(MockFileHandle *self, const CharBuf *path = NULL, i64_t length);
+    init(MockFileHandle *self, const CharBuf *path = NULL, int64_t length);
 
     bool_t
-    Window(MockFileHandle *self, FileWindow *window, i64_t offset, i64_t len);
+    Window(MockFileHandle *self, FileWindow *window, int64_t offset, int64_t len);
 
     bool_t 
     Release_Window(MockFileHandle *self, FileWindow *window);
 
-    i64_t
+    int64_t
     Length(MockFileHandle *self);
 
     bool_t

Modified: lucene/lucy/trunk/core/Lucy/Test/Store/MockFileHandle.c
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Test/Store/MockFileHandle.c?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Test/Store/MockFileHandle.c (original)
+++ lucene/lucy/trunk/core/Lucy/Test/Store/MockFileHandle.c Fri Apr  2 23:36:47 2010
@@ -6,14 +6,14 @@
 #include "Lucy/Store/FileWindow.h"
 
 MockFileHandle*
-MockFileHandle_new(const CharBuf *path, i64_t length) 
+MockFileHandle_new(const CharBuf *path, int64_t length) 
 {
     MockFileHandle *self = (MockFileHandle*)VTable_Make_Obj(MOCKFILEHANDLE);
     return MockFileHandle_init(self, path, length);
 }
 
 MockFileHandle*
-MockFileHandle_init(MockFileHandle *self, const CharBuf *path, i64_t length) 
+MockFileHandle_init(MockFileHandle *self, const CharBuf *path, int64_t length) 
 {
     FH_do_open((FileHandle*)self, path, 0);
     self->len = length;
@@ -21,8 +21,8 @@ MockFileHandle_init(MockFileHandle *self
 }
 
 bool_t
-MockFileHandle_window(MockFileHandle *self, FileWindow *window, i64_t offset, 
-                     i64_t len)
+MockFileHandle_window(MockFileHandle *self, FileWindow *window, int64_t offset, 
+                     int64_t len)
 {
     UNUSED_VAR(self);
     FileWindow_Set_Window(window, NULL, offset, len);
@@ -37,7 +37,7 @@ MockFileHandle_release_window(MockFileHa
     return true;
 }
 
-i64_t
+int64_t
 MockFileHandle_length(MockFileHandle *self)
 {
     return self->len;

Modified: lucene/lucy/trunk/core/Lucy/Test/Store/TestFSFileHandle.c
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Test/Store/TestFSFileHandle.c?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Test/Store/TestFSFileHandle.c (original)
+++ lucene/lucy/trunk/core/Lucy/Test/Store/TestFSFileHandle.c Fri Apr  2 23:36:47 2010
@@ -180,7 +180,7 @@ test_Window(TestBatch *batch)
     CharBuf *test_filename = (CharBuf*)ZCB_WRAP_STR("_fstest", 7);
     FSFileHandle *fh;
     FileWindow *window = FileWindow_new();
-    u32_t i;
+    uint32_t i;
 
     remove((char*)CB_Get_Ptr8(test_filename));
     fh = FSFH_open(test_filename, 

Modified: lucene/lucy/trunk/core/Lucy/Test/Store/TestFSFolder.c
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Test/Store/TestFSFolder.c?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Test/Store/TestFSFolder.c (original)
+++ lucene/lucy/trunk/core/Lucy/Test/Store/TestFSFolder.c Fri Apr  2 23:36:47 2010
@@ -144,7 +144,7 @@ test_disallow_updir(TestBatch *batch)
 void
 TestFSFolder_run_tests()
 {
-    u32_t num_tests = TestFolderCommon_num_tests() + 9;
+    uint32_t num_tests = TestFolderCommon_num_tests() + 9;
     TestBatch *batch = TestBatch_new(num_tests);
 
     TestBatch_Plan(batch);

Modified: lucene/lucy/trunk/core/Lucy/Test/Store/TestFolderCommon.bp
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Test/Store/TestFolderCommon.bp?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Test/Store/TestFolderCommon.bp (original)
+++ lucene/lucy/trunk/core/Lucy/Test/Store/TestFolderCommon.bp Fri Apr  2 23:36:47 2010
@@ -12,7 +12,7 @@ lucy_TestFolderCommon_tear_down_t(void);
 __END_C__
 
 inert class Lucy::Test::Store::TestFolderCommon {
-    inert u32_t
+    inert uint32_t
     num_tests();
 
     inert void

Modified: lucene/lucy/trunk/core/Lucy/Test/Store/TestFolderCommon.c
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Test/Store/TestFolderCommon.c?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Test/Store/TestFolderCommon.c (original)
+++ lucene/lucy/trunk/core/Lucy/Test/Store/TestFolderCommon.c Fri Apr  2 23:36:47 2010
@@ -496,7 +496,7 @@ test_Close(TestBatch *batch, set_up_t se
     tear_down();
 }
 
-u32_t
+uint32_t
 TestFolderCommon_num_tests()
 {
     return 99;

Modified: lucene/lucy/trunk/core/Lucy/Test/Store/TestIOPrimitives.c
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Test/Store/TestIOPrimitives.c?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Test/Store/TestIOPrimitives.c (original)
+++ lucene/lucy/trunk/core/Lucy/Test/Store/TestIOPrimitives.c Fri Apr  2 23:36:47 2010
@@ -67,7 +67,7 @@ test_u8(TestBatch *batch)
 static void
 test_i32(TestBatch *batch)
 {
-    i64_t      *ints = TestUtils_random_i64s(NULL, 1000, I32_MIN, I32_MAX);
+    int64_t    *ints = TestUtils_random_i64s(NULL, 1000, I32_MIN, I32_MAX);
     RAMFile    *file      = RAMFile_new(NULL, false);
     OutStream  *outstream = OutStream_open((Obj*)file);
     InStream   *instream;
@@ -106,7 +106,7 @@ test_i32(TestBatch *batch)
 static void
 test_u32(TestBatch *batch)
 {
-    u64_t      *ints = TestUtils_random_u64s(NULL, 1000, 0, U32_MAX);
+    uint64_t   *ints = TestUtils_random_u64s(NULL, 1000, 0, U32_MAX);
     RAMFile    *file      = RAMFile_new(NULL, false);
     OutStream  *outstream = OutStream_open((Obj*)file);
     InStream   *instream;
@@ -145,7 +145,7 @@ test_u32(TestBatch *batch)
 static void
 test_i64(TestBatch *batch)
 {
-    i64_t      *ints = TestUtils_random_i64s(NULL, 1000, I64_MIN, I64_MAX);
+    int64_t    *ints = TestUtils_random_i64s(NULL, 1000, I64_MIN, I64_MAX);
     RAMFile    *file      = RAMFile_new(NULL, false);
     OutStream  *outstream = OutStream_open((Obj*)file);
     InStream   *instream;
@@ -185,7 +185,7 @@ test_i64(TestBatch *batch)
 static void
 test_u64(TestBatch *batch)
 {
-    u64_t      *ints = TestUtils_random_u64s(NULL, 1000, 0, U64_MAX);
+    uint64_t   *ints = TestUtils_random_u64s(NULL, 1000, 0, U64_MAX);
     RAMFile    *file      = RAMFile_new(NULL, false);
     OutStream  *outstream = OutStream_open((Obj*)file);
     InStream   *instream;
@@ -224,7 +224,7 @@ test_u64(TestBatch *batch)
 static void
 test_c32(TestBatch *batch)
 {
-    u64_t      *ints = TestUtils_random_u64s(NULL, 1000, 0, U32_MAX);
+    uint64_t   *ints = TestUtils_random_u64s(NULL, 1000, 0, U32_MAX);
     RAMFile    *file      = RAMFile_new(NULL, false);
     OutStream  *outstream = OutStream_open((Obj*)file);
     InStream   *instream;
@@ -263,7 +263,7 @@ test_c32(TestBatch *batch)
 static void
 test_c64(TestBatch *batch)
 {
-    u64_t      *ints   = TestUtils_random_u64s(NULL, 1000, 0, U64_MAX);
+    uint64_t   *ints   = TestUtils_random_u64s(NULL, 1000, 0, U64_MAX);
     RAMFile    *file     = RAMFile_new(NULL, false);
     RAMFile    *raw_file = RAMFile_new(NULL, false);
     OutStream  *outstream     = OutStream_open((Obj*)file);

Modified: lucene/lucy/trunk/core/Lucy/Test/Store/TestInStream.c
URL: http://svn.apache.org/viewvc/lucene/lucy/trunk/core/Lucy/Test/Store/TestInStream.c?rev=930438&r1=930437&r2=930438&view=diff
==============================================================================
--- lucene/lucy/trunk/core/Lucy/Test/Store/TestInStream.c (original)
+++ lucene/lucy/trunk/core/Lucy/Test/Store/TestInStream.c Fri Apr  2 23:36:47 2010
@@ -135,10 +135,10 @@ test_Close(TestBatch *batch)
 static void
 test_Seek_and_Tell(TestBatch *batch)
 {
-    i64_t       gb1      = 0x40000000;
-    i64_t       gb3      = gb1 * 3;
-    i64_t       gb6      = gb1 * 6;
-    i64_t       gb12     = gb1 * 12;
+    int64_t     gb1      = 0x40000000;
+    int64_t     gb3      = gb1 * 3;
+    int64_t     gb6      = gb1 * 6;
+    int64_t     gb12     = gb1 * 12;
     FileHandle *fh       = (FileHandle*)MockFileHandle_new(NULL, gb12);
     InStream   *instream = InStream_open((Obj*)fh);
 



Mime
View raw message