Use POSIX data types for external interfaces (#1358)

Replace the Tesseract specific data types in header files which are
part of Debian package libtesseract-dev by POSIX data types.

Update also matching cpp files.

Signed-off-by: Stefan Weil <[email protected]>

Author: stweil

ccutil/genericvector.h

@@ -346,8 +346,8 @@ class GenericVector {
   // vector are small enough that for efficiency it makes sense
   // to start with a larger initial size.
   static const int kDefaultVectorSize = 4;
-  inT32   size_used_;
-  inT32   size_reserved_;
+  int32_t   size_used_;
+  int32_t   size_reserved_;
   T*    data_;
   TessCallback1<T>* clear_cb_;
   // Mutable because Run method is not const
@@ -536,20 +536,20 @@ class PointerVector : public GenericVector<T*> {
   // normal GenericVector of those.
   // Returns false in case of error.
   bool Serialize(FILE* fp) const {
-    inT32 used = GenericVector<T*>::size_used_;
+    int32_t used = GenericVector<T*>::size_used_;
     if (fwrite(&used, sizeof(used), 1, fp) != 1) return false;
     for (int i = 0; i < used; ++i) {
-      inT8 non_null = GenericVector<T*>::data_[i] != NULL;
+      int8_t non_null = GenericVector<T*>::data_[i] != NULL;
       if (fwrite(&non_null, sizeof(non_null), 1, fp) != 1) return false;
       if (non_null && !GenericVector<T*>::data_[i]->Serialize(fp)) return false;
     }
     return true;
   }
   bool Serialize(TFile* fp) const {
-    inT32 used = GenericVector<T*>::size_used_;
+    int32_t used = GenericVector<T*>::size_used_;
     if (fp->FWrite(&used, sizeof(used), 1) != 1) return false;
     for (int i = 0; i < used; ++i) {
-      inT8 non_null = GenericVector<T*>::data_[i] != NULL;
+      int8_t non_null = GenericVector<T*>::data_[i] != NULL;
       if (fp->FWrite(&non_null, sizeof(non_null), 1) != 1) return false;
       if (non_null && !GenericVector<T*>::data_[i]->Serialize(fp)) return false;
     }
@@ -563,13 +563,13 @@ class PointerVector : public GenericVector<T*> {
   // Also needs T::T(), as new T is used in this function.
   // Returns false in case of error.
   bool DeSerialize(bool swap, FILE* fp) {
-    inT32 reserved;
+    int32_t reserved;
     if (fread(&reserved, sizeof(reserved), 1, fp) != 1) return false;
     if (swap) Reverse32(&reserved);
     GenericVector<T*>::reserve(reserved);
     truncate(0);
     for (int i = 0; i < reserved; ++i) {
-      inT8 non_null;
+      int8_t non_null;
       if (fread(&non_null, sizeof(non_null), 1, fp) != 1) return false;
       T* item = NULL;
       if (non_null) {
@@ -587,7 +587,7 @@ class PointerVector : public GenericVector<T*> {
     return true;
   }
   bool DeSerialize(TFile* fp) {
-    inT32 reserved;
+    int32_t reserved;
     if (!DeSerializeSize(fp, &reserved)) return false;
     GenericVector<T*>::reserve(reserved);
     truncate(0);
@@ -600,12 +600,12 @@ class PointerVector : public GenericVector<T*> {
   // retain the integrity of the stream, the caller must call some combination
   // of DeSerializeElement and DeSerializeSkip of the exact number returned in
   // *size, assuming a true return.
-  static bool DeSerializeSize(TFile* fp, inT32* size) {
+  static bool DeSerializeSize(TFile* fp, int32_t* size) {
     return fp->FReadEndian(size, sizeof(*size), 1) == 1;
   }
   // Reads and appends to the vector the next element of the serialization.
   bool DeSerializeElement(TFile* fp) {
-    inT8 non_null;
+    int8_t non_null;
     if (fp->FRead(&non_null, sizeof(non_null), 1) != 1) return false;
     T* item = NULL;
     if (non_null) {
@@ -623,7 +623,7 @@ class PointerVector : public GenericVector<T*> {
   }
   // Skips the next element of the serialization.
   static bool DeSerializeSkip(TFile* fp) {
-    inT8 non_null;
+    int8_t non_null;
     if (fp->FRead(&non_null, sizeof(non_null), 1) != 1) return false;
     if (non_null) {
       if (!T::SkipDeSerialize(fp)) return false;
@@ -906,7 +906,7 @@ bool GenericVector<T>::write(
 template <typename T>
 bool GenericVector<T>::read(
     tesseract::TFile* f, TessResultCallback2<bool, tesseract::TFile*, T*>* cb) {
-  inT32 reserved;
+  int32_t reserved;
   if (f->FReadEndian(&reserved, sizeof(reserved), 1) != 1) return false;
   reserve(reserved);
   if (f->FReadEndian(&size_used_, sizeof(size_used_), 1) != 1) return false;
@@ -947,7 +947,7 @@ bool GenericVector<T>::Serialize(tesseract::TFile* fp) const {
 // If swap is true, assumes a big/little-endian swap is needed.
 template <typename T>
 bool GenericVector<T>::DeSerialize(bool swap, FILE* fp) {
-  inT32 reserved;
+  int32_t reserved;
   if (fread(&reserved, sizeof(reserved), 1, fp) != 1) return false;
   if (swap) Reverse32(&reserved);
   reserve(reserved);
@@ -961,15 +961,15 @@ bool GenericVector<T>::DeSerialize(bool swap, FILE* fp) {
 }
 template <typename T>
 bool GenericVector<T>::DeSerialize(tesseract::TFile* fp) {
-  inT32 reserved;
+  int32_t reserved;
   if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) return false;
   reserve(reserved);
   size_used_ = reserved;
   return fp->FReadEndian(data_, sizeof(T), size_used_) == size_used_;
 }
 template <typename T>
 bool GenericVector<T>::SkipDeSerialize(tesseract::TFile* fp) {
-  inT32 reserved;
+  int32_t reserved;
   if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) return false;
   return fp->FRead(NULL, sizeof(T), reserved) == reserved;
 }
@@ -1001,7 +1001,7 @@ bool GenericVector<T>::SerializeClasses(tesseract::TFile* fp) const {
 // If swap is true, assumes a big/little-endian swap is needed.
 template <typename T>
 bool GenericVector<T>::DeSerializeClasses(bool swap, FILE* fp) {
-  inT32 reserved;
+  int32_t reserved;
   if (fread(&reserved, sizeof(reserved), 1, fp) != 1) return false;
   if (swap) Reverse32(&reserved);
   T empty;
@@ -1013,7 +1013,7 @@ bool GenericVector<T>::DeSerializeClasses(bool swap, FILE* fp) {
 }
 template <typename T>
 bool GenericVector<T>::DeSerializeClasses(tesseract::TFile* fp) {
-  inT32 reserved;
+  int32_t reserved;
   if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) return false;
   T empty;
   init_to_size(reserved, empty);
@@ -1024,7 +1024,7 @@ bool GenericVector<T>::DeSerializeClasses(tesseract::TFile* fp) {
 }
 template <typename T>
 bool GenericVector<T>::SkipDeSerializeClasses(tesseract::TFile* fp) {
-  inT32 reserved;
+  int32_t reserved;
   if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) return false;
   for (int i = 0; i < reserved; ++i) {
     if (!T::SkipDeSerialize(fp)) return false;

ccutil/helpers.h

@@ -42,17 +42,17 @@ class TRand {
  public:
   TRand() : seed_(1) {}
   // Sets the seed to the given value.
-  void set_seed(uinT64 seed) {
+  void set_seed(uint64_t seed) {
     seed_ = seed;
   }
   // Sets the seed using a hash of a string.
   void set_seed(const std::string& str) {
     std::hash<std::string> hasher;
-    set_seed(static_cast<uinT64>(hasher(str)));
+    set_seed(static_cast<uint64_t>(hasher(str)));
   }
 
   // Returns an integer in the range 0 to MAX_INT32.
-  inT32 IntRand() {
+  int32_t IntRand() {
     Iterate();
     return seed_ >> 33;
   }
@@ -73,7 +73,7 @@ class TRand {
   }
 
   // The current value of the seed.
-  uinT64 seed_;
+  uint64_t seed_;
 };
 
 }  // namespace tesseract

ccutil/host.h

@@ -65,9 +65,9 @@ typedef unsigned char BOOL8;
 #define MAX_UINT32  0xffffffff
 #define MAX_FLOAT32 std::numeric_limits<float>::max()
 
-#define MIN_INT8 static_cast<inT8>(0x80)
-#define MIN_INT16 static_cast<inT16>(0x8000)
-#define MIN_INT32 static_cast<inT32>(0x80000000)
+#define MIN_INT8 static_cast<int8_t>(0x80)
+#define MIN_INT16 static_cast<int16_t>(0x8000)
+#define MIN_INT32 static_cast<int32_t>(0x80000000)
 #define MIN_UINT8 0x00
 #define MIN_UINT16  0x0000
 #define MIN_UINT32  0x00000000

ccutil/memry.cpp

@@ -27,7 +27,7 @@
 // TODO(rays) further cleanup by redirecting calls to new and creating proper
 // constructors.
 
-char *alloc_string(inT32 count) {
+char *alloc_string(int32_t count) {
   // Round up the amount allocated to a multiple of 4
   return static_cast<char*>(malloc((count + 3) & ~3));
 }
@@ -36,7 +36,7 @@ void free_string(char *string) {
   free(string);
 }
 
-void *alloc_mem(inT32 count) {
+void *alloc_mem(int32_t count) {
   return malloc(static_cast<size_t>(count));
 }
 

ccutil/memry.h

@@ -24,11 +24,11 @@
 #include          "host.h"
 
 // allocate string
-extern char *alloc_string(inT32 count);
+extern char *alloc_string(int32_t count);
 // free a string.
 extern void free_string(char *string);
 // get some memory
-extern void *alloc_mem(inT32 count);
+extern void *alloc_mem(int32_t count);
 // free mem from alloc_mem
 extern void free_mem(void *oldchunk);
 

ccutil/ocrclass.h

@@ -80,16 +80,16 @@ typedef struct {                  /*single character */
 // characters sets will need to handle extended characters appropriately, but
 // *all* code needs to be prepared to receive UTF8 coded characters for
 // characters such as bullet and fancy quotes.
-  uinT16 char_code;              /*character itself */
-  inT16 left;                    /*of char (-1) */
-  inT16 right;                   /*of char (-1) */
-  inT16 top;                     /*of char (-1) */
-  inT16 bottom;                  /*of char (-1) */
-  inT16 font_index;              /*what font (0) */
-  uinT8 confidence;              /*0=perfect, 100=reject (0/100) */
-  uinT8 point_size;              /*of char, 72=i inch, (10) */
-  inT8 blanks;                   /*no of spaces before this char (1) */
-  uinT8 formatting;              /*char formatting (0) */
+  uint16_t char_code;              /*character itself */
+  int16_t left;                    /*of char (-1) */
+  int16_t right;                   /*of char (-1) */
+  int16_t top;                     /*of char (-1) */
+  int16_t bottom;                  /*of char (-1) */
+  int16_t font_index;              /*what font (0) */
+  uint8_t confidence;              /*0=perfect, 100=reject (0/100) */
+  uint8_t point_size;              /*of char, 72=i inch, (10) */
+  int8_t blanks;                   /*no of spaces before this char (1) */
+  uint8_t formatting;              /*char formatting (0) */
 } EANYCODE_CHAR;                 /*single character */
 
 /**********************************************************************
@@ -114,14 +114,14 @@ typedef bool (*PROGRESS_FUNC)(int progress, int left, int right, int top,
 
 class ETEXT_DESC {             // output header
  public:
-  inT16 count;     /// chars in this buffer(0)
-  inT16 progress;  /// percent complete increasing (0-100)
+  int16_t count;     /// chars in this buffer(0)
+  int16_t progress;  /// percent complete increasing (0-100)
   /** Progress monitor covers word recognition and it does not cover layout
   * analysis.
   * See Ray comment in https://github.com/tesseract-ocr/tesseract/pull/27 */
-  inT8 more_to_come;                /// true if not last
-  volatile inT8 ocr_alive;          /// ocr sets to 1, HP 0
-  inT8 err_code;                    /// for errcode use
+  int8_t more_to_come;                /// true if not last
+  volatile int8_t ocr_alive;          /// ocr sets to 1, HP 0
+  int8_t err_code;                    /// for errcode use
   CANCEL_FUNC cancel;               /// returns true to cancel
   PROGRESS_FUNC progress_callback;  /// called whenever progress increases
   void* cancel_this;                /// this or other data for cancel
@@ -143,9 +143,9 @@ class ETEXT_DESC {             // output header
   }
 
   // Sets the end time to be deadline_msecs milliseconds from now.
-  void set_deadline_msecs(inT32 deadline_msecs) {
+  void set_deadline_msecs(int32_t deadline_msecs) {
     gettimeofday(&end_time, NULL);
-    inT32 deadline_secs = deadline_msecs / 1000;
+    int32_t deadline_secs = deadline_msecs / 1000;
     end_time.tv_sec += deadline_secs;
     end_time.tv_usec += (deadline_msecs -  deadline_secs * 1000) * 1000;
     if (end_time.tv_usec > 1000000) {

ccutil/params.cpp

@@ -147,7 +147,7 @@ bool ParamUtils::GetParamAsString(const char *name,
                                      member_params->int_params);
   if (ip) {
     char buf[128];
-    snprintf(buf, sizeof(buf), "%d", inT32(*ip));
+    snprintf(buf, sizeof(buf), "%d", int32_t(*ip));
     *value = buf;
     return true;
   }
@@ -177,7 +177,7 @@ void ParamUtils::PrintParams(FILE *fp, const ParamsVectors *member_params) {
     const ParamsVectors *vec = (v == 0) ? GlobalParams() : member_params;
     for (i = 0; i < vec->int_params.size(); ++i) {
       fprintf(fp, "%s\t%d\t%s\n", vec->int_params[i]->name_str(),
-              (inT32)(*vec->int_params[i]), vec->int_params[i]->info_str());
+              (int32_t)(*vec->int_params[i]), vec->int_params[i]->info_str());
     }
     for (i = 0; i < vec->bool_params.size(); ++i) {
       fprintf(fp, "%s\t%d\t%s\n", vec->bool_params[i]->name_str(),

ccutil/params.h

@@ -141,24 +141,24 @@ class Param {
 
 class IntParam : public Param {
   public:
-   IntParam(inT32 value, const char *name, const char *comment, bool init,
+   IntParam(int32_t value, const char *name, const char *comment, bool init,
             ParamsVectors *vec) : Param(name, comment, init) {
     value_ = value;
     default_ = value;
     params_vec_ = &(vec->int_params);
     vec->int_params.push_back(this);
   }
   ~IntParam() { ParamUtils::RemoveParam<IntParam>(this, params_vec_); }
-  operator inT32() const { return value_; }
-  void operator=(inT32 value) { value_ = value; }
-  void set_value(inT32 value) { value_ = value; }
+  operator int32_t() const { return value_; }
+  void operator=(int32_t value) { value_ = value; }
+  void set_value(int32_t value) { value_ = value; }
   void ResetToDefault() {
     value_ = default_;
   }
 
  private:
-  inT32 value_;
-  inT32 default_;
+  int32_t value_;
+  int32_t default_;
   // Pointer to the vector that contains this param (not owened by this class).
   GenericVector<IntParam *> *params_vec_;
 };

ccutil/serialis.cpp

@@ -62,9 +62,9 @@ bool TFile::Open(const char* data, int size) {
   return true;
 }
 
-bool TFile::Open(FILE* fp, inT64 end_offset) {
+bool TFile::Open(FILE* fp, int64_t end_offset) {
   offset_ = 0;
-  inT64 current_pos = ftell(fp);
+  int64_t current_pos = ftell(fp);
   if (end_offset < 0) {
     if (fseek(fp, 0, SEEK_END))
       return false;

ccutil/serialis.h

@@ -60,7 +60,7 @@ class TFile {
   // From an existing memory buffer.
   bool Open(const char* data, int size);
   // From an open file and an end offset.
-  bool Open(FILE* fp, inT64 end_offset);
+  bool Open(FILE* fp, int64_t end_offset);
   // Sets the value of the swap flag, so that FReadEndian does the right thing.
   void set_swap(bool value) { swap_ = value; }