zstd-native-ruby 1.0.1 → 1.0.2

data/{vendor → ext/zstd_native}/zstd/programs/fileio.h

@@ -70,7 +70,7 @@ void FIO_setAdaptiveMode(FIO_prefs_t* const prefs, int adapt);
 void FIO_setAdaptMin(FIO_prefs_t* const prefs, int minCLevel);
 void FIO_setAdaptMax(FIO_prefs_t* const prefs, int maxCLevel);
 void FIO_setUseRowMatchFinder(FIO_prefs_t* const prefs, int useRowMatchFinder);
-void FIO_setJobSize(FIO_prefs_t* const prefs, int jobSize);
+void FIO_setBlockSize(FIO_prefs_t* const prefs, int blockSize);
 void FIO_setChecksumFlag(FIO_prefs_t* const prefs, int checksumFlag);
 void FIO_setDictIDFlag(FIO_prefs_t* const prefs, int dictIDFlag);
 void FIO_setLdmBucketSizeLog(FIO_prefs_t* const prefs, int ldmBucketSizeLog);

data/{vendor → ext/zstd_native}/zstd/programs/fileio_types.h

@@ -37,7 +37,7 @@ typedef struct FIO_prefs_s {
     int sparseFileSupport;   /* 0: no sparse allowed; 1: auto (file yes, stdout no); 2: force sparse */
     int dictIDFlag;
     int checksumFlag;
-    int jobSize;
+    int blockSize;
     int overlapLog;
     int adaptiveMode;
     int useRowMatchFinder;

data/{vendor → ext/zstd_native}/zstd/programs/timefn.c

@@ -28,20 +28,18 @@
 UTIL_time_t UTIL_getTime(void)
 {
     static LARGE_INTEGER ticksPerSecond;
-    static double nsFactor = 1.0;
     static int init = 0;
     if (!init) {
         if (!QueryPerformanceFrequency(&ticksPerSecond)) {
             perror("timefn::QueryPerformanceFrequency");
             abort();
         }
-        nsFactor = 1000000000.0 / (double)ticksPerSecond.QuadPart;
         init = 1;
     }
     {   UTIL_time_t r;
         LARGE_INTEGER x;
         QueryPerformanceCounter(&x);
-        r.t = (PTime)((double)x.QuadPart * nsFactor);
+        r.t = (PTime)(x.QuadPart * 1000000000ULL / ticksPerSecond.QuadPart);
         return r;
     }
 }

data/{vendor → ext/zstd_native}/zstd/programs/util.c

@@ -151,8 +151,7 @@ int UTIL_requireUserConfirmation(const char* prompt, const char* abortMsg,
 /*-*************************************
 *  Constants
 ***************************************/
-#define KB * (1 << 10)
-#define LIST_SIZE_INCREASE   (8 KB)
+#define LIST_SIZE_INCREASE   (8*1024)
 #define MAX_FILE_OF_FILE_NAMES_SIZE (1<<20)*50
 
 
@@ -197,16 +196,6 @@ int UTIL_stat(const char* filename, stat_t* statbuf)
     return UTIL_fstat(-1, filename, statbuf);
 }
 
-int UTIL_isFdRegularFile(int fd)
-{
-    stat_t statbuf;
-    int ret;
-    UTIL_TRACE_CALL("UTIL_isFdRegularFile(%d)", fd);
-    ret = fd >= 0 && UTIL_fstat(fd, "", &statbuf) && UTIL_isRegularFileStat(&statbuf);
-    UTIL_TRACE_RET(ret);
-    return ret;
-}
-
 int UTIL_isRegularFile(const char* infilename)
 {
     stat_t statbuf;
@@ -459,26 +448,6 @@ int UTIL_isFIFOStat(const stat_t* statbuf)
     return 0;
 }
 
-/* process substitution */
-int UTIL_isFileDescriptorPipe(const char* filename)
-{
-    UTIL_TRACE_CALL("UTIL_isFileDescriptorPipe(%s)", filename);
-    /* Check if the filename is a /dev/fd/ path which indicates a file descriptor */
-    if (filename[0] == '/' && strncmp(filename, "/dev/fd/", 8) == 0) {
-        UTIL_TRACE_RET(1);
-        return 1;
-    }
-
-    /* Check for alternative process substitution formats on different systems */
-    if (filename[0] == '/' && strncmp(filename, "/proc/self/fd/", 14) == 0) {
-        UTIL_TRACE_RET(1);
-        return 1;
-    }
-
-    UTIL_TRACE_RET(0);
-    return 0; /* Not recognized as a file descriptor pipe */
-}
-
 /* UTIL_isBlockDevStat : distinguish named pipes */
 int UTIL_isBlockDevStat(const stat_t* statbuf)
 {
@@ -645,157 +614,101 @@ U64 UTIL_getTotalFileSize(const char* const * fileNamesTable, unsigned nbFiles)
 }
 
 
-/* Read the entire content of a file into a buffer with progressive resizing */
-static char* UTIL_readFileContent(FILE* inFile, size_t* totalReadPtr)
+/* condition : @file must be valid, and not have reached its end.
+ * @return : length of line written into @buf, ended with `\0` instead of '\n',
+ *           or 0, if there is no new line */
+static size_t readLineFromFile(char* buf, size_t len, FILE* file)
 {
-    size_t bufSize = 64 KB;  /* Start with a reasonable buffer size */
-    size_t totalRead = 0;
-    size_t bytesRead = 0;
-    char* buf = (char*)malloc(bufSize);
-    if (buf == NULL) return NULL;
-
-
-    /* Read the file incrementally */
-    while ((bytesRead = fread(buf + totalRead, 1, bufSize - totalRead - 1, inFile)) > 0) {
-        totalRead += bytesRead;
-
-        /* If buffer is nearly full, expand it */
-        if (bufSize - totalRead < 1 KB) {
-            if (bufSize >= MAX_FILE_OF_FILE_NAMES_SIZE) {
-                /* Too large, abort */
-                free(buf);
-                return NULL;
-            }
-
-            {   size_t newBufSize = bufSize * 2;
-                if (newBufSize > MAX_FILE_OF_FILE_NAMES_SIZE)
-                    newBufSize = MAX_FILE_OF_FILE_NAMES_SIZE;
-
-                {   char* newBuf = (char*)realloc(buf, newBufSize);
-                    if (newBuf == NULL) {
-                        free(buf);
-                        return NULL;
-                    }
-
-                    buf = newBuf;
-                    bufSize = newBufSize;
-        }   }   }
+    assert(!feof(file));
+    if ( fgets(buf, (int) len, file) == NULL ) return 0;
+    {   size_t linelen = strlen(buf);
+        if (strlen(buf)==0) return 0;
+        if (buf[linelen-1] == '\n') linelen--;
+        buf[linelen] = '\0';
+        return linelen+1;
     }
-
-    /* Add null terminator to the end */
-    buf[totalRead] = '\0';
-    *totalReadPtr = totalRead;
-
-    return buf;
 }
 
-/* Process a buffer containing multiple lines and count the number of lines */
-static size_t UTIL_processLines(char* buffer, size_t bufferSize)
-{
-    size_t lineCount = 0;
-    size_t i = 0;
-
-    /* Convert newlines to null terminators and count lines */
-    while (i < bufferSize) {
-        if (buffer[i] == '\n') {
-            buffer[i] = '\0';  /* Replace newlines with null terminators */
-            lineCount++;
-        }
-        i++;
-    }
-
-    /* Count the last line if it doesn't end with a newline */
-    if (bufferSize > 0 && (i == 0 || buffer[i-1] != '\0')) {
-        lineCount++;
-    }
-
-    return lineCount;
-}
-
-/* Create an array of pointers to the lines in a buffer */
-static const char** UTIL_createLinePointers(char* buffer, size_t numLines, size_t bufferSize)
+/* Conditions :
+ *   size of @inputFileName file must be < @dstCapacity
+ *   @dst must be initialized
+ * @return : nb of lines
+ *       or -1 if there's an error
+ */
+static int
+readLinesFromFile(void* dst, size_t dstCapacity,
+            const char* inputFileName)
 {
-    size_t lineIndex = 0;
+    int nbFiles = 0;
     size_t pos = 0;
-    void* const bufferPtrs = malloc(numLines * sizeof(const char**));
-    const char** const linePointers = (const char**)bufferPtrs;
-    if (bufferPtrs == NULL) return NULL;
-
-    while (lineIndex < numLines && pos < bufferSize) {
-        size_t len = 0;
-        linePointers[lineIndex++] = buffer+pos;
+    char* const buf = (char*)dst;
+    FILE* const inputFile = fopen(inputFileName, "r");
 
-        /* Find the next null terminator, being careful not to go past the buffer */
-        while ((pos + len < bufferSize) && buffer[pos + len] != '\0') {
-            len++;
-        }
+    assert(dst != NULL);
 
-        /* Move past this string and its null terminator */
-        pos += len;
-        if (pos < bufferSize) pos++;  /* Skip the null terminator if we're not at buffer end */
+    if(!inputFile) {
+        if (g_utilDisplayLevel >= 1) perror("zstd:util:readLinesFromFile");
+        return -1;
     }
 
-    /* Verify we processed the expected number of lines */
-    if (lineIndex != numLines) {
-        /* Something went wrong - we didn't find as many lines as expected */
-        free(bufferPtrs);
-        return NULL;
+    while ( !feof(inputFile) ) {
+        size_t const lineLength = readLineFromFile(buf+pos, dstCapacity-pos, inputFile);
+        if (lineLength == 0) break;
+        assert(pos + lineLength <= dstCapacity); /* '=' for inputFile not terminated with '\n' */
+        pos += lineLength;
+        ++nbFiles;
     }
 
-    return linePointers;
+    CONTROL( fclose(inputFile) == 0 );
+
+    return nbFiles;
 }
 
+/*Note: buf is not freed in case function successfully created table because filesTable->fileNames[0] = buf*/
 FileNamesTable*
-UTIL_createFileNamesTable_fromFileList(const char* fileList)
+UTIL_createFileNamesTable_fromFileName(const char* inputFileName)
 {
+    size_t nbFiles = 0;
+    char* buf;
+    size_t bufSize;
     stat_t statbuf;
-    char* buffer = NULL;
-    size_t numLines = 0;
-    size_t bufferSize = 0;
 
-    /* Check if the input is a valid file */
-    if (!UTIL_stat(fileList, &statbuf)) {
+    if (!UTIL_stat(inputFileName, &statbuf) || !UTIL_isRegularFileStat(&statbuf))
         return NULL;
-    }
 
-    /* Check if the input is a supported type */
-    if (!UTIL_isRegularFileStat(&statbuf) &&
-        !UTIL_isFIFOStat(&statbuf) &&
-        !UTIL_isFileDescriptorPipe(fileList)) {
-        return NULL;
+    {   U64 const inputFileSize = UTIL_getFileSizeStat(&statbuf);
+        if(inputFileSize > MAX_FILE_OF_FILE_NAMES_SIZE)
+            return NULL;
+        bufSize = (size_t)(inputFileSize + 1); /* (+1) to add '\0' at the end of last filename */
     }
 
-    /* Open the input file */
-    {   FILE* const inFile = fopen(fileList, "rb");
-        if (inFile == NULL) return NULL;
+    buf = (char*) malloc(bufSize);
+    CONTROL( buf != NULL );
 
-        /* Read the file content */
-        buffer = UTIL_readFileContent(inFile, &bufferSize);
-        fclose(inFile);
-    }
-
-    if (buffer == NULL) return NULL;
+    {   int const ret_nbFiles = readLinesFromFile(buf, bufSize, inputFileName);
 
-    /* Process lines */
-    numLines = UTIL_processLines(buffer, bufferSize);
-    if (numLines == 0) {
-        free(buffer);
-        return NULL;
+        if (ret_nbFiles <= 0) {
+          free(buf);
+          return NULL;
+        }
+        nbFiles = (size_t)ret_nbFiles;
     }
 
-    /* Create line pointers */
-    {   const char** linePointers = UTIL_createLinePointers(buffer, numLines, bufferSize);
-        if (linePointers == NULL) {
-            free(buffer);
-            return NULL;
+    {   const char** filenamesTable = (const char**) malloc(nbFiles * sizeof(*filenamesTable));
+        CONTROL(filenamesTable != NULL);
+
+        {   size_t fnb, pos = 0;
+            for (fnb = 0; fnb < nbFiles; fnb++) {
+                filenamesTable[fnb] = buf+pos;
+                pos += strlen(buf+pos)+1;  /* +1 for the finishing `\0` */
+            }
+        assert(pos <= bufSize);
         }
 
-        /* Create the final table */
-        return UTIL_assembleFileNamesTable(linePointers, numLines, buffer);
+        return UTIL_assembleFileNamesTable(filenamesTable, nbFiles, buf);
     }
 }
 
-
 static FileNamesTable*
 UTIL_assembleFileNamesTable2(const char** filenames, size_t tableSize, size_t tableCapacity, char* buf)
 {
@@ -928,7 +841,6 @@ static int UTIL_prepareFileList(const char* dirName,
     hFile=FindFirstFileA(path, &cFile);
     if (hFile == INVALID_HANDLE_VALUE) {
         UTIL_DISPLAYLEVEL(1, "Cannot open directory '%s'\n", dirName);
-        free(path);
         return 0;
     }
     free(path);

data/{vendor → ext/zstd_native}/zstd/programs/util.h

@@ -184,7 +184,6 @@ int UTIL_fchmod(const int fd, char const* filename, const stat_t* statbuf, mode_
  * compute the needed information.
  */
 
-int UTIL_isFdRegularFile(int fd);
 int UTIL_isRegularFile(const char* infilename);
 int UTIL_isDirectory(const char* infilename);
 int UTIL_isSameFile(const char* file1, const char* file2);
@@ -192,7 +191,6 @@ int UTIL_isSameFileStat(const char* file1, const char* file2, const stat_t* file
 int UTIL_isCompressedFile(const char* infilename, const char *extensionList[]);
 int UTIL_isLink(const char* infilename);
 int UTIL_isFIFO(const char* infilename);
-int UTIL_isFileDescriptorPipe(const char* filename);
 
 /**
  * Returns with the given file descriptor is a console.
@@ -252,13 +250,13 @@ typedef struct
     size_t tableCapacity;
 } FileNamesTable;
 
-/*! UTIL_createFileNamesTable_fromFileList() :
+/*! UTIL_createFileNamesTable_fromFileName() :
  *  read filenames from @inputFileName, and store them into returned object.
  * @return : a FileNamesTable*, or NULL in case of error (ex: @inputFileName doesn't exist).
  *  Note: inputFileSize must be less than 50MB
  */
 FileNamesTable*
-UTIL_createFileNamesTable_fromFileList(const char* inputFileName);
+UTIL_createFileNamesTable_fromFileName(const char* inputFileName);
 
 /*! UTIL_assembleFileNamesTable() :
  *  This function takes ownership of its arguments, @filenames and @buf,