Result of clang tidy on recent merge

COPYING

@@ -17,5 +17,5 @@ in this distribution is now licensed under the Apache License:
 Other Dependencies and Licenses:
 ================================
 
-Tesseract uses Leptonica library (http://leptonica.com/) with a very weakly
+Tesseract uses Leptonica library (http://leptonica.com/) which essentially
-restricted copyright license (http://leptonica.com/about-the-license.html)
+uses a BSD 2-clause license. (http://leptonica.com/about-the-license.html)

android/jni/Android.mk

@@ -4,7 +4,7 @@ include $(CLEAR_VARS)
 LOCAL_MODULE := tesseract-$(APP_ABI)
 
 LOCAL_STATIC_LIBRARIES := \
-    mobile_base \
+    base \
     leptonica-$(APP_ABI)
 
 LOCAL_C_INCLUDES := $(APP_C_INCLUDES)
@@ -51,7 +51,6 @@ LOCAL_CFLAGS := -DANDROID_BUILD -DNO_CUBE_BUILD -DGRAPHICS_DISABLED
 
 include $(BUILD_SHARED_LIBRARY)
 
-$(call import-module,mobile/base)
+$(call import-module,base/port)
-$(call import-module,mobile/base)
 $(call import-module,mobile/util/hash)
 $(call import-module,third_party/leptonica/android/jni)

api/baseapi.cpp

@@ -809,9 +809,7 @@ int CubeAPITest(Boxa* boxa_blocks, Pixa* pixa_blocks,
  * has not been subjected to a call of Init, SetImage, Recognize, Clear, End
  * DetectOS, or anything else that changes the internal PAGE_RES.
  */
-PageIterator* TessBaseAPI::AnalyseLayout() {
+PageIterator* TessBaseAPI::AnalyseLayout() { return AnalyseLayout(false); }
-  return AnalyseLayout(false);
-}
 
 PageIterator* TessBaseAPI::AnalyseLayout(bool merge_similar_words) {
   if (FindLines() == 0) {
@@ -1379,8 +1377,9 @@ static void AddBaselineCoordsTohOCR(const PageIterator *it,
   hocr_str->add_str_double(" ", round(p0 * 1000.0) / 1000.0);
 }
 
-static void AddIdTohOCR(STRING* hocr_str, const std::string base, int num1, int num2) {
+static void AddIdTohOCR(STRING* hocr_str, const std::string base, int num1,
-  const unsigned long BUFSIZE = 64;
+                        int num2) {
+  const size_t BUFSIZE = 64;
   char id_buffer[BUFSIZE];
   if (num2 >= 0) {
     snprintf(id_buffer, BUFSIZE - 1, "%s_%d_%d", base.c_str(), num1, num2);
@@ -1393,8 +1392,7 @@ static void AddIdTohOCR(STRING* hocr_str, const std::string base, int num1, int
   *hocr_str += "'";
 }
 
-static void AddBoxTohOCR(const ResultIterator *it,
+static void AddBoxTohOCR(const ResultIterator* it, PageIteratorLevel level,
-                         PageIteratorLevel level,
                          STRING* hocr_str) {
   int left, top, right, bottom;
   it->BoundingBox(level, &left, &top, &right, &bottom);
@@ -1410,7 +1408,7 @@ static void AddBoxTohOCR(const ResultIterator *it,
     // add custom height measures
     float row_height, descenders, ascenders;  // row attributes
     it->RowAttributes(&row_height, &descenders, &ascenders);
-    // TODO: Do we want to limit these to a single decimal place?
+    // TODO(rays): Do we want to limit these to a single decimal place?
     hocr_str->add_str_double("; x_size ", row_height);
     hocr_str->add_str_double("; x_descenders ", descenders * -1);
     hocr_str->add_str_double("; x_ascenders ", ascenders);
@@ -1418,8 +1416,7 @@ static void AddBoxTohOCR(const ResultIterator *it,
   *hocr_str += "\">";
 }
 
-static void AddBoxToTSV(const PageIterator *it,
+static void AddBoxToTSV(const PageIterator* it, PageIteratorLevel level,
-                         PageIteratorLevel level,
                         STRING* hocr_str) {
   int left, top, right, bottom;
   it->BoundingBox(level, &left, &top, &right, &bottom);
@@ -1429,8 +1426,6 @@ static void AddBoxToTSV(const PageIterator *it,
   hocr_str->add_str_int("\t", bottom - top);
 }
 
-
-
 /**
  * Make a HTML-formatted string with hOCR markup from the internal
  * data structures.
@@ -1452,8 +1447,7 @@ char* TessBaseAPI::GetHOCRText(int page_number) {
  * STL removed from original patch submission and refactored by rays.
  */
 char* TessBaseAPI::GetHOCRText(ETEXT_DESC* monitor, int page_number) {
-  if (tesseract_ == NULL ||
+  if (tesseract_ == NULL || (page_res_ == NULL && Recognize(monitor) < 0))
-      (page_res_ == NULL && Recognize(monitor) < 0))
     return NULL;
 
   int lcnt = 1, bcnt = 1, pcnt = 1, wcnt = 1;
@@ -1470,13 +1464,13 @@ char* TessBaseAPI::GetHOCRText(ETEXT_DESC* monitor, int page_number) {
 
 #ifdef _WIN32
   // convert input name from ANSI encoding to utf-8
-  int str16_len = MultiByteToWideChar(CP_ACP, 0, input_file_->string(), -1,
+  int str16_len =
-                                      NULL, 0);
+      MultiByteToWideChar(CP_ACP, 0, input_file_->string(), -1, NULL, 0);
   wchar_t *uni16_str = new WCHAR[str16_len];
   str16_len = MultiByteToWideChar(CP_ACP, 0, input_file_->string(), -1,
                                   uni16_str, str16_len);
-  int utf8_len = WideCharToMultiByte(CP_UTF8, 0, uni16_str, str16_len, NULL,
+  int utf8_len = WideCharToMultiByte(CP_UTF8, 0, uni16_str, str16_len, NULL, 0,
-                                     0, NULL, NULL);
+                                     NULL, NULL);
   char *utf8_str = new char[utf8_len];
   WideCharToMultiByte(CP_UTF8, 0, uni16_str, str16_len, utf8_str,
                       utf8_len, NULL, NULL);
@@ -1567,8 +1561,12 @@ char* TessBaseAPI::GetHOCRText(ETEXT_DESC* monitor, int page_number) {
     }
     switch (res_it->WordDirection()) {
       // Only emit direction if different from current paragraph direction
-      case DIR_LEFT_TO_RIGHT: if (!para_is_ltr) hocr_str += " dir='ltr'"; break;
+      case DIR_LEFT_TO_RIGHT:
-      case DIR_RIGHT_TO_LEFT: if (para_is_ltr) hocr_str += " dir='rtl'"; break;
+        if (!para_is_ltr) hocr_str += " dir='ltr'";
+        break;
+      case DIR_RIGHT_TO_LEFT:
+        if (para_is_ltr) hocr_str += " dir='rtl'";
+        break;
       case DIR_MIX:
       case DIR_NEUTRAL:
       default:  // Do nothing.
@@ -1620,8 +1618,7 @@ char* TessBaseAPI::GetHOCRText(ETEXT_DESC* monitor, int page_number) {
  * page_number is 0-based but will appear in the output as 1-based.
  */
 char* TessBaseAPI::GetTSVText(int page_number) {
-  if (tesseract_ == NULL ||
+  if (tesseract_ == NULL || (page_res_ == NULL && Recognize(NULL) < 0))
-      (page_res_ == NULL && Recognize(NULL) < 0))
     return NULL;
 
   int lcnt = 1, bcnt = 1, pcnt = 1, wcnt = 1;
@@ -1629,7 +1626,8 @@ char* TessBaseAPI::GetTSVText(int page_number) {
 
   STRING tsv_str("");
 
-  int page_num = page_id, block_num = 0, par_num = 0, line_num = 0, word_num = 0;
+  int page_num = page_id, block_num = 0, par_num = 0, line_num = 0,
+      word_num = 0;
 
   tsv_str.add_str_int("1\t", page_num);  // level 1 - page
   tsv_str.add_str_int("\t", block_num);
@@ -1687,9 +1685,9 @@ char* TessBaseAPI::GetTSVText(int page_number) {
     int pointsize, font_id;
     const char* font_name;
     res_it->BoundingBox(RIL_WORD, &left, &top, &right, &bottom);
-    font_name = res_it->WordFontAttributes(&bold, &italic, &underlined,
+    font_name =
-                                           &monospace, &serif, &smallcaps,
+        res_it->WordFontAttributes(&bold, &italic, &underlined, &monospace,
-                                           &pointsize, &font_id);
+                                   &serif, &smallcaps, &pointsize, &font_id);
     word_num++;
     tsv_str.add_str_int("5\t", page_num);  // level 5 - word
     tsv_str.add_str_int("\t", block_num);
@@ -1760,7 +1758,7 @@ char* TessBaseAPI::GetBoxText(int page_number) {
   int total_length = blob_count * kBytesPerBoxFileLine + utf8_length +
       kMaxBytesPerLine;
   char* result = new char[total_length];
-  strcpy(result, "\0");
+  result[0] = '\0';
   int output_length = 0;
   LTRResultIterator* it = GetLTRIterator();
   do {
@@ -1933,17 +1931,17 @@ char* TessBaseAPI::GetOsdText(int page_number) {
   // clockwise rotation needed to make the page upright
   int rotate = OrientationIdToValue(orient_id);
 
-  char* osd_buf = new char[255];
+  const int kOsdBufsize = 255;
-  snprintf(osd_buf, 255,
+  char* osd_buf = new char[kOsdBufsize];
+  snprintf(osd_buf, kOsdBufsize,
            "Page number: %d\n"
            "Orientation in degrees: %d\n"
            "Rotate: %d\n"
            "Orientation confidence: %.2f\n"
            "Script: %s\n"
            "Script confidence: %.2f\n",
-          page_number,
+           page_number, orient_deg, rotate, orient_conf, script_name,
-          orient_deg, rotate, orient_conf,
+           script_conf);
-          script_name, script_conf);
 
   return osd_buf;
 }
@@ -2063,7 +2061,7 @@ void TessBaseAPI::Clear() {
   if (thresholder_ != NULL)
     thresholder_->Clear();
   ClearResults();
-  SetInputImage(NULL);
+  if (tesseract_ != NULL) SetInputImage(NULL);
 }
 
 /**
@@ -2767,7 +2765,7 @@ void TessBaseAPI::GetFeaturesForBlob(TBLOB* blob,
   INT_FX_RESULT_STRUCT fx_info;
   tesseract_->ExtractFeatures(*blob, false, &bl_features,
                               &cn_features, &fx_info, &outline_counts);
-  if (cn_features.size() == 0 || cn_features.size() > MAX_NUM_INT_FEATURES) {
+  if (cn_features.empty() || cn_features.size() > MAX_NUM_INT_FEATURES) {
     *num_features = 0;
     return;  // Feature extraction failed.
   }

api/baseapi.h

@@ -750,13 +750,9 @@ class TESS_API TessBaseAPI {
    */
   static void NormalizeTBLOB(TBLOB *tblob, ROW *row, bool numeric_mode);
 
-  Tesseract* tesseract() const {
+  Tesseract* tesseract() const { return tesseract_; }
-    return tesseract_;
-  }
 
-  OcrEngineMode oem() const {
+  OcrEngineMode oem() const { return last_oem_requested_; }
-    return last_oem_requested_;
-  }
 
   void InitTruthCallback(TruthCallback *cb) { truth_cb_ = cb; }
 
@@ -898,7 +894,7 @@ class TESS_API TessBaseAPI {
                             const char* retry_config, int timeout_millisec,
                             TessResultRenderer* renderer,
                             int tessedit_page_number);
-  // TIFF supports multipage so gets special consideration
+  // TIFF supports multipage so gets special consideration.
   bool ProcessPagesMultipageTiff(const unsigned char *data,
                                  size_t size,
                                  const char* filename,

api/pdfrenderer.cpp

@@ -20,12 +20,12 @@
 #include "config_auto.h"
 #endif
 
+#include "allheaders.h"
 #include "baseapi.h"
-#include "renderer.h"
 #include "math.h"
+#include "renderer.h"
 #include "strngs.h"
 #include "tprintf.h"
-#include "allheaders.h"
 
 #ifdef _MSC_VER
 #include "mathfix.h"
@@ -567,7 +567,8 @@ bool TessPDFRenderer::BeginDocumentHandler() {
                "<<\n"
                "  /Length %lu /Filter /FlateDecode\n"
                ">>\n"
-               "stream\n", (unsigned long)len);
+               "stream\n",
+               (unsigned long)len);
   if (n >= sizeof(buf)) {
     lept_free(comp);
     return false;

api/renderer.cpp

@@ -210,13 +210,13 @@ TessTsvRenderer::TessTsvRenderer(const char *outputbase, bool font_info)
 
 bool TessTsvRenderer::BeginDocumentHandler() {
   // Output TSV column headings
-  AppendString("level\tpage_num\tblock_num\tpar_num\tline_num\tword_num\tleft\ttop\twidth\theight\tconf\ttext\n");
+  AppendString(
+      "level\tpage_num\tblock_num\tpar_num\tline_num\tword_"
+      "num\tleft\ttop\twidth\theight\tconf\ttext\n");
   return true;
 }
 
-bool TessTsvRenderer::EndDocumentHandler() {
+bool TessTsvRenderer::EndDocumentHandler() { return true; }
-  return true;
-}
 
 bool TessTsvRenderer::AddImageHandler(TessBaseAPI* api) {
   char* tsv = api->GetTSVText(imagenum());
@@ -266,8 +266,7 @@ bool TessBoxTextRenderer::AddImageHandler(TessBaseAPI* api) {
  * Osd Text Renderer interface implementation
  **********************************************************************/
 TessOsdRenderer::TessOsdRenderer(const char* outputbase)
-    : TessResultRenderer(outputbase, "osd") {
+    : TessResultRenderer(outputbase, "osd") {}
-}
 
 bool TessOsdRenderer::AddImageHandler(TessBaseAPI* api) {
   char* osd = api->GetOsdText(imagenum());

api/tesseractmain.cpp

@@ -111,16 +111,11 @@ void PrintHelpForPSM() {
       "  8    Treat the image as a single word.\n"
       "  9    Treat the image as a single word in a circle.\n"
       " 10    Treat the image as a single character.\n"
-
-        //TODO: Consider publishing these modes.
-        #if 0
       " 11    Sparse text. Find as much text as possible in no"
       " particular order.\n"
       " 12    Sparse text with OSD.\n"
       " 13    Raw line. Treat the image as a single text line,\n"
-          "\t\t\tbypassing hacks that are Tesseract-specific.\n"
+      "\t\t\tbypassing hacks that are Tesseract-specific.\n";
-        #endif
-        ;
 
   printf("%s", msg);
 }
@@ -137,8 +132,7 @@ void PrintHelpMessage(const char* program) {
       "  -c VAR=VALUE          Set value for config variables.\n"
       "                        Multiple -c arguments are allowed.\n"
       "  -psm NUM              Specify page segmentation mode.\n"
-      "NOTE: These options must occur before any configfile.\n"
+      "NOTE: These options must occur before any configfile.\n";
-     ;
 
   printf("\n%s\n", ocr_options);
   PrintHelpForPSM();
@@ -149,13 +143,13 @@ void PrintHelpMessage(const char* program) {
       "  --help-psm            Show page segmentation modes.\n"
       "  -v, --version         Show version information.\n"
       "  --list-langs          List available languages for tesseract engine.\n"
-      "  --print-parameters    Print tesseract parameters to stdout.\n"
+      "  --print-parameters    Print tesseract parameters to stdout.\n";
-      ;
 
   printf("\n%s", single_options);
 }
 
-void SetVariablesFromCLArgs(tesseract::TessBaseAPI* api, int argc, char** argv) {
+void SetVariablesFromCLArgs(tesseract::TessBaseAPI* api, int argc,
+                            char** argv) {
   char opt1[256], opt2[255];
   for (int i = 0; i < argc; i++) {
     if (strcmp(argv[i], "-c") == 0 && i + 1 < argc) {
@@ -215,16 +209,11 @@ void FixPageSegMode(tesseract::TessBaseAPI* api,
 }
 
 // NOTE: arg_i is used here to avoid ugly *i so many times in this function
-void ParseArgs(const int argc, char** argv,
+void ParseArgs(const int argc, char** argv, const char** lang,
-                  const char** lang,
+               const char** image, const char** outputbase,
-                  const char** image,
+               const char** datapath, bool* list_langs, bool* print_parameters,
-                  const char** outputbase,
-                  const char** datapath,
-                  bool* list_langs,
-                  bool* print_parameters,
                GenericVector<STRING>* vars_vec,
-                  GenericVector<STRING>* vars_values,
+               GenericVector<STRING>* vars_values, int* arg_i,
-                  int* arg_i,
                tesseract::PageSegMode* pagesegmode) {
   if (argc == 1) {
     PrintHelpMessage(argv[0]);
@@ -232,8 +221,7 @@ void ParseArgs(const int argc, char** argv,
   }
 
   if (argc == 2) {
-    if ((strcmp(argv[1], "-h") == 0) ||
+    if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
-         (strcmp(argv[1], "--help") == 0)) {
       PrintHelpMessage(argv[0]);
       exit(0);
     }
@@ -241,8 +229,7 @@ void ParseArgs(const int argc, char** argv,
       PrintHelpForPSM();
       exit(0);
     }
-    if ((strcmp(argv[1], "-v") == 0) ||
+    if ((strcmp(argv[1], "-v") == 0) || (strcmp(argv[1], "--version") == 0)) {
-         (strcmp(argv[1], "--version") == 0)) {
       PrintVersionInfo();
       exit(0);
     }
@@ -298,10 +285,10 @@ void ParseArgs(const int argc, char** argv,
   }
 }
 
-void PreloadRenderers(tesseract::TessBaseAPI* api,
+void PreloadRenderers(
+    tesseract::TessBaseAPI* api,
     tesseract::PointerVector<tesseract::TessResultRenderer>* renderers,
-          tesseract::PageSegMode pagesegmode,
+    tesseract::PageSegMode pagesegmode, const char* outputbase) {
-          const char* outputbase) {
   if (pagesegmode == tesseract::PSM_OSD_ONLY) {
     renderers->push_back(new tesseract::TessOsdRenderer(outputbase));
   } else {
@@ -324,8 +311,8 @@ void PreloadRenderers(tesseract::TessBaseAPI* api,
 
     api->GetBoolVariable("tessedit_create_pdf", &b);
     if (b) {
-      renderers->push_back(new tesseract::TessPDFRenderer(outputbase,
+      renderers->push_back(
-                                                        api->GetDatapath()));
+          new tesseract::TessPDFRenderer(outputbase, api->GetDatapath()));
     }
 
     api->GetBoolVariable("tessedit_write_unlv", &b);
@@ -359,7 +346,6 @@ void PreloadRenderers(tesseract::TessBaseAPI* api,
  *
  **********************************************************************/
 
-
 int main(int argc, char** argv) {
   const char* lang = "eng";
   const char* image = NULL;
@@ -380,10 +366,8 @@ int main(int argc, char **argv) {
   TIFFSetWarningHandler(Win32WarningHandler);
 #endif /* HAVE_TIFFIO_H &&  _WIN32 */
 
-  ParseArgs(argc, argv,
+  ParseArgs(argc, argv, &lang, &image, &outputbase, &datapath, &list_langs,
-          &lang, &image, &outputbase, &datapath,
+            &print_parameters, &vars_vec, &vars_values, &arg_i, &pagesegmode);
-          &list_langs, &print_parameters,
-          &vars_vec, &vars_values, &arg_i, &pagesegmode);
 
   bool banner = false;
   if (outputbase != NULL && strcmp(outputbase, "-") &&
@@ -396,8 +380,9 @@ int main(int argc, char **argv) {
 
   api.SetOutputName(outputbase);
 
-  int init_failed = api.Init(datapath, lang, tesseract::OEM_DEFAULT,
+  int init_failed =
-                &(argv[arg_i]), argc - arg_i, &vars_vec, &vars_values, false);
+      api.Init(datapath, lang, tesseract::OEM_DEFAULT, &(argv[arg_i]),
+               argc - arg_i, &vars_vec, &vars_values, false);
   if (init_failed) {
     fprintf(stderr, "Could not initialize tesseract.\n");
     exit(1);
@@ -439,7 +424,8 @@ int main(int argc, char **argv) {
     tesseract::PageIterator* it = api.AnalyseLayout();
     if (it) {
       it->Orientation(&orientation, &direction, &order, &deskew_angle);
-      tprintf("Orientation: %d\nWritingDirection: %d\nTextlineOrder: %d\n" \
+      tprintf(
+          "Orientation: %d\nWritingDirection: %d\nTextlineOrder: %d\n"
           "Deskew angle: %.4f\n",
           orientation, direction, order, deskew_angle);
     } else {
@@ -462,8 +448,6 @@ int main(int argc, char **argv) {
 
   tesseract::PointerVector<tesseract::TessResultRenderer> renderers;
 
-
-
   if (in_training_mode) {
     renderers.push_back(NULL);
   } else {

ccmain/control.cpp

@@ -73,7 +73,6 @@ void Tesseract::recog_pseudo_word(PAGE_RES* page_res,
   }
 }
 
-
 /**
  * Recognize a single word in interactive mode.
  *
@@ -539,7 +538,7 @@ void Tesseract::bigram_correction_pass(PAGE_RES *page_res) {
         }
       }
     }
-    if (overrides_word1.size() >= 1) {
+    if (!overrides_word1.empty()) {
       // Excellent, we have some bigram matches.
       if (EqualIgnoringCaseAndTerminalPunct(*w_prev->best_choice,
                                             *overrides_word1[best_idx]) &&

ccmain/docqual.cpp

@@ -98,8 +98,8 @@ void Tesseract::word_char_quality(WERD_RES *word,
                                   ROW *row,
                                   inT16 *match_count,
                                   inT16 *accepted_match_count) {
-  if (word->bln_boxes == NULL ||
+  if (word->bln_boxes == NULL || word->rebuild_word == NULL ||
-    word->rebuild_word == NULL || word->rebuild_word->blobs.empty()) {
+      word->rebuild_word->blobs.empty()) {
     *match_count = 0;
     *accepted_match_count = 0;
     return;
@@ -151,7 +151,6 @@ void Tesseract::quality_based_rejection(PAGE_RES_IT &page_res_it,
   }
 }
 
-
 /*************************************************************************
  * unrej_good_quality_words()
  * Accept potential rejects in words which pass the following checks:
@@ -403,7 +402,6 @@ void Tesseract::doc_and_block_rejection(  //reject big chunks
 
 }  // namespace tesseract
 
-
 /*************************************************************************
  * reject_whole_page()
  * Don't believe any of it - set the reject map to 00..00 in all words

ccmain/fixspace.cpp

@@ -211,7 +211,6 @@ void Tesseract::match_current_words(WERD_RES_LIST &words, ROW *row,
   }
 }
 
-
 /**
  * @name eval_word_spacing()
  * The basic measure is the number of characters in contextually confirmed

ccmain/ltrresultiterator.cpp

@@ -145,11 +145,10 @@ float LTRResultIterator::Confidence(PageIteratorLevel level) const {
   return 0.0f;
 }
 
-void LTRResultIterator::RowAttributes(float* row_height,
+void LTRResultIterator::RowAttributes(float* row_height, float* descenders,
-                                      float* descenders,
                                       float* ascenders) const {
-    *row_height = it_->row()->row->x_height() + it_->row()-> row->ascenders()
+  *row_height = it_->row()->row->x_height() + it_->row()->row->ascenders() -
-                  - it_->row()->row->descenders();
+                it_->row()->row->descenders();
   *descenders = it_->row()->row->descenders();
   *ascenders = it_->row()->row->ascenders();
 }

ccmain/ltrresultiterator.h

@@ -92,8 +92,7 @@ class TESS_API LTRResultIterator : public PageIterator {
   float Confidence(PageIteratorLevel level) const;
 
   // Returns the attributes of the current row.
-  void RowAttributes(float* row_height,
+  void RowAttributes(float* row_height, float* descenders,
-                     float* descenders,
                      float* ascenders) const;
 
   // ============= Functions that refer to words only ============.

ccmain/output.cpp

@@ -78,17 +78,15 @@ void Tesseract::output_pass(  //Tess output pass //send to api
   while (page_res_it.word () != NULL) {
     check_debug_pt (page_res_it.word (), 120);
 
-	if (target_word_box)
+    if (target_word_box) {
-	{
-
       TBOX current_word_box = page_res_it.word()->word->bounding_box();
-		FCOORD center_pt((current_word_box.right()+current_word_box.left())/2,(current_word_box.bottom()+current_word_box.top())/2);
+      FCOORD center_pt(
-		if (!target_word_box->contains(center_pt))
+          (current_word_box.right() + current_word_box.left()) / 2,
-		{
+          (current_word_box.bottom() + current_word_box.top()) / 2);
+      if (!target_word_box->contains(center_pt)) {
         page_res_it.forward();
         continue;
       }
-
     }
     if (tessedit_write_block_separators &&
     block_of_last_word != page_res_it.block ()) {

ccmain/pagesegmain.cpp

@@ -412,7 +412,8 @@ ColumnFinder* Tesseract::SetupPageSegAndDetectOrientation(
                   "Don't rotate.\n", osd_margin);
           osd_orientation = 0;
         } else {
-          tprintf("OSD: Weak margin (%.2f) for %d blob text block, "
+          tprintf(
+              "OSD: Weak margin (%.2f) for %d blob text block, "
               "but using orientation anyway: %d\n",
               osd_margin, osd_blobs.length(), osd_orientation);
         }

ccmain/paragraphs.cpp

@@ -2052,7 +2052,7 @@ void ConvertHypothesizedModelRunsToParagraphs(
     bool single_line_paragraph = false;
     SetOfModels models;
     rows[start].NonNullHypotheses(&models);
-    if (models.size() > 0) {
+    if (!models.empty()) {
       model = models[0];
       if (rows[start].GetLineType(model) != LT_BODY)
         single_line_paragraph = true;
@@ -2190,17 +2190,17 @@ void LeftoverSegments(const GenericVector<RowScratchRegisters> &rows,
     SetOfModels models_w_crowns;
     rows[i].StrongHypotheses(&models);
     rows[i].NonNullHypotheses(&models_w_crowns);
-    if (models.empty() && models_w_crowns.size() > 0) {
+    if (models.empty() && !models_w_crowns.empty()) {
       // Crown paragraph.  Is it followed by a modeled line?
       for (int end = i + 1; end < rows.size(); end++) {
         SetOfModels end_models;
         SetOfModels strong_end_models;
         rows[end].NonNullHypotheses(&end_models);
         rows[end].StrongHypotheses(&strong_end_models);
-        if (end_models.size() == 0) {
+        if (end_models.empty()) {
           needs_fixing = true;
           break;
-        } else if (strong_end_models.size() > 0) {
+        } else if (!strong_end_models.empty()) {
           needs_fixing = false;
           break;
         }
@@ -2485,7 +2485,7 @@ void InitializeRowInfo(bool after_recognition,
   info->ltr = ltr >= rtl;
   info->has_leaders = num_leaders > 3;
   info->num_words = werds.size();
-  if (werds.size() > 0) {
+  if (!werds.empty()) {
     WERD_RES *lword = werds[0], *rword = werds[werds.size() - 1];
     info->lword_text = lword->best_choice->unichar_string().string();
     info->rword_text = rword->best_choice->unichar_string().string();
@@ -2538,7 +2538,7 @@ void DetectParagraphs(int debug_level,
 
   // If we're called before text recognition, we might not have
   // tight block bounding boxes, so trim by the minimum on each side.
-  if (row_infos.size() > 0) {
+  if (!row_infos.empty()) {
     int min_lmargin = row_infos[0].pix_ldistance;
     int min_rmargin = row_infos[0].pix_rdistance;
     for (int i = 1; i < row_infos.size(); i++) {

ccmain/paramsd.cpp

@@ -329,13 +329,19 @@ void ParamsEditor::WriteParams(char *filename,
     fclose(fp);
     sprintf (msg_str, "Overwrite file " "%s" "? (Y/N)", filename);
     int a = sv_window_->ShowYesNoDialog(msg_str);
-    if (a == 'n') { return; }  // don't write
+    if (a == 'n') {
+      return;
+    }  // don't write
   }
 
 
   fp = fopen (filename, "wb");  // can we write to it?
   if (fp == NULL) {
-    sv_window_->AddMessage("Can't write to file " "%s" "", filename);
+    sv_window_->AddMessage(
+        "Can't write to file "
+        "%s"
+        "",
+        filename);
     return;
   }
 

ccmain/tesseractclass.cpp

@@ -398,8 +398,8 @@ Tesseract::Tesseract()
                  "Don't suspect dict wds longer than this", this->params()),
       BOOL_MEMBER(suspect_constrain_1Il, false, "UNLV keep 1Il chars rejected",
                   this->params()),
-      double_MEMBER(suspect_rating_per_ch, 999.9, "Don't touch bad rating limit",
+      double_MEMBER(suspect_rating_per_ch, 999.9,
-                    this->params()),
+                    "Don't touch bad rating limit", this->params()),
       double_MEMBER(suspect_accept_rating, -999.9, "Accept good rating limit",
                     this->params()),
       BOOL_MEMBER(tessedit_minimal_rejection, false,
@@ -512,7 +512,6 @@ Tesseract::Tesseract()
                     "Page separator (default is form feed control character)",
                     this->params()),
 
-
       // The following parameters were deprecated and removed from their
       // original
       // locations. The parameters are temporarily kept here to give Tesseract

ccmain/tesseractclass.h

@@ -38,7 +38,6 @@
 
 class BLOB_CHOICE_LIST_CLIST;
 class BLOCK_LIST;
-class CharSamp;
 struct OSResults;
 class PAGE_RES;
 class PAGE_RES_IT;
@@ -98,6 +97,7 @@ namespace tesseract {
 
 class ColumnFinder;
 #ifndef NO_CUBE_BUILD
+class CharSamp;
 class CubeLineObject;
 class CubeObject;
 class CubeRecoContext;
@@ -1010,8 +1010,7 @@ class Tesseract : public Wordrec {
   INT_VAR_H(suspect_level, 99, "Suspect marker level");
   INT_VAR_H(suspect_space_level, 100,
             "Min suspect level for rejecting spaces");
-  INT_VAR_H(suspect_short_words, 2,
+  INT_VAR_H(suspect_short_words, 2, "Don't Suspect dict wds longer than this");
-            "Don't Suspect dict wds longer than this");
   BOOL_VAR_H(suspect_constrain_1Il, false, "UNLV keep 1Il chars rejected");
   double_VAR_H(suspect_rating_per_ch, 999.9, "Don't touch bad rating limit");
   double_VAR_H(suspect_accept_rating, -999.9, "Accept good rating limit");

ccstruct/blobbox.cpp

@@ -31,7 +31,9 @@
 #define PROJECTION_MARGIN 10     //arbitrary
 #define EXTERN
 
-ELISTIZE (BLOBNBOX) ELIST2IZE (TO_ROW) ELISTIZE (TO_BLOCK)
+ELISTIZE(BLOBNBOX)
+ELIST2IZE(TO_ROW)
+ELISTIZE(TO_BLOCK)
 
 // Up to 30 degrees is allowed for rotations of diacritic blobs.
 const double kCosSmallAngle = 0.866;
@@ -176,7 +178,7 @@ void BLOBNBOX::NeighbourGaps(int gaps[BND_COUNT]) const {
     gaps[dir] = MAX_INT16;
     BLOBNBOX* neighbour = neighbours_[dir];
     if (neighbour != NULL) {
-      TBOX n_box = neighbour->bounding_box();
+      const TBOX& n_box = neighbour->bounding_box();
       if (dir == BND_LEFT || dir == BND_RIGHT) {
         gaps[dir] = box.x_gap(n_box);
       } else {

ccstruct/boxread.cpp

@@ -34,8 +34,7 @@ FILE* OpenBoxFile(const STRING& fname) {
   STRING filename = BoxFileName(fname);
   FILE* box_file = NULL;
   if (!(box_file = fopen(filename.string(), "rb"))) {
-    CANTOPENFILE.error("read_next_box", TESSEXIT,
+    CANTOPENFILE.error("read_next_box", TESSEXIT, "Can't open box file %s",
-                       "Can't open box file %s",
                        filename.string());
   }
   return box_file;

ccstruct/boxword.h

@@ -82,9 +82,7 @@ class BoxWord {
   const TBOX& bounding_box() const {
     return bbox_;
   }
-  int length() const {
+  int length() const { return length_; }
-    return length_;
-  }
   const TBOX& BlobBox(int index) const {
     return boxes_[index];
   }

ccstruct/coutln.cpp

@@ -48,8 +48,8 @@ ICOORD C_OUTLINE::step_coords[4] = {
  * @param length length of loop
  */
 
-C_OUTLINE::C_OUTLINE (CRACKEDGE * startpt, ICOORD bot_left, 
+C_OUTLINE::C_OUTLINE(CRACKEDGE* startpt, ICOORD bot_left, ICOORD top_right,
-                      ICOORD top_right, inT16 length)
+                     inT16 length)
     : box(bot_left, top_right), start(startpt->pos), offsets(NULL) {
   inT16 stepindex;               //index to step
   CRACKEDGE *edgept;             //current point
@@ -71,7 +71,6 @@ C_OUTLINE::C_OUTLINE (CRACKEDGE * startpt, ICOORD bot_left,
   }
 }
 
-
 /**
  * @name C_OUTLINE::C_OUTLINE
  *
@@ -300,7 +299,6 @@ inT32 C_OUTLINE::perimeter() const {
   return total_steps;
 }
 
-
 /**
  * @name C_OUTLINE::outer_area
  *
@@ -332,7 +330,6 @@ inT32 C_OUTLINE::outer_area() const {
   return total;
 }
 
-
 /**
  * @name C_OUTLINE::count_transitions
  *
@@ -459,7 +456,6 @@ inT32 C_OUTLINE::count_transitions(inT32 threshold) {
   return total;
 }
 
-
 /**
  * @name C_OUTLINE::operator<
  *
@@ -468,8 +464,7 @@ inT32 C_OUTLINE::count_transitions(inT32 threshold) {
  */
 
 BOOL8
-C_OUTLINE::operator< (const C_OUTLINE & other) const
+C_OUTLINE::operator<(const C_OUTLINE& other) const {
-{
   inT16 count = 0;               //winding count
   ICOORD pos;                    //position of point
   inT32 stepindex;               //index to cstep
@@ -495,7 +490,6 @@ C_OUTLINE::operator< (const C_OUTLINE & other) const
   return count != 0;
 }
 
-
 /**
  * @name C_OUTLINE::winding_number
  *
@@ -534,7 +528,6 @@ inT16 C_OUTLINE::winding_number(ICOORD point) const {
   return count;                  //winding number
 }
 
-
 /**
  * C_OUTLINE::turn_direction
  *
@@ -563,7 +556,6 @@ inT16 C_OUTLINE::turn_direction() const {  //winding number
   return count;                  //winding number
 }
 
-
 /**
  * @name C_OUTLINE::reverse
  *
@@ -586,7 +578,6 @@ void C_OUTLINE::reverse() {  //reverse drection
   }
 }
 
-
 /**
  * @name C_OUTLINE::move
  *
@@ -661,14 +652,27 @@ static void ComputeGradient(const l_uint32* data, int wpl,
                             int x, int y, int width, int height,
                             ICOORD* gradient) {
   const l_uint32* line = data + y * wpl;
-  int pix_x_y = x < width && y < height ?
+  int pix_x_y =
-      GET_DATA_BYTE(const_cast<void*> (reinterpret_cast<const void *>(line)), x) : 255;
+      x < width && y < height
-  int pix_x_prevy = x < width && y > 0 ?
+          ? GET_DATA_BYTE(
-      GET_DATA_BYTE(const_cast<void*> (reinterpret_cast<const void *>(line - wpl)), x) : 255;
+                const_cast<void*>(reinterpret_cast<const void*>(line)), x)
-  int pix_prevx_prevy = x > 0 && y > 0 ?
+          : 255;
-      GET_DATA_BYTE(const_cast<void*> (reinterpret_cast<void const*>(line - wpl)), x - 1) : 255;
+  int pix_x_prevy =
-  int pix_prevx_y = x > 0 && y < height ?
+      x < width && y > 0
-      GET_DATA_BYTE(const_cast<void*> (reinterpret_cast<const void *>(line)), x - 1) : 255;
+          ? GET_DATA_BYTE(
+                const_cast<void*>(reinterpret_cast<const void*>(line - wpl)), x)
+          : 255;
+  int pix_prevx_prevy =
+      x > 0 && y > 0
+          ? GET_DATA_BYTE(
+                const_cast<void*>(reinterpret_cast<void const*>(line - wpl)),
+                x - 1)
+          : 255;
+  int pix_prevx_y =
+      x > 0 && y < height
+          ? GET_DATA_BYTE(
+                const_cast<void*>(reinterpret_cast<const void*>(line)), x - 1)
+          : 255;
   gradient->set_x(pix_x_y + pix_x_prevy - (pix_prevx_y + pix_prevx_prevy));
   gradient->set_y(pix_x_prevy + pix_prevx_prevy - (pix_x_y + pix_prevx_y));
 }
@@ -684,8 +688,10 @@ static bool EvaluateVerticalDiff(const l_uint32* data, int wpl, int diff_sign,
   if (y <= 0 || y >= height)
     return false;
   const l_uint32* line = data + y * wpl;
-  int pixel1 = GET_DATA_BYTE(const_cast<void*> (reinterpret_cast<const void *>(line - wpl)), x);
+  int pixel1 = GET_DATA_BYTE(
-  int pixel2 = GET_DATA_BYTE(const_cast<void*> (reinterpret_cast<const void *>(line)), x);
+      const_cast<void*>(reinterpret_cast<const void*>(line - wpl)), x);
+  int pixel2 =
+      GET_DATA_BYTE(const_cast<void*>(reinterpret_cast<const void*>(line)), x);
   int diff = (pixel2 - pixel1) * diff_sign;
   if (diff > *best_diff) {
     *best_diff = diff;
@@ -705,8 +711,10 @@ static bool EvaluateHorizontalDiff(const l_uint32* line, int diff_sign,
                                    int* best_diff, int* best_sum, int* best_x) {
   if (x <= 0 || x >= width)
     return false;
-  int pixel1 = GET_DATA_BYTE(const_cast<void*> (reinterpret_cast<const void *>(line)), x - 1);
+  int pixel1 = GET_DATA_BYTE(
-  int pixel2 = GET_DATA_BYTE(const_cast<void*> (reinterpret_cast<const void *>(line)), x);
+      const_cast<void*>(reinterpret_cast<const void*>(line)), x - 1);
+  int pixel2 =
+      GET_DATA_BYTE(const_cast<void*>(reinterpret_cast<const void*>(line)), x);
   int diff = (pixel2 - pixel1) * diff_sign;
   if (diff > *best_diff) {
     *best_diff = diff;
@@ -954,8 +962,7 @@ void C_OUTLINE::render_outline(int left, int top, Pix* pix) const {
  */
 
 #ifndef GRAPHICS_DISABLED
-void C_OUTLINE::plot(ScrollView* window,
+void C_OUTLINE::plot(ScrollView* window, ScrollView::Color colour) const {
-                     ScrollView::Color colour) const {
   inT16 stepindex;               // index to cstep
   ICOORD pos;                    // current position
   DIR128 stepdir;                // direction of step
@@ -1016,7 +1023,6 @@ void C_OUTLINE::plot_normed(const DENORM& denorm, ScrollView::Color colour,
 }
 #endif
 
-
 /**
  * @name C_OUTLINE::operator=
  *

ccstruct/mod128.cpp

@@ -86,16 +86,3 @@ DIR128::DIR128(                 //from fcoord
   while (high - low > 1);
   dir = low;
 }
-
-
-/**********************************************************************
- * dir_to_gradient
- *
- * Convert a direction to a vector.
- **********************************************************************/
-
-#if 0 // code is buggy for negative dir and unused
-ICOORD DIR128::vector() const {  //convert to vector
-  return dirtab[dir];            //easy really
-}
-#endif

ccstruct/mod128.h

@@ -77,7 +77,6 @@ class DLLSYM DIR128
     inT8 get_dir() const {  //access function
       return dir;
     }
-    ICOORD vector() const;  //turn to vector
 
   private:
     inT8 dir;                    //a direction

ccstruct/otsuthr.cpp

@@ -56,18 +56,11 @@ int OtsuThreshold(Pix* src_pix, int left, int top, int width, int height,
 
   // Calculate Histogram on GPU
   OpenclDevice od;
-    if (od.selectedDeviceIsOpenCL() &&
+  if (od.selectedDeviceIsOpenCL() && (num_channels == 1 || num_channels == 4) &&
-        (num_channels == 1 || num_channels == 4) && top == 0 && left == 0 ) {
+      top == 0 && left == 0) {
-      od.HistogramRectOCL(
+    od.HistogramRectOCL((const unsigned char*)pixGetData(src_pix), num_channels,
-          (const unsigned char*)pixGetData(src_pix),
+                        pixGetWpl(src_pix) * 4, left, top, width, height,
-          num_channels,
+                        kHistogramSize, histogramAllChannels);
-          pixGetWpl(src_pix) * 4,
-          left,
-          top,
-          width,
-          height,
-          kHistogramSize,
-          histogramAllChannels);
 
     // Calculate Threshold from Histogram on cpu
     for (int ch = 0; ch < num_channels; ++ch) {
@@ -143,7 +136,6 @@ int OtsuThreshold(Pix* src_pix, int left, int top, int width, int height,
   delete[] histogramAllChannels;
 #endif  // USE_OPENCL
 
-
   if (!any_good_hivalue) {
     // Use the best of the ones that were not good enough.
     (*hi_values)[best_hi_index] = best_hi_value;

ccstruct/pageres.h

@@ -630,7 +630,7 @@ class WERD_RES : public ELIST_LINK {
   static WERD_RES* deep_copy(const WERD_RES* src) {
     WERD_RES* result = new WERD_RES(*src);
     // That didn't copy the ratings, but we want a copy if there is one to
-    // begin width.
+    // begin with.
     if (src->ratings != NULL)
       result->ratings = src->ratings->DeepCopy();
     return result;

ccstruct/pdblock.h

@@ -29,8 +29,7 @@ struct Pix;
 
 CLISTIZEH (PDBLK)
 ///page block
-class PDBLK
+class PDBLK {
-{
   friend class BLOCK_RECT_IT;    //< block iterator
 
  public:
@@ -48,21 +47,16 @@ class PDBLK
   /// set vertex lists
   ///@param left list of left vertices
   ///@param right list of right vertices
-    void set_sides(ICOORDELT_LIST *left,
+  void set_sides(ICOORDELT_LIST *left, ICOORDELT_LIST *right);
-                   ICOORDELT_LIST *right);
 
   /// destructor
   ~PDBLK() {
     if (hand_poly) delete hand_poly;
   }
 
-    POLY_BLOCK *poly_block() const {
+  POLY_BLOCK *poly_block() const { return hand_poly; }
-      return hand_poly;
-    }
   /// set the poly block
-    void set_poly_block(POLY_BLOCK *blk) {
+  void set_poly_block(POLY_BLOCK *blk) { hand_poly = blk; }
-      hand_poly = blk;
-    }
   /// get box
   void bounding_box(ICOORD &bottom_left,        // bottom left
                     ICOORD &top_right) const {  // topright
@@ -70,16 +64,10 @@ class PDBLK
     top_right = box.topright();
   }
   /// get real box
-    const TBOX &bounding_box() const {
+  const TBOX &bounding_box() const { return box; }
-      return box;
-    }
 
-    int index() const {
+  int index() const { return index_; }
-      return index_;
+  void set_index(int value) { index_ = value; }
-    }
-    void set_index(int value) {
-      index_ = value;
-    }
 
   /// is pt inside block
   BOOL8 contains(ICOORD pt);
@@ -98,9 +86,7 @@ class PDBLK
   ///@param window window to draw in
   ///@param serial serial number
   ///@param colour colour to draw in
-    void plot(ScrollView* window,
+  void plot(ScrollView *window, inT32 serial, ScrollView::Color colour);
-              inT32 serial,
-              ScrollView::Color colour);
 #endif  // GRAPHICS_DISABLED
 
   /// assignment

ccstruct/ratngs.h

@@ -288,7 +288,8 @@ class WERD_CHOICE : public ELIST_LINK {
                src_certainty, src_permuter);
   }
   WERD_CHOICE(const char *src_string, const UNICHARSET &unicharset);
-  WERD_CHOICE(const WERD_CHOICE &word) : ELIST_LINK(word), unicharset_(word.unicharset_) {
+  WERD_CHOICE(const WERD_CHOICE &word)
+      : ELIST_LINK(word), unicharset_(word.unicharset_) {
     this->init(word.length());
     this->operator=(word);
   }

ccstruct/rejctmap.h

@@ -48,8 +48,7 @@ OF THIS IMPLIED TEMPORAL ORDERING OF THE FLAGS!!!!
 #include          "bits16.h"
 #include                   "params.h"
 
-enum REJ_FLAGS
+enum REJ_FLAGS {
-{
   /* Reject modes which are NEVER overridden */
   R_TESS_FAILURE,    // PERM Tess didn't classify
   R_SMALL_XHT,       // PERM Xht too small

ccstruct/statistc.cpp

@@ -215,7 +215,6 @@ inT32 STATS::min_bucket() const {  // Find min
   return rangemin_ + min;
 }
 
-
 /**********************************************************************
  * STATS::max_bucket
  *

ccutil/clst.cpp

@@ -56,7 +56,6 @@ void (*zapper) (void *)) {       //ptr to zapper functn
   }
 }
 
-
 /***********************************************************************
  *              CLIST::shallow_clear
  *
@@ -107,7 +106,6 @@ void CLIST::assign_to_sublist(                           //to this list
   last = start_it->extract_sublist (end_it);
 }
 
-
 /***********************************************************************
  *              CLIST::length
  *
@@ -123,7 +121,6 @@ inT32 CLIST::length() const {  //count elements
   return count;
 }
 
-
 /***********************************************************************
  *              CLIST::sort
  *
@@ -276,7 +273,6 @@ void *CLIST_ITERATOR::forward() {
   return current->data;
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::data_relative
  *
@@ -312,7 +308,6 @@ void *CLIST_ITERATOR::data_relative(                //get data + or - ...
   return ptr->data;
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::move_to_last()
  *
@@ -336,7 +331,6 @@ void *CLIST_ITERATOR::move_to_last() {
     return current->data;
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::exchange()
  *
@@ -434,7 +428,6 @@ void CLIST_ITERATOR::exchange(                             //positions of 2 link
   other_it->current = old_current;
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::extract_sublist()
  *

ccutil/clst.h

@@ -138,7 +138,8 @@ class DLLSYM CLIST
 /***********************************************************************
  *              CLASS - CLIST_ITERATOR
  *
- *							Generic iterator class for singly linked lists with embedded links
+ *              Generic iterator class for singly linked lists with embedded
+ *links
  **********************************************************************/
 
 class DLLSYM CLIST_ITERATOR
@@ -270,7 +271,6 @@ inline void CLIST_ITERATOR::set_to_list(  //change list
   ex_current_was_cycle_pt = FALSE;
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::CLIST_ITERATOR
  *
@@ -281,7 +281,6 @@ inline CLIST_ITERATOR::CLIST_ITERATOR(CLIST *list_to_iterate) {
   set_to_list(list_to_iterate);
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::add_after_then_move
  *
@@ -329,7 +328,6 @@ inline void CLIST_ITERATOR::add_after_then_move(  // element to add
   current = new_element;
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::add_after_stay_put
  *
@@ -380,7 +378,6 @@ inline void CLIST_ITERATOR::add_after_stay_put(  // element to add
   }
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::add_before_then_move
  *
@@ -425,7 +422,6 @@ inline void CLIST_ITERATOR::add_before_then_move(  // element to add
   current = new_element;
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::add_before_stay_put
  *
@@ -471,11 +467,11 @@ inline void CLIST_ITERATOR::add_before_stay_put(  // element to add
   }
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::add_list_after
  *
- *  Insert another list to this list after the current element but don't move the
+ *  Insert another list to this list after the current element but don't move
+ *the
  *  iterator.
  **********************************************************************/
 
@@ -518,7 +514,6 @@ inline void CLIST_ITERATOR::add_list_after(CLIST *list_to_add) {
   }
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::add_list_before
  *
@@ -563,7 +558,6 @@ inline void CLIST_ITERATOR::add_list_before(CLIST *list_to_add) {
   }
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::extract
  *
@@ -606,7 +600,6 @@ inline void *CLIST_ITERATOR::extract() {
   return extracted_data;
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::move_to_first()
  *
@@ -626,7 +619,6 @@ inline void *CLIST_ITERATOR::move_to_first() {
   return current != NULL ? current->data : NULL;
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::mark_cycle_pt()
  *
@@ -651,7 +643,6 @@ inline void CLIST_ITERATOR::mark_cycle_pt() {
   started_cycling = FALSE;
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::at_first()
  *
@@ -671,7 +662,6 @@ inline BOOL8 CLIST_ITERATOR::at_first() {
     !ex_current_was_last));      //first and last
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::at_last()
  *
@@ -691,7 +681,6 @@ inline BOOL8 CLIST_ITERATOR::at_last() {
     ex_current_was_last));       //first and last
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::cycled_list()
  *
@@ -709,7 +698,6 @@ inline BOOL8 CLIST_ITERATOR::cycled_list() {
 
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::length()
  *
@@ -726,7 +714,6 @@ inline inT32 CLIST_ITERATOR::length() {
   return list->length ();
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::sort()
  *
@@ -747,7 +734,6 @@ const void *, const void *)) {
   move_to_first();
 }
 
-
 /***********************************************************************
  *              CLIST_ITERATOR::add_to_end
  *
@@ -835,42 +821,46 @@ CLISTIZEH_C.
   extern DLLSYM void CLASSNAME##_c1_zapper(             /*delete a link*/  \
                                            void *link); /*link to delete*/ \
                                                                            \
-extern DLLSYM void*			CLASSNAME##_c1_copier(		/*deep copy a link*/	\
+  extern DLLSYM void                                                       \
+      *CLASSNAME##_c1_copier(                    /*deep copy a link*/      \
                              void *old_element); /*source link */
 
 #define CLISTIZEH_B(CLASSNAME)                                              \
                                                                             \
   /***********************************************************************  \
-*							CLASS - CLASSNAME##_CLIST							\
+  *             CLASS -                                                     \
+  *CLASSNAME##_CLIST                                                        \
   *                                                                         \
-*							List class for class CLASSNAME						\
+  *             List class for class                                        \
+  *CLASSNAME                                                                \
   *                                                                         \
   **********************************************************************/   \
                                                                             \
-class DLLSYM				CLASSNAME##_CLIST : public CLIST					\
+  class DLLSYM CLASSNAME##_CLIST : public CLIST {                           \
-{																				\
    public:                                                                  \
     CLASSNAME##_CLIST() : CLIST() {}                                        \
     /* constructor */                                                       \
                                                                             \
     CLASSNAME##_CLIST(                           /* don't construct */      \
                       const CLASSNAME##_CLIST &) /*by initial assign*/      \
-	{ DONT_CONSTRUCT_LIST_BY_COPY.error( QUOTE_IT( CLASSNAME##_CLIST ),			\
+    {                                                                       \
-														ABORT, NULL ); }		\
+      DONT_CONSTRUCT_LIST_BY_COPY.error(QUOTE_IT(CLASSNAME##_CLIST), ABORT, \
+                                        NULL);                              \
+    }                                                                       \
                                                                             \
     void deep_clear() /* delete elements */                                 \
-	{ CLIST::internal_deep_clear( &CLASSNAME##_c1_zapper ); }					\
+    {                                                                       \
+      CLIST::internal_deep_clear(&CLASSNAME##_c1_zapper);                   \
+    }                                                                       \
                                                                             \
     void operator=(/* prevent assign */                                     \
-	const CLASSNAME##_CLIST&)													\
+                   const CLASSNAME##_CLIST &) {                             \
-	{ DONT_ASSIGN_LISTS.error( QUOTE_IT( CLASSNAME##_CLIST ),					\
+      DONT_ASSIGN_LISTS.error(QUOTE_IT(CLASSNAME##_CLIST), ABORT, NULL);    \
-											ABORT, NULL ); }
+    }
 
 #define CLISTIZEH_C(CLASSNAME)                                               \
-																				\
+  }                                                                          \
-};																				\
+  ;                                                                          \
-																				\
-																				\
                                                                              \
   /***********************************************************************   \
   *             CLASS - CLASSNAME##_C_IT                                     \
@@ -883,32 +873,29 @@ void						operator=(					/* prevent assign */	\
   *  class of that class")                                                   \
   **********************************************************************/    \
                                                                              \
-class DLLSYM				CLASSNAME##_C_IT : public CLIST_ITERATOR			\
+  class DLLSYM CLASSNAME##_C_IT : public CLIST_ITERATOR {                    \
-{																				\
    public:                                                                   \
     CLASSNAME##_C_IT() : CLIST_ITERATOR() {}                                 \
                                                                              \
-							CLASSNAME##_C_IT(									\
+    CLASSNAME##_C_IT(CLASSNAME##_CLIST *list) : CLIST_ITERATOR(list) {}      \
-	CLASSNAME##_CLIST*		list):CLIST_ITERATOR(list){}						\
                                                                              \
-	CLASSNAME*			data()												\
+    CLASSNAME *data() { return (CLASSNAME *)CLIST_ITERATOR::data(); }        \
-		{ return (CLASSNAME*) CLIST_ITERATOR::data(); }						\
                                                                              \
-	CLASSNAME*			data_relative(										\
+    CLASSNAME *data_relative(inT8 offset) {                                  \
-	inT8					offset)												\
+      return (CLASSNAME *)CLIST_ITERATOR::data_relative(offset);             \
-		{ return (CLASSNAME*) CLIST_ITERATOR::data_relative( offset ); }		\
+    }                                                                        \
                                                                              \
-	CLASSNAME*			forward()											\
+    CLASSNAME *forward() { return (CLASSNAME *)CLIST_ITERATOR::forward(); }  \
-		{ return (CLASSNAME*) CLIST_ITERATOR::forward(); }					\
                                                                              \
-	CLASSNAME*			extract()											\
+    CLASSNAME *extract() { return (CLASSNAME *)CLIST_ITERATOR::extract(); }  \
-		{ return (CLASSNAME*) CLIST_ITERATOR::extract(); }					\
                                                                              \
-	CLASSNAME*			move_to_first()										\
+    CLASSNAME *move_to_first() {                                             \
-		{ return (CLASSNAME*) CLIST_ITERATOR::move_to_first(); }				\
+      return (CLASSNAME *)CLIST_ITERATOR::move_to_first();                   \
+    }                                                                        \
                                                                              \
-	CLASSNAME*			move_to_last()										\
+    CLASSNAME *move_to_last() {                                              \
-		{ return (CLASSNAME*) CLIST_ITERATOR::move_to_last(); }				\
+      return (CLASSNAME *)CLIST_ITERATOR::move_to_last();                    \
+    }                                                                        \
   };
 
 #define CLISTIZEH(CLASSNAME) \
@@ -929,7 +916,8 @@ CLISTIZEH_C( CLASSNAME )
   *             CLASSNAME##_c1_zapper                                        \
   *                                                                          \
   *  A function which can delete a CLASSNAME element.  This is passed to the \
-*  generic deep_clear list member function so that when a list is cleared the	\
+  *  generic deep_clear list member function so that when a list is cleared  \
+  *the                                                                       \
   *  elements on the list are properly destroyed from the base class, even   \
   *  though we don't use a virtual destructor function.                      \
   **********************************************************************/    \
@@ -938,6 +926,6 @@ DLLSYM void					CLASSNAME##_c1_zapper(		/*delete a link*/		\
                                     void *link) /*link to delete*/           \
   {                                                                          \
     delete (CLASSNAME *)link;                                                \
-}																				\
+  }
 
 #endif

ccutil/elst.cpp

@@ -81,7 +81,6 @@ void ELIST::assign_to_sublist(                           //to this list
   last = start_it->extract_sublist (end_it);
 }
 
-
 /***********************************************************************
  *              ELIST::length
  *
@@ -97,7 +96,6 @@ inT32 ELIST::length() const {  // count elements
   return count;
 }
 
-
 /***********************************************************************
  *              ELIST::sort
  *
@@ -224,7 +222,6 @@ ELIST_LINK *ELIST_ITERATOR::forward() {
   return current;
 }
 
-
 /***********************************************************************
  *              ELIST_ITERATOR::data_relative
  *
@@ -260,7 +257,6 @@ ELIST_LINK *ELIST_ITERATOR::data_relative(                //get data + or - ...
   return ptr;
 }
 
-
 /***********************************************************************
  *              ELIST_ITERATOR::move_to_last()
  *
@@ -281,7 +277,6 @@ ELIST_LINK *ELIST_ITERATOR::move_to_last() {
   return current;
 }
 
-
 /***********************************************************************
  *              ELIST_ITERATOR::exchange()
  *
@@ -379,7 +374,6 @@ void ELIST_ITERATOR::exchange(                             //positions of 2 link
   other_it->current = old_current;
 }
 
-
 /***********************************************************************
  *              ELIST_ITERATOR::extract_sublist()
  *

ccutil/elst.h

@@ -458,7 +458,6 @@ inline void ELIST_ITERATOR::add_before_then_move(  // element to add
   current = new_element;
 }
 
-
 /***********************************************************************
  *                          ELIST_ITERATOR::add_before_stay_put
  *
@@ -501,11 +500,11 @@ inline void ELIST_ITERATOR::add_before_stay_put(  // element to add
   }
 }
 
-
 /***********************************************************************
  *                          ELIST_ITERATOR::add_list_after
  *
- *  Insert another list to this list after the current element but don't move the
+ *  Insert another list to this list after the current element but don't move
+ *the
  *  iterator.
  **********************************************************************/
 
@@ -977,7 +976,6 @@ DLLSYM void CLASSNAME##_zapper(ELIST_LINK* link) {                          \
   /* Become a deep copy of src_list*/                                         \
   void CLASSNAME##_LIST::deep_copy(const CLASSNAME##_LIST *src_list,          \
                                    CLASSNAME *(*copier)(const CLASSNAME *)) { \
-                                                                            \
     CLASSNAME##_IT from_it(const_cast<CLASSNAME##_LIST *>(src_list));         \
     CLASSNAME##_IT to_it(this);                                               \
                                                                               \

ccutil/elst2.cpp

@@ -82,7 +82,6 @@ void ELIST2::assign_to_sublist(                            //to this list
   last = start_it->extract_sublist (end_it);
 }
 
-
 /***********************************************************************
  *              ELIST2::length
  *
@@ -98,7 +97,6 @@ inT32 ELIST2::length() const {  // count elements
   return count;
 }
 
-
 /***********************************************************************
  *              ELIST2::sort
  *
@@ -218,7 +216,6 @@ ELIST2_LINK *ELIST2_ITERATOR::forward() {
   return current;
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::backward
  *
@@ -257,7 +254,6 @@ ELIST2_LINK *ELIST2_ITERATOR::backward() {
   return current;
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::data_relative
  *
@@ -289,7 +285,6 @@ ELIST2_LINK *ELIST2_ITERATOR::data_relative(                //get data + or - ..
   return ptr;
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::exchange()
  *
@@ -399,7 +394,6 @@ void ELIST2_ITERATOR::exchange(                              //positions of 2 li
   other_it->current = old_current;
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::extract_sublist()
  *

ccutil/elst2.h

@@ -144,7 +144,8 @@ class DLLSYM ELIST2
 /***********************************************************************
  *              CLASS - ELIST2_ITERATOR
  *
- *							Generic iterator class for doubly linked lists with embedded links
+ *              Generic iterator class for doubly linked lists with embedded
+ *links
  **********************************************************************/
 
 class DLLSYM ELIST2_ITERATOR
@@ -279,7 +280,6 @@ inline void ELIST2_ITERATOR::set_to_list(  //change list
   ex_current_was_cycle_pt = FALSE;
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::ELIST2_ITERATOR
  *
@@ -290,7 +290,6 @@ inline ELIST2_ITERATOR::ELIST2_ITERATOR(ELIST2 *list_to_iterate) {
   set_to_list(list_to_iterate);
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::add_after_then_move
  *
@@ -339,7 +338,6 @@ inline void ELIST2_ITERATOR::add_after_then_move(  // element to add
   current = new_element;
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::add_after_stay_put
  *
@@ -391,7 +389,6 @@ inline void ELIST2_ITERATOR::add_after_stay_put(  // element to add
   }
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::add_before_then_move
  *
@@ -438,7 +435,6 @@ inline void ELIST2_ITERATOR::add_before_then_move(  // element to add
   current = new_element;
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::add_before_stay_put
  *
@@ -486,11 +482,11 @@ inline void ELIST2_ITERATOR::add_before_stay_put(  // element to add
   }
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::add_list_after
  *
- *  Insert another list to this list after the current element but don't move the
+ *  Insert another list to this list after the current element but don't move
+ *the
  *  iterator.
  **********************************************************************/
 
@@ -537,7 +533,6 @@ inline void ELIST2_ITERATOR::add_list_after(ELIST2 *list_to_add) {
   }
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::add_list_before
  *
@@ -586,7 +581,6 @@ inline void ELIST2_ITERATOR::add_list_before(ELIST2 *list_to_add) {
   }
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::extract
  *
@@ -631,7 +625,6 @@ inline ELIST2_LINK *ELIST2_ITERATOR::extract() {
   return extracted_link;
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::move_to_first()
  *
@@ -651,7 +644,6 @@ inline ELIST2_LINK *ELIST2_ITERATOR::move_to_first() {
   return current;
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::move_to_last()
  *
@@ -671,7 +663,6 @@ inline ELIST2_LINK *ELIST2_ITERATOR::move_to_last() {
   return current;
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::mark_cycle_pt()
  *
@@ -696,7 +687,6 @@ inline void ELIST2_ITERATOR::mark_cycle_pt() {
   started_cycling = FALSE;
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::at_first()
  *
@@ -716,7 +706,6 @@ inline BOOL8 ELIST2_ITERATOR::at_first() {
     !ex_current_was_last));      //first and last
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::at_last()
  *
@@ -736,7 +725,6 @@ inline BOOL8 ELIST2_ITERATOR::at_last() {
     ex_current_was_last));       //first and last
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::cycled_list()
  *
@@ -754,7 +742,6 @@ inline BOOL8 ELIST2_ITERATOR::cycled_list() {
 
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::length()
  *
@@ -771,7 +758,6 @@ inline inT32 ELIST2_ITERATOR::length() {
   return list->length ();
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::sort()
  *
@@ -792,7 +778,6 @@ const void *, const void *)) {
   move_to_first();
 }
 
-
 /***********************************************************************
  *              ELIST2_ITERATOR::add_to_end
  *
@@ -881,42 +866,48 @@ ELIST2_LINK*				link);						/*link to delete*/
 #define ELIST2IZEH_B(CLASSNAME)                                            \
                                                                            \
   /*********************************************************************** \
-*							CLASS - CLASSNAME##_LIST																	\
+  *             CLASS -                                                    \
+  *CLASSNAME##_LIST                                                        \
   *                                                                        \
-*							List class for class CLASSNAME															\
+  *             List class for class                                       \
+  *CLASSNAME                                                               \
   *                                                                        \
   **********************************************************************/  \
                                                                            \
-class DLLSYM				CLASSNAME##_LIST : public ELIST2							\
+  class DLLSYM CLASSNAME##_LIST : public ELIST2 {                          \
-{																										\
    public:                                                                 \
     CLASSNAME##_LIST() : ELIST2() {}                                       \
     /* constructor */                                                      \
                                                                            \
     CLASSNAME##_LIST(                          /* don't construct */       \
                      const CLASSNAME##_LIST &) /*by initial assign*/       \
-	{ DONT_CONSTRUCT_LIST_BY_COPY.error( QUOTE_IT( CLASSNAME##_LIST ),      \
+    {                                                                      \
-														ABORT, NULL ); }							\
+      DONT_CONSTRUCT_LIST_BY_COPY.error(QUOTE_IT(CLASSNAME##_LIST), ABORT, \
+                                        NULL);                             \
+    }                                                                      \
                                                                            \
     void clear() /* delete elements */                                     \
-	{ ELIST2::internal_clear( &CLASSNAME##_zapper ); }								\
+    {                                                                      \
+      ELIST2::internal_clear(&CLASSNAME##_zapper);                         \
+    }                                                                      \
                                                                            \
     ~CLASSNAME##_LIST() /* destructor */                                   \
-	{ clear(); }																				\
+    {                                                                      \
+      clear();                                                             \
+    }                                                                      \
                                                                            \
     /* Become a deep copy of src_list*/                                    \
     void deep_copy(const CLASSNAME##_LIST *src_list,                       \
                    CLASSNAME *(*copier)(const CLASSNAME *));               \
                                                                            \
     void operator=(/* prevent assign */                                    \
-	const CLASSNAME##_LIST&)																\
+                   const CLASSNAME##_LIST &) {                             \
-	{ DONT_ASSIGN_LISTS.error( QUOTE_IT( CLASSNAME##_LIST ),						\
+      DONT_ASSIGN_LISTS.error(QUOTE_IT(CLASSNAME##_LIST), ABORT, NULL);    \
-											ABORT, NULL ); }
+    }
 
 #define ELIST2IZEH_C(CLASSNAME)                                                \
-};																										\
+  }                                                                            \
-																										\
+  ;                                                                            \
-																										\
                                                                                \
   /***********************************************************************     \
   *             CLASS - CLASSNAME##_IT                                         \
@@ -929,35 +920,31 @@ void						operator=(					/* prevent assign */	\
   *  class of that class")                                                     \
   **********************************************************************/      \
                                                                                \
-class DLLSYM				CLASSNAME##_IT : public ELIST2_ITERATOR				\
+  class DLLSYM CLASSNAME##_IT : public ELIST2_ITERATOR {                       \
-{																										\
    public:                                                                     \
     CLASSNAME##_IT() : ELIST2_ITERATOR() {}                                    \
                                                                                \
-								CLASSNAME##_IT(												\
+    CLASSNAME##_IT(CLASSNAME##_LIST *list) : ELIST2_ITERATOR(list) {}          \
-CLASSNAME##_LIST*			list):ELIST2_ITERATOR(list){}								\
                                                                                \
-	CLASSNAME*			data()															\
+    CLASSNAME *data() { return (CLASSNAME *)ELIST2_ITERATOR::data(); }         \
-		{ return (CLASSNAME*) ELIST2_ITERATOR::data(); }								\
                                                                                \
-	CLASSNAME*			data_relative(													\
+    CLASSNAME *data_relative(inT8 offset) {                                    \
-	inT8					offset)															\
+      return (CLASSNAME *)ELIST2_ITERATOR::data_relative(offset);              \
-		{ return (CLASSNAME*) ELIST2_ITERATOR::data_relative( offset ); }		\
+    }                                                                          \
                                                                                \
-	CLASSNAME*			forward()														\
+    CLASSNAME *forward() { return (CLASSNAME *)ELIST2_ITERATOR::forward(); }   \
-		{ return (CLASSNAME*) ELIST2_ITERATOR::forward(); }							\
                                                                                \
-	CLASSNAME*			backward()														\
+    CLASSNAME *backward() { return (CLASSNAME *)ELIST2_ITERATOR::backward(); } \
-		{ return (CLASSNAME*) ELIST2_ITERATOR::backward(); }						\
                                                                                \
-	CLASSNAME*			extract()														\
+    CLASSNAME *extract() { return (CLASSNAME *)ELIST2_ITERATOR::extract(); }   \
-		{ return (CLASSNAME*) ELIST2_ITERATOR::extract(); }							\
                                                                                \
-	CLASSNAME*			move_to_first()												\
+    CLASSNAME *move_to_first() {                                               \
-		{ return (CLASSNAME*) ELIST2_ITERATOR::move_to_first(); }					\
+      return (CLASSNAME *)ELIST2_ITERATOR::move_to_first();                    \
+    }                                                                          \
                                                                                \
-	CLASSNAME*			move_to_last()													\
+    CLASSNAME *move_to_last() {                                                \
-		{ return (CLASSNAME*) ELIST2_ITERATOR::move_to_last(); }					\
+      return (CLASSNAME *)ELIST2_ITERATOR::move_to_last();                     \
+    }                                                                          \
   };
 
 #define ELIST2IZEH(CLASSNAME) \
@@ -968,7 +955,6 @@ ELIST2IZEH_B( CLASSNAME )																		\
                               \
   ELIST2IZEH_C(CLASSNAME)
 
-
 /***********************************************************************
   ELIST2IZE( CLASSNAME ) MACRO
 ***********************************************************************/
@@ -993,7 +979,6 @@ delete (CLASSNAME *) link;																	\
   /* Become a deep copy of src_list*/                                         \
   void CLASSNAME##_LIST::deep_copy(const CLASSNAME##_LIST *src_list,          \
                                    CLASSNAME *(*copier)(const CLASSNAME *)) { \
-\
     CLASSNAME##_IT from_it(const_cast<CLASSNAME##_LIST *>(src_list));         \
     CLASSNAME##_IT to_it(this);                                               \
                                                                               \

ccutil/errcode.h

@@ -87,11 +87,10 @@ const ERRCODE ASSERT_FAILED = "Assert failed";
                         __FILE__, __LINE__);                            \
   }
 
-#define ASSERT_HOST_MSG(x, ...) if (!(x))                               \
+#define ASSERT_HOST_MSG(x, ...)                                                \
-  {                                                                     \
+  if (!(x)) {                                                                  \
     tprintf(__VA_ARGS__);                                                      \
-    ASSERT_FAILED.error(#x, ABORT, "in file %s, line %d",               \
+    ASSERT_FAILED.error(#x, ABORT, "in file %s, line %d", __FILE__, __LINE__); \
-                        __FILE__, __LINE__);                            \
   }
 
 void signal_exit(int signal_code);

ccutil/helpers.h

@@ -73,7 +73,7 @@ class TRand {
 
 // Remove newline (if any) at the end of the string.
 inline void chomp_string(char *str) {
-  int last_index = (int)strlen(str) - 1;
+  int last_index = static_cast<int>(strlen(str)) - 1;
   while (last_index >= 0 &&
          (str[last_index] == '\n' || str[last_index] == '\r')) {
     str[last_index--] = '\0';

ccutil/host.h

@@ -59,6 +59,7 @@
  ** of the computer and/or operating system.
  ******************************************************************************/
 
+#include <limits>
 #include "platform.h"
 /* _WIN32 */
 #ifdef _WIN32
@@ -121,15 +122,16 @@ typedef unsigned char BOOL8;
 #define MAX_UINT8 0xff
 #define MAX_UINT16  0xffff
 #define MAX_UINT32  0xffffffff
-#define MAX_FLOAT32 ((float)3.40282347e+38)
+#define MAX_FLOAT32 std::numeric_limits<float>::max()
 
-#define MIN_INT8  0x80
+#define MIN_INT8 static_cast<inT8>(0x80)
-#define MIN_INT16 0x8000
+#define MIN_INT16 static_cast<inT16>(0x8000)
-#define MIN_INT32 static_cast<int>(0x80000000)
+#define MIN_INT32 static_cast<inT32>(0x80000000)
 #define MIN_UINT8 0x00
 #define MIN_UINT16  0x0000
 #define MIN_UINT32  0x00000000
-#define MIN_FLOAT32 ((float)1.17549435e-38)
+// Minimum positive value ie 1e-37ish.
+#define MIN_FLOAT32 std::numeric_limits<float>::min()
 
 // Defines
 #ifndef TRUE

ccutil/ocrclass.h

@@ -110,8 +110,8 @@ typedef struct {                  /*single character */
  * user words found. If it returns true then operation is cancelled.
  **********************************************************************/
 typedef bool (*CANCEL_FUNC)(void* cancel_this, int words);
-typedef bool (*PROGRESS_FUNC)(int progress,
+typedef bool (*PROGRESS_FUNC)(int progress, int left, int right, int top,
-                              int left, int right, int top, int bottom);
+                              int bottom);
 
 class ETEXT_DESC {             // output header
  public:
@@ -126,12 +126,19 @@ class ETEXT_DESC {             // output header
   CANCEL_FUNC cancel;               /// returns true to cancel
   PROGRESS_FUNC progress_callback;  /// called whenever progress increases
   void* cancel_this;                /// this or other data for cancel
-  struct timeval end_time;     /** time to stop. expected to be set only by call
+  struct timeval end_time;          /// Time to stop. Expected to be set only
-                               * to set_deadline_msecs() */
+                                    /// by call to set_deadline_msecs().
   EANYCODE_CHAR text[1];            /// character data
 
-  ETEXT_DESC() : count(0), progress(0), more_to_come(0), ocr_alive(0),
+  ETEXT_DESC()
-                   err_code(0), cancel(NULL), cancel_this(NULL) {
+      : count(0),
+        progress(0),
+        more_to_come(0),
+        ocr_alive(0),
+        err_code(0),
+        cancel(NULL),
+        progress_callback(NULL),
+        cancel_this(NULL) {
     end_time.tv_sec = 0;
     end_time.tv_usec = 0;
   }

ccutil/params.cpp

@@ -31,8 +31,7 @@
 #define EQUAL         '='
 
 tesseract::ParamsVectors *GlobalParams() {
-  static tesseract::ParamsVectors global_params =
+  static tesseract::ParamsVectors global_params = tesseract::ParamsVectors();
-    tesseract::ParamsVectors();
   return &global_params;
 }
 

ccutil/unicharset.h

@@ -181,8 +181,7 @@ class UNICHARSET {
 
   // Return the UNICHAR_ID of a given unichar representation within the
   // UNICHARSET. Only the first length characters from unichar_repr are used.
-  UNICHAR_ID unichar_to_id(const char* const unichar_repr,
+  UNICHAR_ID unichar_to_id(const char* const unichar_repr, int length) const;
-                                 int length) const;
 
   // Return the minimum number of bytes that matches a legal UNICHAR_ID,
   // while leaving the rest of the string encodable. Returns 0 if the

classify/adaptmatch.cpp

@@ -908,8 +908,7 @@ void Classify::AdaptToChar(TBLOB* Blob, CLASS_ID ClassId, int FontinfoId,
 
     NumFeatures = GetAdaptiveFeatures(Blob, IntFeatures, &FloatFeatures);
     if (NumFeatures <= 0) {
-      FreeFeatureSet(FloatFeatures);
+      return;  // Features already freed by GetAdaptiveFeatures.
-      return;
     }
 
     // Only match configs with the matching font.
@@ -1008,8 +1007,6 @@ void Classify::DisplayAdaptedChar(TBLOB* blob, INT_CLASS_STRUCT* int_class) {
 #endif
 }
 
-
-
 /**
  * This routine adds the result of a classification into
  * Results.  If the new rating is much worse than the current

classify/classify.cpp

@@ -151,8 +151,8 @@ Classify::Classify()
       INT_MEMBER(classify_integer_matcher_multiplier, 10,
                  "Integer Matcher Multiplier  0-255:   ", this->params()),
       EnableLearning(true),
-      INT_MEMBER(il1_adaption_test, 0, "Don't adapt to i/I at beginning of word",
+      INT_MEMBER(il1_adaption_test, 0,
-                 this->params()),
+                 "Don't adapt to i/I at beginning of word", this->params()),
       BOOL_MEMBER(classify_bln_numeric_mode, 0,
                   "Assume the input is numbers [0-9].", this->params()),
       double_MEMBER(speckle_large_max_size, 0.30, "Max large speckle size",

classify/cluster.cpp

@@ -437,7 +437,6 @@ MakeClusterer (inT16 SampleSize, const PARAM_DESC ParamDesc[]) {
   return Clusterer;
 }                                // MakeClusterer
 
-
 /**
  * This routine creates a new sample data structure to hold
  * the specified feature.  This sample is added to the clusterer
@@ -490,7 +489,6 @@ SAMPLE* MakeSample(CLUSTERER * Clusterer, const FLOAT32* Feature,
   return (Sample);
 }                                // MakeSample
 
-
 /**
  * This routine first checks to see if the samples in this
  * clusterer have already been clustered before; if so, it does
@@ -523,10 +521,16 @@ LIST ClusterSamples(CLUSTERER *Clusterer, CLUSTERCONFIG *Config) {
 
   //compute prototypes starting at the root node in the tree
   ComputePrototypes(Clusterer, Config);
-  return (Clusterer->ProtoList);
+  // We don't need the cluster pointers in the protos any more, so null them
+  // out, which makes it safe to delete the clusterer.
+  LIST proto_list = Clusterer->ProtoList;
+  iterate(proto_list) {
+    PROTOTYPE *proto = reinterpret_cast<PROTOTYPE *>(first_node(proto_list));
+    proto->Cluster = NULL;
+  }
+  return Clusterer->ProtoList;
 }                                // ClusterSamples
 
-
 /**
  * This routine frees all of the memory allocated to the
  * specified data structure.  It will not, however, free
@@ -558,7 +562,6 @@ void FreeClusterer(CLUSTERER *Clusterer) {
   }
 }                                // FreeClusterer
 
-
 /**
  * This routine frees all of the memory allocated to the
  * specified list of prototypes.  The clusters which are
@@ -572,7 +575,6 @@ void FreeProtoList(LIST *ProtoList) {
   destroy_nodes(*ProtoList, FreePrototype);
 }                                // FreeProtoList
 
-
 /**
  * This routine deallocates the memory consumed by the specified
  * prototype and modifies the corresponding cluster so that it
@@ -606,7 +608,6 @@ void FreePrototype(void *arg) {  //PROTOTYPE     *Prototype)
   memfree(Prototype);
 }                                // FreePrototype
 
-
 /**
  * This routine is used to find all of the samples which
  * belong to a cluster.  It starts by removing the top
@@ -637,7 +638,6 @@ CLUSTER *NextSample(LIST *SearchState) {
   }
 }                                // NextSample
 
-
 /**
  * This routine returns the mean of the specified
  * prototype in the indicated dimension.
@@ -651,7 +651,6 @@ FLOAT32 Mean(PROTOTYPE *Proto, uinT16 Dimension) {
   return (Proto->Mean[Dimension]);
 }                                // Mean
 
-
 /**
  * This routine returns the standard deviation of the
  * prototype in the indicated dimension.
@@ -760,7 +759,6 @@ void CreateClusterTree(CLUSTERER *Clusterer) {
   memfree(context.candidates);
 }                                // CreateClusterTree
 
-
 /**
  * This routine is designed to be used in concert with the
  * KDWalk routine.  It will create a potential cluster for
@@ -786,7 +784,6 @@ void MakePotentialClusters(ClusteringContext *context,
   }
 }                                // MakePotentialClusters
 
-
 /**
  * This routine searches the specified kd-tree for the nearest
  * neighbor of the specified cluster.  It actually uses the
@@ -830,7 +827,6 @@ FindNearestNeighbor(KDTREE * Tree, CLUSTER * Cluster, FLOAT32 * Distance)
   return BestNeighbor;
 }                                // FindNearestNeighbor
 
-
 /**
  * This routine creates a new permanent cluster from the
  * clusters specified in TempCluster.  The 2 clusters in
@@ -872,7 +868,6 @@ CLUSTER *MakeNewCluster(CLUSTERER *Clusterer, TEMPCLUSTER *TempCluster) {
   return Cluster;
 }                                // MakeNewCluster
 
-
 /**
  * This routine merges two clusters into one larger cluster.
  * To do this it computes the number of samples in the new
@@ -921,7 +916,6 @@ inT32 MergeClusters(inT16 N,
   return n;
 }                                // MergeClusters
 
-
 /**
  * This routine decides which clusters in the cluster tree
  * should be represented by prototypes, forms a list of these
@@ -961,7 +955,6 @@ void ComputePrototypes(CLUSTERER *Clusterer, CLUSTERCONFIG *Config) {
   }
 }                                // ComputePrototypes
 
-
 /**
  * This routine attempts to create a prototype from the
  * specified cluster that conforms to the distribution
@@ -1050,7 +1043,6 @@ PROTOTYPE *MakePrototype(CLUSTERER *Clusterer,
   return Proto;
 }                                // MakePrototype
 
-
 /**
  * This routine checks for clusters which are degenerate and
  * therefore cannot be analyzed in a statistically valid way.
@@ -1247,7 +1239,6 @@ PROTOTYPE *MakeSphericalProto(CLUSTERER *Clusterer,
   return (Proto);
 }                                // MakeSphericalProto
 
-
 /**
  * This routine tests the specified cluster to see if it can
  * be approximated by an elliptical normal distribution.  If it
@@ -1286,7 +1277,6 @@ PROTOTYPE *MakeEllipticalProto(CLUSTERER *Clusterer,
   return (Proto);
 }                                // MakeEllipticalProto
 
-
 /**
  * This routine tests each dimension of the specified cluster to
  * see what distribution would best approximate that dimension.
@@ -1355,7 +1345,6 @@ PROTOTYPE *MakeMixedProto(CLUSTERER *Clusterer,
   return (Proto);
 }                                // MakeMixedProto
 
-
 /**
  * This routine alters the ith dimension of the specified
  * mixed prototype to be D_random.
@@ -1380,7 +1369,6 @@ void MakeDimRandom(uinT16 i, PROTOTYPE *Proto, PARAM_DESC *ParamDesc) {
   // note that the proto Weight is irrelevant for D_random protos
 }                                // MakeDimRandom
 
-
 /**
  * This routine alters the ith dimension of the specified
  * mixed prototype to be uniform.
@@ -1410,7 +1398,6 @@ void MakeDimUniform(uinT16 i, PROTOTYPE *Proto, STATISTICS *Statistics) {
   // note that the proto Weight is irrelevant for uniform protos
 }                                // MakeDimUniform
 
-
 /**
  * This routine searches the cluster tree for all leaf nodes
  * which are samples in the specified cluster.  It computes
@@ -1502,7 +1489,6 @@ ComputeStatistics (inT16 N, PARAM_DESC ParamDesc[], CLUSTER * Cluster) {
   return (Statistics);
 }                                // ComputeStatistics
 
-
 /**
  * This routine creates a spherical prototype data structure to
  * approximate the samples in the specified cluster.
@@ -1537,7 +1523,6 @@ PROTOTYPE *NewSphericalProto(uinT16 N,
   return (Proto);
 }                                // NewSphericalProto
 
-
 /**
  * This routine creates an elliptical prototype data structure to
  * approximate the samples in the specified cluster.
@@ -1579,7 +1564,6 @@ PROTOTYPE *NewEllipticalProto(inT16 N,
   return (Proto);
 }                                // NewEllipticalProto
 
-
 /**
  * This routine creates a mixed prototype data structure to
  * approximate the samples in the specified cluster.
@@ -1609,7 +1593,6 @@ PROTOTYPE *NewMixedProto(inT16 N, CLUSTER *Cluster, STATISTICS *Statistics) {
   return (Proto);
 }                                // NewMixedProto
 
-
 /**
  * This routine allocates memory to hold a simple prototype
  * data structure, i.e. one without independent distributions
@@ -1640,7 +1623,6 @@ PROTOTYPE *NewSimpleProto(inT16 N, CLUSTER *Cluster) {
   return (Proto);
 }                                // NewSimpleProto
 
-
 /**
  * This routine returns TRUE if the specified covariance
  * matrix indicates that all N dimensions are independent of
@@ -1692,7 +1674,6 @@ inT16 N, FLOAT32 * CoVariance, FLOAT32 Independence) {
   return (TRUE);
 }                                // Independent
 
-
 /**
  * This routine returns a histogram data structure which can
  * be used by other routines to place samples into histogram
@@ -1739,7 +1720,6 @@ BUCKETS *GetBuckets(CLUSTERER* clusterer,
   return Buckets;
 }                                // GetBuckets
 
-
 /**
  * This routine creates a histogram data structure which can
  * be used by other routines to place samples into histogram
@@ -1840,7 +1820,6 @@ BUCKETS *MakeBuckets(DISTRIBUTION Distribution,
   return Buckets;
 }                                // MakeBuckets
 
-
 /**
  * This routine computes the optimum number of histogram
  * buckets that should be used in a chi-squared goodness of
@@ -1874,7 +1853,6 @@ uinT16 OptimumNumberOfBuckets(uinT32 SampleCount) {
   return kBucketsTable[Last];
 }                                // OptimumNumberOfBuckets
 
-
 /**
  * This routine computes the chi-squared value which will
  * leave a cumulative probability of Alpha in the right tail
@@ -1932,7 +1910,6 @@ ComputeChiSquared (uinT16 DegreesOfFreedom, FLOAT64 Alpha)
 
 }                                // ComputeChiSquared
 
-
 /**
  * This routine computes the probability density function
  * of a discrete normal distribution defined by the global
@@ -1943,7 +1920,8 @@ ComputeChiSquared (uinT16 DegreesOfFreedom, FLOAT64 Alpha)
  * @note Globals:
  *    kNormalMean mean of a discrete normal distribution
  *    kNormalVariance variance of a discrete normal distribution
- *		kNormalMagnitude	magnitude of a discrete normal distribution
+ *    kNormalMagnitude  magnitude of a discrete normal
+ *distribution
  * @return  The value of the normal distribution at x.
  * @note Exceptions: None
  * @note History: 6/4/89, DSJ, Created.
@@ -1955,7 +1933,6 @@ FLOAT64 NormalDensity(inT32 x) {
   return kNormalMagnitude * exp(-0.5 * Distance * Distance / kNormalVariance);
 }                                // NormalDensity
 
-
 /**
  * This routine computes the probability density function
  * of a uniform distribution at the specified point.  The
@@ -1974,7 +1951,6 @@ FLOAT64 UniformDensity(inT32 x) {
     return (FLOAT64) 0.0;
 }                                // UniformDensity
 
-
 /**
  * This routine computes a trapezoidal approximation to the
  * integral of a function over a small delta in x.
@@ -1989,7 +1965,6 @@ FLOAT64 Integral(FLOAT64 f1, FLOAT64 f2, FLOAT64 Dx) {
   return (f1 + f2) * Dx / 2.0;
 }                                // Integral
 
-
 /**
  * This routine counts the number of cluster samples which
  * fall within the various histogram buckets in Buckets.  Only
@@ -2071,7 +2046,6 @@ void FillBuckets(BUCKETS *Buckets,
   }
 }                                // FillBuckets
 
-
 /**
  * This routine determines which bucket x falls into in the
  * discrete normal distribution defined by kNormalMean
@@ -2107,7 +2081,6 @@ uinT16 NormalBucket(PARAM_DESC *ParamDesc,
   return (uinT16) floor((FLOAT64) X);
 }                                // NormalBucket
 
-
 /**
  * This routine determines which bucket x falls into in the
  * discrete uniform distribution defined by
@@ -2143,7 +2116,6 @@ uinT16 UniformBucket(PARAM_DESC *ParamDesc,
   return (uinT16) floor((FLOAT64) X);
 }                                // UniformBucket
 
-
 /**
  * This routine performs a chi-square goodness of fit test
  * on the histogram data in the Buckets data structure.  TRUE
@@ -2176,7 +2148,6 @@ BOOL8 DistributionOK(BUCKETS *Buckets) {
     return TRUE;
 }                                // DistributionOK
 
-
 /**
  * This routine frees the memory used by the statistics
  * data structure.
@@ -2192,7 +2163,6 @@ void FreeStatistics(STATISTICS *Statistics) {
   memfree(Statistics);
 }                                // FreeStatistics
 
-
 /**
  * This routine properly frees the memory used by a BUCKETS.
  *
@@ -2204,7 +2174,6 @@ void FreeBuckets(BUCKETS *buckets) {
   Efree(buckets);
 }                                // FreeBuckets
 
-
 /**
  * This routine frees the memory consumed by the specified
  * cluster and all of its subclusters.  This is done by
@@ -2225,7 +2194,6 @@ void FreeCluster(CLUSTER *Cluster) {
   }
 }                                // FreeCluster
 
-
 /**
  * This routine computes the degrees of freedom that should
  * be used in a chi-squared test with the specified number of
@@ -2252,7 +2220,6 @@ uinT16 DegreesOfFreedom(DISTRIBUTION Distribution, uinT16 HistogramBuckets) {
 
 }                                // DegreesOfFreedom
 
-
 /**
  * This routine is used to search a list of histogram data
  * structures to find one with the specified number of
@@ -2272,7 +2239,6 @@ int NumBucketsMatch(void *arg1,    // BUCKETS *Histogram,
 
 }                                // NumBucketsMatch
 
-
 /**
  * This routine is used to search a list for a list node
  * whose contents match Key.  It is called by the list
@@ -2287,7 +2253,6 @@ int ListEntryMatch(void *arg1,    //ListNode
 
 }                                // ListEntryMatch
 
-
 /**
  * This routine multiplies each ExpectedCount histogram entry
  * by NewSampleCount/OldSampleCount so that the histogram
@@ -2313,7 +2278,6 @@ void AdjustBuckets(BUCKETS *Buckets, uinT32 NewSampleCount) {
 
 }                                // AdjustBuckets
 
-
 /**
  * This routine sets the bucket counts in the specified histogram
  * to zero.
@@ -2331,7 +2295,6 @@ void InitBuckets(BUCKETS *Buckets) {
 
 }                                // InitBuckets
 
-
 /**
  * This routine is used to search a list of structures which
  * hold pre-computed chi-squared values for a chi-squared
@@ -2355,7 +2318,6 @@ int AlphaMatch(void *arg1,    //CHISTRUCT                             *ChiStruct
 
 }                                // AlphaMatch
 
-
 /**
  * This routine allocates a new data structure which is used
  * to hold a chi-squared value along with its associated
@@ -2377,7 +2339,6 @@ CHISTRUCT *NewChiStruct(uinT16 DegreesOfFreedom, FLOAT64 Alpha) {
 
 }                                // NewChiStruct
 
-
 /**
  * This routine attempts to find an x value at which Function
  * goes to zero (i.e. a root of the function ).  It will only
@@ -2440,7 +2401,6 @@ void *FunctionParams, FLOAT64 InitialGuess, FLOAT64 Accuracy)
 
 }                                // Solve
 
-
 /**
  * This routine computes the area under a chi density curve
  * from 0 to x, minus the desired area under the curve.  The
@@ -2480,7 +2440,6 @@ FLOAT64 ChiArea(CHISTRUCT *ChiParams, FLOAT64 x) {
 
 }                                // ChiArea
 
-
 /**
  * This routine looks at all samples in the specified cluster.
  * It computes a running estimate of the percentage of the

classify/clusttool.cpp

@@ -28,7 +28,8 @@
 //---------------Global Data Definitions and Declarations--------------------
 #define TOKENSIZE 80         //< max size of tokens read from an input file
 #define MAXSAMPLESIZE 65535  //< max num of dimensions in feature space
-//#define MAXBLOCKSIZE  65535   //< max num of samples in a character (block size)
+//#define MAXBLOCKSIZE  65535   //< max num of samples in a character (block
+// size)
 
 /**
  * This routine reads a single integer from the specified
@@ -315,8 +316,7 @@ FLOAT32* ReadNFloats(FILE * File, uinT16 N, FLOAT32 Buffer[]) {
  * @note Exceptions: None
  * @note History: 6/6/89, DSJ, Created.
  */
-void
+void WriteParamDesc(FILE *File, uinT16 N, const PARAM_DESC ParamDesc[]) {
-WriteParamDesc (FILE * File, uinT16 N, PARAM_DESC ParamDesc[]) {
   int i;
 
   for (i = 0; i < N; i++) {
@@ -446,14 +446,9 @@ void WriteProtoStyle(FILE *File, PROTOSTYLE ProtoStyle) {
  * @note History: 6/12/89, DSJ, Created.
 */
 
-void WriteProtoList(
+void WriteProtoList(FILE *File, uinT16 N, PARAM_DESC ParamDesc[],
-     FILE	*File,
+                    LIST ProtoList, BOOL8 WriteSigProtos,
-     uinT16	N,
+                    BOOL8 WriteInsigProtos) {
-     PARAM_DESC	ParamDesc[],
-     LIST	ProtoList,
-     BOOL8	WriteSigProtos,
-     BOOL8	WriteInsigProtos)
-{
   PROTOTYPE *Proto;
 
   /* write file header */

classify/clusttool.h

@@ -36,7 +36,7 @@ PROTOSTYLE ReadProtoStyle(FILE *File);
 
 FLOAT32 *ReadNFloats (FILE * File, uinT16 N, FLOAT32 Buffer[]);
 
-void WriteParamDesc (FILE * File, uinT16 N, PARAM_DESC ParamDesc[]);
+void WriteParamDesc(FILE *File, uinT16 N, const PARAM_DESC ParamDesc[]);
 
 void WritePrototype(FILE *File, uinT16 N, PROTOTYPE *Proto);
 
@@ -44,12 +44,8 @@ void WriteNFloats (FILE * File, uinT16 N, FLOAT32 Array[]);
 
 void WriteProtoStyle(FILE *File, PROTOSTYLE ProtoStyle);
 
-void WriteProtoList(
+void WriteProtoList(FILE *File, uinT16 N, PARAM_DESC ParamDesc[],
-     FILE	*File,
+                    LIST ProtoList, BOOL8 WriteSigProtos,
-     uinT16	N,
-     PARAM_DESC	ParamDesc[],
-     LIST	ProtoList,
-     BOOL8	WriteSigProtos,
                     BOOL8 WriteInsigProtos);
 
 //--------------Global Data Definitions and Declarations---------------------

classify/fpoint.cpp

@@ -58,5 +58,4 @@ FLOAT32 NormalizedAngleFrom(FPOINT *Point1,
   if (Angle < 0.0 || Angle >= FullScale)
     Angle = 0.0;
   return (Angle);
-
 }

classify/intfx.cpp

@@ -520,7 +520,7 @@ bool ExtractIntFeat(const TBLOB& blob,
   tesseract::Classify::ExtractFeatures(blob, nonlinear_norm,
                                        &bl_features, &cn_features, results,
                                        NULL);
-  if (bl_features.size() == 0 || cn_features.size() == 0 ||
+  if (bl_features.empty() || cn_features.empty() ||
       bl_features.size() > MAX_NUM_INT_FEATURES ||
       cn_features.size() > MAX_NUM_INT_FEATURES) {
     return false;  // Feature extraction failed.

classify/intmatcher.cpp

@@ -295,7 +295,8 @@ class ClassPruner {
       HeapSort(num_classes_, sort_key_, sort_index_);
   }
 
-  /** Prints debug info on the class pruner matches for the pruned classes only. */
+  /** Prints debug info on the class pruner matches for the pruned classes only.
+   */
   void DebugMatch(const Classify& classify,
                   const INT_TEMPLATES_STRUCT* int_templates,
                   const INT_FEATURE_STRUCT* features) const {
@@ -370,8 +371,9 @@ class ClassPruner {
  private:
   /** Array[rounded_classes_] of initial counts for each class. */
   int *class_count_;
-  /// Array[rounded_classes_] of modified counts for each class after normalizing
+  /// Array[rounded_classes_] of modified counts for each class after
-  /// for expected number of features, disabled classes, fragments, and xheights.
+  /// normalizing for expected number of features, disabled classes, fragments,
+  /// and xheights.
   int *norm_count_;
   /** Array[rounded_classes_ +1] of pruned counts that gets sorted */
   int *sort_key_;
@@ -402,8 +404,9 @@ class ClassPruner {
  *                               normalization process (by CLASS_INDEX)
  * @param expected_num_features  Array of expected number of features
  *                               for each class (by CLASS_INDEX)
- * @param results                Sorted Array of pruned classes. Must be an array
+ * @param results                Sorted Array of pruned classes. Must be an
- *                               of size at least int_templates->NumClasses.
+ *                               array of size at least
+ *                               int_templates->NumClasses.
  * @param keep_this
  */
 int Classify::PruneClasses(const INT_TEMPLATES_STRUCT* int_templates,
@@ -606,7 +609,6 @@ int IntegerMatcher::FindGoodProtos(
   return NumGoodProtos;
 }
 
-
 /**
  * FindBadFeatures finds all features with maximum feature-evidence <
  * AdaptFeatureThresh. The list is ordered by increasing feature number.
@@ -701,7 +703,6 @@ void IntegerMatcher::Init(tesseract::IntParam *classify_debug_level) {
   evidence_mult_mask_ = ((1 << kIntEvidenceTruncBits) - 1);
 }
 
-
 /*----------------------------------------------------------------------------
               Private Code
 ----------------------------------------------------------------------------*/
@@ -717,8 +718,6 @@ void ScratchEvidence::ClearFeatureEvidence(const INT_CLASS class_template) {
          class_template->NumConfigs * sizeof(feature_evidence_[0]));
 }
 
-
-
 /**
  * Print debugging information for Configuations
  * @return none
@@ -742,7 +741,6 @@ void IMDebugConfiguration(int FeatureNum,
   cprintf ("\n");
 }
 
-
 /**
  * Print debugging information for Configuations
  * @return none
@@ -916,7 +914,6 @@ int IntegerMatcher::UpdateTablesForFeature(
   return SumOverConfigs;
 }
 
-
 /**
  * Print debugging information for Configuations
  * @return none
@@ -1165,8 +1162,6 @@ void ScratchEvidence::UpdateSumOfProtoEvidences(
   }
 }
 
-
-
 /**
  * Normalize Sum of Proto and Feature Evidence by dividing by the sum of
  * the Feature Lengths and the Proto Lengths for each configuration.
@@ -1180,7 +1175,6 @@ void ScratchEvidence::NormalizeSums(
   }
 }
 
-
 /**
  * Find the best match for the current class and update the Result
  * with the configuration and match rating.

classify/intproto.cpp

@@ -46,9 +46,7 @@
 #include "config_auto.h"
 #endif
 
-using tesseract::FontInfo;
 using tesseract::FontSet;
-using tesseract::FontSpacingInfo;
 
 /* match debug display constants*/
 #define PROTO_PRUNER_SCALE  (4.0)
@@ -326,10 +324,8 @@ int AddIntProto(INT_CLASS Class) {
        Word < Proto->Configs + WERDS_PER_CONFIG_VEC; *Word++ = 0);
 
   return (Index);
-
 }
 
-
 /**
  * This routine adds Proto to the class pruning tables
  * for the specified class in Templates.
@@ -372,7 +368,6 @@ void AddProtoToClassPruner (PROTO Proto, CLASS_ID ClassId,
   }
 }                                /* AddProtoToClassPruner */
 
-
 /**
  * This routine updates the proto pruner lookup tables
  * for Class to include a new proto identified by ProtoId
@@ -432,7 +427,6 @@ void AddProtoToProtoPruner(PROTO Proto, int ProtoId,
   FillPPLinearBits(ProtoSet->ProtoPruner[PRUNER_Y], Index, Y, Pad, debug);
 }                                /* AddProtoToProtoPruner */
 
-
 /**
  * Returns a quantized bucket for the given param shifted by offset,
  * notionally (param + offset) * num_buckets, but clipped and casted to the
@@ -550,7 +544,6 @@ void Classify::ConvertProto(PROTO Proto, int ProtoId, INT_CLASS Class) {
             P->A, P->B, P->C, Class->ProtoLengths[ProtoId]);
 }                                /* ConvertProto */
 
-
 /**
  * This routine converts from the old floating point format
  * to the new integer format.
@@ -635,7 +628,6 @@ void DisplayIntFeature(const INT_FEATURE_STRUCT* Feature, FLOAT32 Evidence) {
   }
 }                                /* DisplayIntFeature */
 
-
 /**
  * This routine renders the specified proto into a
  * global display list.
@@ -720,7 +712,6 @@ void free_int_class(INT_CLASS int_class) {
   Efree(int_class);
 }
 
-
 /**
  * This routine allocates a new set of integer templates
  * initialized to hold 0 classes.
@@ -1218,7 +1209,6 @@ FLOAT32 BucketStart(int Bucket, FLOAT32 Offset, int NumBuckets) {
 
 }                                /* BucketStart */
 
-
 /**
  * This routine returns the parameter value which
  * corresponds to the end of the specified bucket.
@@ -1236,7 +1226,6 @@ FLOAT32 BucketEnd(int Bucket, FLOAT32 Offset, int NumBuckets) {
   return (((FLOAT32) (Bucket + 1) / NumBuckets) - Offset);
 }                                /* BucketEnd */
 
-
 /**
  * This routine fills in the section of a class pruner
  * corresponding to a single x value for a single proto of
@@ -1284,7 +1273,6 @@ void DoFill(FILL_SPEC *FillSpec,
     }
 }                                /* DoFill */
 
-
 /**
  * Return TRUE if the specified table filler is done, i.e.
  * if it has no more lines to fill.
@@ -1306,7 +1294,6 @@ BOOL8 FillerDone(TABLE_FILLER *Filler) {
 
 }                                /* FillerDone */
 
-
 /**
  * This routine sets Bit in each bit vector whose
  * bucket lies within the range Center +- Spread.  The fill
@@ -1349,7 +1336,6 @@ void FillPPCircularBits(uinT32 ParamTable[NUM_PP_BUCKETS][WERDS_PER_PP_VECTOR],
 
 }                                /* FillPPCircularBits */
 
-
 /**
  * This routine sets Bit in each bit vector whose
  * bucket lies within the range Center +- Spread.  The fill
@@ -1516,7 +1502,6 @@ void GetCPPadsForLevel(int Level,
 
 }                                /* GetCPPadsForLevel */
 
-
 /**
  * @param Evidence  evidence value to return color for
  * @return Color which corresponds to specified Evidence value.
@@ -1538,7 +1523,6 @@ ScrollView::Color GetMatchColorFor(FLOAT32 Evidence) {
     return ScrollView::BLUE;
 }                                /* GetMatchColorFor */
 
-
 /**
  * This routine returns (in Fill) the specification of
  * the next line to be filled from Filler.  FillerDone() should
@@ -1589,7 +1573,6 @@ void GetNextFill(TABLE_FILLER *Filler, FILL_SPEC *Fill) {
 
 }                                /* GetNextFill */
 
-
 /**
  * This routine computes a data structure (Filler)
  * which can be used to fill in a rectangle surrounding
@@ -1723,8 +1706,10 @@ void InitTableFiller (FLOAT32 EndPad, FLOAT32 SidePad,
 
       /* translate into bucket positions and deltas */
       Filler->X = Bucket8For(Start.x, XS, NB);
-      Filler->StartDelta = -(inT16) ((Sin / Cos) * 256);
+      Filler->StartDelta = static_cast<inT16>(ClipToRange<int>(
-      Filler->EndDelta = (inT16) ((Cos / Sin) * 256);
+          -IntCastRounded((Sin / Cos) * 256), MIN_INT16, MAX_INT16));
+      Filler->EndDelta = static_cast<inT16>(ClipToRange<int>(
+          IntCastRounded((Cos / Sin) * 256), MIN_INT16, MAX_INT16));
 
       XAdjust = BucketEnd(Filler->X, XS, NB) - Start.x;
       YAdjust = XAdjust * Sin / Cos;
@@ -1787,7 +1772,6 @@ void RenderIntFeature(ScrollView *window, const INT_FEATURE_STRUCT* Feature,
   window->DrawTo(X + Dx, Y + Dy);
 }                                /* RenderIntFeature */
 
-
 /**
  * This routine extracts the parameters of the specified
  * proto from the class description and adds a rendering of

classify/intproto.h

@@ -52,7 +52,7 @@ class FCOORD;
 #define NUM_CP_BUCKETS    24
 #define CLASSES_PER_CP    32
 #define NUM_BITS_PER_CLASS  2
-#define CLASS_PRUNER_CLASS_MASK (~(~0 << NUM_BITS_PER_CLASS))
+#define CLASS_PRUNER_CLASS_MASK (~(~0u << NUM_BITS_PER_CLASS))
 #define CLASSES_PER_CP_WERD (CLASSES_PER_CP / NUM_BITS_PER_CLASS)
 #define PROTOS_PER_PP_WERD  BITS_PER_WERD
 #define BITS_PER_CP_VECTOR  (CLASSES_PER_CP * NUM_BITS_PER_CLASS)

classify/kdtree.cpp

@@ -117,7 +117,8 @@ bool MinK<Key, Value>::insert(Key key, Value value) {
 
 
 //-----------------------------------------------------------------------------
-/** Helper class for searching for the k closest points to query_point in tree. */
+/** Helper class for searching for the k closest points to query_point in tree.
+ */
 class KDTreeSearch {
  public:
   KDTreeSearch(KDTREE* tree, FLOAT32 *query_point, int k_closest);
@@ -241,7 +242,6 @@ void KDStore(KDTREE *Tree, FLOAT32 *Key, void *Data) {
   *PtrToNode = MakeKDNode(Tree, Key, (void *) Data, Level);
 }                                /* KDStore */
 
-
 /**
  * This routine deletes a node from Tree.  The node to be
  * deleted is specified by the Key for the node and the Data
@@ -298,7 +298,6 @@ KDDelete (KDTREE * Tree, FLOAT32 Key[], void *Data) {
   }
 }                                /* KDDelete */
 
-
 /**
  * This routine searches the K-D tree specified by Tree and
  * finds the QuerySize nearest neighbors of Query.  All neighbors
@@ -541,7 +540,6 @@ void Walk(KDTREE *tree, void_proc action, void *context,
     Walk(tree, action, context, sub_tree->Right, NextLevel(tree, level));
 }
 
-
 /** Given a subtree nodes, insert all of its elements into tree. */
 void InsertNodes(KDTREE *tree, KDNODE *nodes) {
   if (nodes == NULL)

classify/mastertrainer.cpp

@@ -362,9 +362,11 @@ bool MasterTrainer::LoadFontInfo(const char* filename) {
     fontinfo.name = font_name;
     fontinfo.properties = 0;
     fontinfo.universal_id = 0;
-    if (tfscanf(fp, "%1024s %i %i %i %i %i\n", font_name,
+    if (tfscanf(fp, "%1024s %i %i %i %i %i\n", font_name, &italic, &bold,
-                &italic, &bold, &fixed, &serif, &fraktur) != 6)
+                &fixed, &serif, &fraktur) != 6) {
+      delete[] font_name;
       continue;
+    }
     fontinfo.properties =
         (italic << 0) +
         (bold << 1) +
@@ -373,6 +375,8 @@ bool MasterTrainer::LoadFontInfo(const char* filename) {
         (fraktur << 4);
     if (!fontinfo_table_.contains(fontinfo)) {
       fontinfo_table_.push_back(fontinfo);
+    } else {
+      delete[] font_name;
     }
   }
   fclose(fp);

classify/mfoutline.cpp

@@ -35,7 +35,8 @@
 ----------------------------------------------------------------------------*/
 
 /*---------------------------------------------------------------------------*/
-/** Convert a blob into a list of MFOUTLINEs (float-based microfeature format). */
+/** Convert a blob into a list of MFOUTLINEs (float-based microfeature format).
+ */
 LIST ConvertBlob(TBLOB *blob) {
   LIST outlines = NIL_LIST;
   return (blob == NULL)
@@ -344,7 +345,6 @@ void ChangeDirection(MFOUTLINE Start, MFOUTLINE End, DIRECTION Direction) {
 
 }                                /* ChangeDirection */
 
-
 /**
  * This routine normalizes each point in Outline by
  * translating it to the specified center and scaling it
@@ -378,7 +378,6 @@ void CharNormalizeOutline(MFOUTLINE Outline, const DENORM& cn_denorm) {
 
 }                                /* CharNormalizeOutline */
 
-
 /**
  * This routine computes the slope from Start to Finish and
  * and then computes the approximate direction of the line

classify/mfx.cpp

@@ -128,7 +128,6 @@ FLOAT32 ComputeOrientation(MFEDGEPT *Start, MFEDGEPT *End) {
   return (Orientation);
 }                                /* ComputeOrientation */
 
-
 /**
  * Convert Outline to MicroFeatures
  * @param Outline         outline to extract micro-features from
@@ -164,7 +163,6 @@ MICROFEATURES ConvertToMicroFeatures(MFOUTLINE Outline,
   return (MicroFeatures);
 }                                /* ConvertToMicroFeatures */
 
-
 /**
  * This routine computes the feature parameters which describe
  * the micro-feature that starts and Start and ends at End.

classify/normfeat.cpp

@@ -33,7 +33,6 @@ FLOAT32 ActualOutlineLength(FEATURE Feature) {
   return (Feature->Params[CharNormLength] * LENGTH_COMPRESSION);
 }
 
-
 /**
  * Return the character normalization feature for a blob.
  *

classify/ocrfeatures.cpp

@@ -66,7 +66,6 @@ void FreeFeature(FEATURE Feature) {
 
 }                                /* FreeFeature */
 
-
 /**
  * Release the memory consumed by the specified feature
  * set.  This routine also frees the memory consumed by the
@@ -85,7 +84,6 @@ void FreeFeatureSet(FEATURE_SET FeatureSet) {
   }
 }                                /* FreeFeatureSet */
 
-
 /**
  * Allocate and return a new feature of the specified
  * type.
@@ -105,7 +103,6 @@ FEATURE NewFeature(const FEATURE_DESC_STRUCT* FeatureDesc) {
 
 }                                /* NewFeature */
 
-
 /**
  * Allocate and return a new feature set large enough to
  * hold the specified number of features.
@@ -124,7 +121,6 @@ FEATURE_SET NewFeatureSet(int NumFeatures) {
 
 }                                /* NewFeatureSet */
 
-
 /**
  * Create a new feature of the specified type and read in
  * the value of its parameters from File.  The extra penalty
@@ -135,7 +131,8 @@ FEATURE_SET NewFeatureSet(int NumFeatures) {
  * @param File open text file to read feature from
  * @param FeatureDesc specifies type of feature to read from File
  * @return New #FEATURE read from File.
- * @note Exceptions: #ILLEGAL_FEATURE_PARAM if text file doesn't match expected format
+ * @note Exceptions: #ILLEGAL_FEATURE_PARAM if text file doesn't match expected
+ * format
  * @note History: Wed May 23 08:53:16 1990, DSJ, Created.
  */
 FEATURE ReadFeature(FILE* File, const FEATURE_DESC_STRUCT* FeatureDesc) {
@@ -153,7 +150,6 @@ FEATURE ReadFeature(FILE *File, const FEATURE_DESC_STRUCT* FeatureDesc) {
   return (Feature);
 }                                /* ReadFeature */
 
-
 /**
  * Create a new feature set of the specified type and read in
  * the features from File.  The correct text representation
@@ -180,7 +176,6 @@ FEATURE_SET ReadFeatureSet(FILE *File, const FEATURE_DESC_STRUCT* FeatureDesc) {
   return (FeatureSet);
 }                                /* ReadFeatureSet */
 
-
 /**
  * Appends a textual representation of Feature to str.
  * This representation is simply a list of the N parameters
@@ -203,7 +198,6 @@ void WriteFeature(FEATURE Feature, STRING* str) {
   *str += "\n";
 }                                /* WriteFeature */
 
-
 /**
  * Write a textual representation of FeatureSet to File.
  * This representation is an integer specifying the number of
@@ -224,7 +218,6 @@ void WriteFeatureSet(FEATURE_SET FeatureSet, STRING* str) {
   }
 }                                /* WriteFeatureSet */
 
-
 /**
  * Write a textual representation of FeatureDesc to File
  * in the old format (i.e. the format used by the clusterer).

classify/shapeclassifier.cpp

@@ -176,7 +176,7 @@ void ShapeClassifier::UnicharPrintResults(
   for (int i = 0; i < results.size(); ++i) {
     tprintf("%g: c_id=%d=%s", results[i].rating, results[i].unichar_id,
             GetUnicharset().id_to_unichar(results[i].unichar_id));
-    if (results[i].fonts.size() != 0) {
+    if (!results[i].fonts.empty()) {
       tprintf(" Font Vector:");
       for (int f = 0; f < results[i].fonts.size(); ++f) {
         tprintf(" %d", results[i].fonts[f].fontinfo_id);

cube/cube_search_object.cpp

@@ -400,7 +400,7 @@ bool CubeSearchObject::ComputeSpaceCosts() {
     float prob = 0.0;
 
     // gap is too small => no space
-    if (gap < min_spc_gap_) {
+    if (gap < min_spc_gap_ || max_spc_gap_ == min_spc_gap_) {
       prob = 0.0;
     } else if (gap > max_spc_gap_) {
       // gap is too big => definite space

cube/hybrid_neural_net_classifier.cpp

@@ -330,7 +330,7 @@ bool HybridNeuralNetCharClassifier::LoadNets(const string &data_file_path,
   // split into lines
   vector<string> str_vec;
   CubeUtils::SplitStringUsing(str, "\r\n", &str_vec);
-  if (str_vec.size() <= 0) {
+  if (str_vec.empty()) {
     return false;
   }
 

cube/word_unigrams.cpp

@@ -163,7 +163,7 @@ int WordUnigrams::Cost(const char_32 *key_str32,
   CubeUtils::SplitStringUsing(key_str, " \t", &words);
 
   // no words => no cost
-  if (words.size() <= 0) {
+  if (words.empty()) {
     return 0;
   }
 

cutil/oldlist.cpp

@@ -206,7 +206,7 @@ void destroy_nodes(LIST list, void_dest destructor) {
     destructor = memfree;
 
   while (list != NIL_LIST) {
-    (*destructor) (first_node (list));
+    if (first_node(list) != NULL) (*destructor)(first_node(list));
     list = pop(list);
   }
 }

dict/context.cpp

@@ -32,27 +32,21 @@ namespace tesseract {
 static const int kMinAbsoluteGarbageWordLength = 10;
 static const float kMinAbsoluteGarbageAlphanumFrac = 0.5f;
 
-const int case_state_table[6][4] = { {
+const int case_state_table[6][4] = {
-                                  /*  0. Beginning of word       */
+    {/*  0. Beginning of word       */
      /*    P   U   L   D                                          */
      /* -1. Error on case           */
-      0, 1, 5, 4
+     0, 1, 5, 4},
-    },
     {/*  1. After initial capital    */
-      0, 3, 2, 4
+     0, 3, 2, 4},
-    },
     {/*  2. After lower case         */
-      0, -1, 2, -1
+     0, -1, 2, -1},
-    },
     {/*  3. After upper case         */
-      0, 3, -1, 4
+     0, 3, -1, 4},
-    },
     {/*  4. After a digit            */
-      0, -1, -1, 4
+     0, -1, -1, 4},
-    },
     {/*  5. After initial lower case */
-      5, -1, 2, -1
+     5, -1, 2, -1},
-    },
 };
 
 int Dict::case_ok(const WERD_CHOICE &word, const UNICHARSET &unicharset) {

dict/dict.cpp

@@ -35,8 +35,7 @@ Dict::Dict(CCUtil* ccutil)
       probability_in_context_(&tesseract::Dict::def_probability_in_context),
       params_model_classify_(NULL),
       ccutil_(ccutil),
-      STRING_MEMBER(user_words_file, "",
+      STRING_MEMBER(user_words_file, "", "A filename of user-provided words.",
-                    "A filename of user-provided words.",
                     getCCUtil()->params()),
       STRING_INIT_MEMBER(user_words_suffix, "",
                          "A suffix of user-provided words located in tessdata.",
@@ -54,26 +53,34 @@ Dict::Dict(CCUtil* ccutil)
                        getCCUtil()->params()),
       BOOL_INIT_MEMBER(load_unambig_dawg, true, "Load unambiguous word dawg.",
                        getCCUtil()->params()),
-      BOOL_INIT_MEMBER(load_punc_dawg, true, "Load dawg with punctuation"
+      BOOL_INIT_MEMBER(load_punc_dawg, true,
-                       " patterns.", getCCUtil()->params()),
+                       "Load dawg with punctuation"
-      BOOL_INIT_MEMBER(load_number_dawg, true, "Load dawg with number"
+                       " patterns.",
-                       " patterns.", getCCUtil()->params()),
+                       getCCUtil()->params()),
-      BOOL_INIT_MEMBER(load_bigram_dawg, true, "Load dawg with special word "
+      BOOL_INIT_MEMBER(load_number_dawg, true,
-                       "bigrams.", getCCUtil()->params()),
+                       "Load dawg with number"
+                       " patterns.",
+                       getCCUtil()->params()),
+      BOOL_INIT_MEMBER(load_bigram_dawg, true,
+                       "Load dawg with special word "
+                       "bigrams.",
+                       getCCUtil()->params()),
       double_MEMBER(xheight_penalty_subscripts, 0.125,
                     "Score penalty (0.1 = 10%) added if there are subscripts "
                     "or superscripts in a word, but it is otherwise OK.",
                     getCCUtil()->params()),
       double_MEMBER(xheight_penalty_inconsistent, 0.25,
                     "Score penalty (0.1 = 10%) added if an xheight is "
-                    "inconsistent.", getCCUtil()->params()),
+                    "inconsistent.",
+                    getCCUtil()->params()),
       double_MEMBER(segment_penalty_dict_frequent_word, 1.0,
                     "Score multiplier for word matches which have good case and"
                     "are frequent in the given language (lower is better).",
                     getCCUtil()->params()),
       double_MEMBER(segment_penalty_dict_case_ok, 1.1,
                     "Score multiplier for word matches that have good case "
-                    "(lower is better).", getCCUtil()->params()),
+                    "(lower is better).",
+                    getCCUtil()->params()),
       double_MEMBER(segment_penalty_dict_case_bad, 1.3125,
                     "Default score multiplier for word matches, which may have "
                     "case issues (lower is better).",
@@ -88,11 +95,13 @@ Dict::Dict(CCUtil* ccutil)
       double_MEMBER(segment_penalty_garbage, 1.50,
                     "Score multiplier for poorly cased strings that are not in"
                     " the dictionary and generally look like garbage (lower is"
-                    " better).", getCCUtil()->params()),
+                    " better).",
+                    getCCUtil()->params()),
       STRING_MEMBER(output_ambig_words_file, "",
                     "Output file for ambiguities found in the dictionary",
                     getCCUtil()->params()),
-      INT_MEMBER(dawg_debug_level, 0, "Set to 1 for general debug info"
+      INT_MEMBER(dawg_debug_level, 0,
+                 "Set to 1 for general debug info"
                  ", to 2 for more details, to 3 to see all the debug messages",
                  getCCUtil()->params()),
       INT_MEMBER(hyphen_debug_level, 0, "Debug level for hyphenated words.",
@@ -109,12 +118,12 @@ Dict::Dict(CCUtil* ccutil)
                     "Certainty threshold for non-dict words",
                     getCCUtil()->params()),
       double_MEMBER(stopper_phase2_certainty_rejection_offset, 1.0,
-                    "Reject certainty offset",
+                    "Reject certainty offset", getCCUtil()->params()),
-                    getCCUtil()->params()),
       INT_MEMBER(stopper_smallword_size, 2,
                  "Size of dict word to be treated as non-dict word",
                  getCCUtil()->params()),
-      double_MEMBER(stopper_certainty_per_char, -0.50, "Certainty to add"
+      double_MEMBER(stopper_certainty_per_char, -0.50,
+                    "Certainty to add"
                     " for each dict char above small word size.",
                     getCCUtil()->params()),
       double_MEMBER(stopper_allowable_character_badness, 3.0,
@@ -130,9 +139,9 @@ Dict::Dict(CCUtil* ccutil)
                   "Deprecated- backward compatibility only",
                   getCCUtil()->params()),
       INT_MEMBER(tessedit_truncate_wordchoice_log, 10,
-                 "Max words to keep in list",
+                 "Max words to keep in list", getCCUtil()->params()),
-                 getCCUtil()->params()),
+      STRING_MEMBER(word_to_debug, "",
-      STRING_MEMBER(word_to_debug, "", "Word for which stopper debug"
+                    "Word for which stopper debug"
                     " information should be printed to stdout",
                     getCCUtil()->params()),
       STRING_MEMBER(word_to_debug_lengths, "",
@@ -152,8 +161,10 @@ Dict::Dict(CCUtil* ccutil)
                     getCCUtil()->params()),
       double_MEMBER(doc_dict_certainty_threshold, -2.25,
                     "Worst certainty for words that can be inserted into the"
-                    "document dictionary", getCCUtil()->params()),
+                    "document dictionary",
-      INT_MEMBER(max_permuter_attempts, 10000, "Maximum number of different"
+                    getCCUtil()->params()),
+      INT_MEMBER(max_permuter_attempts, 10000,
+                 "Maximum number of different"
                  " character choices to consider during permutation."
                  " This limit is especially useful when user patterns"
                  " are specified, since overly generic patterns can result in"
@@ -179,6 +190,7 @@ Dict::Dict(CCUtil* ccutil)
 }
 
 Dict::~Dict() {
+  End();
   if (hyphen_word_ != NULL) delete hyphen_word_;
   if (output_ambig_words_file_ != NULL) fclose(output_ambig_words_file_);
 }

dict/stopper.cpp

@@ -41,7 +41,6 @@
 #pragma warning(disable:4800)  // int/bool warnings
 #endif
 
-using tesseract::ScriptPos;
 /*----------------------------------------------------------------------------
               Private Code
 ----------------------------------------------------------------------------*/

opencl/oclkernels.h

@@ -1092,7 +1092,8 @@ void kernel_ThresholdRectToPix(
                 for ( int c = 0; c < NUM_CHANNELS; c++) {
                     unsigned char pixChan = pixels.s[p*NUM_CHANNELS + c];
                     if (pHi_Values[c] >= 0 && (pixChan > pThresholds[c]) == (pHi_Values[c] == 0)) {
-                        word |=  (((uint)0x80000000) >> ((b*PIXELS_PER_BURST+p)&31));
+                        const uint kTopBit = 0x80000000;
+                        word |=  (kTopBit >> ((b*PIXELS_PER_BURST+p)&31));
                     }
                 }
             }
@@ -1157,7 +1158,8 @@ void kernel_ThresholdRectToPix_OneChan(
 \n#endif\n
                 unsigned char pixChan = pixels.s[idx];
                 if (pHi_Values[0] >= 0 && (pixChan > pThresholds[0]) == (pHi_Values[0] == 0)) {
-                    word |=  (0x80000000 >> ((b*PIXELS_PER_BURST+p)&31));
+                    const uint kTopBit = 0x80000000;
+                    word |=  (kTopBit >> ((b*PIXELS_PER_BURST+p)&31));
                 }
             }
         }

opencl/opencl_device_selection.h

@@ -63,8 +63,10 @@ static ds_status releaseDSProfile(ds_profile* profile, ds_score_release sr) {
     if (profile->devices!=NULL && sr!=NULL) {
       unsigned int i;
       for (i = 0; i < profile->numDevices; i++) {
-        if (profile->devices[i].oclDeviceName) free(profile->devices[i].oclDeviceName);
+        if (profile->devices[i].oclDeviceName)
-        if (profile->devices[i].oclDriverVersion) free(profile->devices[i].oclDriverVersion);
+          free(profile->devices[i].oclDeviceName);
+        if (profile->devices[i].oclDriverVersion)
+          free(profile->devices[i].oclDriverVersion);
         status = sr(profile->devices[i].score);
         if (status != DS_SUCCESS)
           break;

opencl/openclwrapper.h

@@ -10,7 +10,8 @@
 // including CL/cl.h doesn't occur until USE_OPENCL defined below
 
 // platform preprocessor commands
-#if defined( WIN32 ) || defined( __WIN32__ ) || defined( _WIN32 ) || defined( __CYGWIN__ ) || defined( __MINGW32__ )
+#if defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || \
+    defined(__CYGWIN__) || defined(__MINGW32__)
 #define ON_WINDOWS 1
 #define ON_LINUX   0
 #define ON_APPLE   0
@@ -82,7 +83,8 @@
 
 #define PERF_COUNT_END                                                       \
   QueryPerformanceCounter(&time_funct_end);                                  \
-    elapsed_time_sec = (time_funct_end.QuadPart-time_funct_start.QuadPart)/(double)(freq.QuadPart); \
+  elapsed_time_sec = (time_funct_end.QuadPart - time_funct_start.QuadPart) / \
+                     (double)(freq.QuadPart);                                \
   printf(PERF_COUNT_REPORT_STR, funct_name, "total", elapsed_time_sec);
 #else
 #define PERF_COUNT_START(FUNCT_NAME)
@@ -92,7 +94,8 @@
 #if PERF_COUNT_VERBOSE >= 3
 #define PERF_COUNT_SUB(SUB)                                              \
   QueryPerformanceCounter(&time_sub_end);                                \
-    elapsed_time_sec = (time_sub_end.QuadPart-time_sub_start.QuadPart)/(double)(freq.QuadPart); \
+  elapsed_time_sec = (time_sub_end.QuadPart - time_sub_start.QuadPart) / \
+                     (double)(freq.QuadPart);                            \
   printf(PERF_COUNT_REPORT_STR, funct_name, SUB, elapsed_time_sec);      \
   time_sub_start = time_sub_end;
 #else
@@ -114,7 +117,9 @@
 
 #define PERF_COUNT_END                                                    \
   clock_gettime(CLOCK_MONOTONIC, &time_funct_end);                        \
-    elapsed_time_sec = (time_funct_end.tv_sec - time_funct_start.tv_sec)*1.0 + (time_funct_end.tv_nsec - time_funct_start.tv_nsec)/1000000000.0; \
+  elapsed_time_sec =                                                      \
+      (time_funct_end.tv_sec - time_funct_start.tv_sec) * 1.0 +           \
+      (time_funct_end.tv_nsec - time_funct_start.tv_nsec) / 1000000000.0; \
   printf(PERF_COUNT_REPORT_STR, funct_name, "total", elapsed_time_sec);
 #else
 #define PERF_COUNT_START(FUNCT_NAME)
@@ -124,7 +129,9 @@
 #if PERF_COUNT_VERBOSE >= 3
 #define PERF_COUNT_SUB(SUB)                                           \
   clock_gettime(CLOCK_MONOTONIC, &time_sub_end);                      \
-    elapsed_time_sec = (time_sub_end.tv_sec - time_sub_start.tv_sec)*1.0 + (time_sub_end.tv_nsec - time_sub_start.tv_nsec)/1000000000.0; \
+  elapsed_time_sec =                                                  \
+      (time_sub_end.tv_sec - time_sub_start.tv_sec) * 1.0 +           \
+      (time_sub_end.tv_nsec - time_sub_start.tv_nsec) / 1000000000.0; \
   printf(PERF_COUNT_REPORT_STR, funct_name, SUB, elapsed_time_sec);   \
   time_sub_start = time_sub_end;
 #else
@@ -253,12 +260,12 @@ public:
     // OpenCL implementation of Morphology (Hollow = Closed - Open)
     static PIX* pixHollowCL(PIX  *pixd, PIX  *pixs, l_int32  close_hsize, l_int32  close_vsize, l_int32  open_hsize, l_int32  open_vsize, bool reqDataCopy);
 
-    static void pixGetLinesCL(PIX  *pixd, PIX  *pixs,
+    static void pixGetLinesCL(PIX *pixd, PIX *pixs, PIX **pix_vline,
-                                            PIX** pix_vline, PIX** pix_hline,
+                              PIX **pix_hline, PIX **pixClosed,
-                                            PIX** pixClosed, bool  getpixClosed,
+                              bool getpixClosed, l_int32 close_hsize,
-                                            l_int32  close_hsize, l_int32  close_vsize,
+                              l_int32 close_vsize, l_int32 open_hsize,
-                                            l_int32  open_hsize, l_int32  open_vsize,
+                              l_int32 open_vsize, l_int32 line_hsize,
-                                            l_int32  line_hsize, l_int32  line_vsize);
+                              l_int32 line_vsize);
 
     //int InitOpenclAttr( OpenCLEnv * env );
     //int ReleaseKernel( KernelEnv * env );
@@ -279,34 +286,24 @@ public:
     static void FreeOpenclDll();
 #endif
 
-
     inline static int AddKernelConfig( int kCount, const char *kName );
 
     /* for binarization */
-    static int HistogramRectOCL(
+    static int HistogramRectOCL(const unsigned char *imagedata,
-        const unsigned char *imagedata,
+                                int bytes_per_pixel, int bytes_per_line,
-        int bytes_per_pixel,
+                                int left, int top, int width, int height,
-        int bytes_per_line,
+                                int kHistogramSize, int *histogramAllChannels);
-        int left,
-        int top,
-        int width,
-        int height,
-        int kHistogramSize,
-        int *histogramAllChannels);
 
-    static int ThresholdRectToPixOCL(
+    static int ThresholdRectToPixOCL(const unsigned char *imagedata,
-        const unsigned char* imagedata,
+                                     int bytes_per_pixel, int bytes_per_line,
-        int bytes_per_pixel,
-        int bytes_per_line,
                                      const int *thresholds,
-        const int* hi_values,
+                                     const int *hi_values, Pix **pix,
-        Pix** pix,
+                                     int rect_height, int rect_width,
-        int rect_height,
+                                     int rect_top, int rect_left);
-        int rect_width,
-        int rect_top,
-        int rect_left);
 
-    static Pix * pixConvertRGBToGrayOCL( Pix *pix, float weightRed = 0.3, float weightGreen = 0.5, float weightBlue = 0.2 );
+    static Pix *pixConvertRGBToGrayOCL(Pix *pix, float weightRed = 0.3,
+                                       float weightGreen = 0.5,
+                                       float weightBlue = 0.2);
 
     static ds_device getDeviceSelection();
     static ds_device selectedDevice;

textord/alignedblob.cpp

@@ -188,7 +188,7 @@ ScrollView* AlignedBlob::DisplayTabs(const char* window_name,
   gsearch.StartFullSearch();
   BLOBNBOX* bbox;
   while ((bbox = gsearch.NextFullSearch()) != NULL) {
-    TBOX box = bbox->bounding_box();
+    const TBOX& box = bbox->bounding_box();
     int left_x = box.left();
     int right_x = box.right();
     int top_y = box.top();

textord/bbgrid.cpp

@@ -231,7 +231,7 @@ Pix* GridReducedPix(const TBOX& box, int gridsize,
 // Note that the Pix is used upside-down, with (0, 0) being the bottom-left.
 Pix* TraceOutlineOnReducedPix(C_OUTLINE* outline, int gridsize,
                               ICOORD bleft, int* left, int* bottom) {
-  TBOX box = outline->bounding_box();
+  const TBOX& box = outline->bounding_box();
   Pix* pix = GridReducedPix(box, gridsize, bleft, left, bottom);
   int wpl = pixGetWpl(pix);
   l_uint32* data = pixGetData(pix);
@@ -257,7 +257,7 @@ Pix* TraceOutlineOnReducedPix(C_OUTLINE* outline, int gridsize,
 // As TraceOutlineOnReducedPix above, but on a BLOCK instead of a C_OUTLINE.
 Pix* TraceBlockOnReducedPix(BLOCK* block, int gridsize,
                             ICOORD bleft, int* left, int* bottom) {
-  TBOX box = block->bounding_box();
+  const TBOX& box = block->bounding_box();
   Pix* pix = GridReducedPix(box, gridsize, bleft, left, bottom);
   int wpl = pixGetWpl(pix);
   l_uint32* data = pixGetData(pix);

textord/bbgrid.h

@@ -623,7 +623,7 @@ void BBGrid<BBC, BBC_CLIST, BBC_C_IT>::DisplayBoxes(ScrollView* tab_win) {
   gsearch.StartFullSearch();
   BBC* bbox;
   while ((bbox = gsearch.NextFullSearch()) != NULL) {
-    TBOX box = bbox->bounding_box();
+    const TBOX& box = bbox->bounding_box();
     int left_x = box.left();
     int right_x = box.right();
     int top_y = box.top();

textord/ccnontextdetect.cpp

@@ -305,7 +305,7 @@ bool CCNonTextDetect::BlobOverlapsTooMuch(BLOBNBOX* blob, int max_overlaps) {
   // Search the grid to see what intersects it.
   // Setup a Rectangle search for overlapping this blob.
   BlobGridSearch rsearch(this);
-  TBOX box = blob->bounding_box();
+  const TBOX& box = blob->bounding_box();
   rsearch.StartRectSearch(box);
   rsearch.SetUniqueMode(true);
   BLOBNBOX* neighbour;

textord/colpartition.cpp

@@ -918,7 +918,7 @@ void ColPartition::ComputeLimits() {
     for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
       bbox = it.data();
       if (non_leader_count == 0 || bbox->flow() != BTFT_LEADER) {
-        TBOX box = bbox->bounding_box();
+        const TBOX& box = bbox->bounding_box();
         int area = box.area();
         top_stats.add(box.top(), area);
         bottom_stats.add(box.bottom(), area);
@@ -1181,8 +1181,8 @@ bool ColPartition::MarkAsLeaderIfMonospaced() {
       if (best_end == NULL) {
         tprintf("No path\n");
       } else {
-        tprintf("Total cost = %d vs allowed %d\n",
+        tprintf("Total cost = %d vs allowed %d\n", best_end->total_cost(),
-                best_end->total_cost(), blob_count);
+                blob_count);
       }
     }
     delete [] projection;
@@ -2121,7 +2121,7 @@ void ColPartition::RefinePartnersByOverlap(bool upper,
 // Return true if bbox belongs better in this than other.
 bool ColPartition::ThisPartitionBetter(BLOBNBOX* bbox,
                                        const ColPartition& other) {
-  TBOX box = bbox->bounding_box();
+  const TBOX& box = bbox->bounding_box();
   // Margins take priority.
   int left = box.left();
   int right = box.right();

textord/colpartitiongrid.cpp

@@ -86,7 +86,7 @@ void ColPartitionGrid::HandleClick(int x, int y) {
   ColPartition* neighbour;
   FCOORD click(x, y);
   while ((neighbour = radsearch.NextRadSearch()) != NULL) {
-    TBOX nbox = neighbour->bounding_box();
+    const TBOX& nbox = neighbour->bounding_box();
     if (nbox.contains(click)) {
       tprintf("Block box:");
       neighbour->bounding_box().print();
@@ -1037,7 +1037,7 @@ void ColPartitionGrid::ListFindMargins(ColPartitionSet** best_columns,
     ColPartition* part = part_it.data();
     ColPartitionSet* columns = NULL;
     if (best_columns != NULL) {
-      TBOX part_box = part->bounding_box();
+      const TBOX& part_box = part->bounding_box();
       // Get the columns from the y grid coord.
       int grid_x, grid_y;
       GridCoords(part_box.left(), part_box.bottom(), &grid_x, &grid_y);
@@ -1569,7 +1569,7 @@ BlobRegionType ColPartitionGrid::SmoothInOneDirection(
     const TBOX& im_box, const FCOORD& rerotation,
     bool debug, const ColPartition& part, int* best_distance) {
   // Set up a rectangle search bounded by the part.
-  TBOX part_box = part.bounding_box();
+  const TBOX& part_box = part.bounding_box();
   TBOX search_box;
   ICOORD dist_scaling;
   ComputeSearchBoxAndScaling(direction, part_box, gridsize(),
@@ -1619,10 +1619,10 @@ BlobRegionType ColPartitionGrid::SmoothInOneDirection(
         image_bias - htext_score >= kSmoothDecisionMargin &&
         image_bias - vtext_score >= kSmoothDecisionMargin) {
       *best_distance = dists[NPT_IMAGE][0];
-      if (dists[NPT_WEAK_VTEXT].size() > 0 &&
+      if (!dists[NPT_WEAK_VTEXT].empty() &&
           *best_distance > dists[NPT_WEAK_VTEXT][0])
         *best_distance = dists[NPT_WEAK_VTEXT][0];
-      if (dists[NPT_WEAK_HTEXT].size() > 0 &&
+      if (!dists[NPT_WEAK_HTEXT].empty() &&
           *best_distance > dists[NPT_WEAK_HTEXT][0])
         *best_distance = dists[NPT_WEAK_HTEXT][0];
       return BRT_POLYIMAGE;

textord/devanagari_processing.h

@@ -41,9 +41,7 @@ class PixelHistogram {
     length_ = 0;
   }
 
-  int* hist() const {
+  int* hist() const { return hist_; }
-    return hist_;
-  }
 
   int length() const {
     return length_;

textord/drawedg.h

@@ -1,6 +1,7 @@
 /**********************************************************************
  * File:        drawedg.h  (Formerly drawedge.h)
- * Description: Collection of functions to draw things to do with edge detection.
+ * Description: Collection of functions to draw things to do with edge
+ *detection.
  * Author:          Ray Smith
  * Created:         Thu Jun 06 13:29:20 BST 1991
  *

textord/fpchop.cpp

@@ -730,7 +730,6 @@ C_OUTLINE *join_chopped_fragments(                         //join pieces
   return NULL;
 }
 
-
 /**********************************************************************
  * join_segments
  *

textord/imagefind.cpp

@@ -1115,7 +1115,7 @@ static bool TestWeakIntersectedPart(const TBOX& im_box,
                                     ColPartition* part) {
   if (part->flow() < BTFT_STRONG_CHAIN) {
     // A weak partition intersects the box.
-    TBOX part_box = part->bounding_box();
+    const TBOX& part_box = part->bounding_box();
     if (im_box.contains(part_box)) {
       int area = part_box.area();
       int intersect_area = IntersectArea(part_box, part_list);
@@ -1180,7 +1180,7 @@ static bool ScanForOverlappingText(ColPartitionGrid* part_grid, TBOX* box) {
         part->flow() == BTFT_STRONG_CHAIN) {
       // Text intersects the box.
       any_text_in_padded_rect = true;
-      TBOX part_box = part->bounding_box();
+      const TBOX& part_box = part->bounding_box();
       if (box->overlap(part_box)) {
         return true;
       }

textord/makerow.cpp

@@ -1786,7 +1786,7 @@ static int CountOverlaps(const TBOX& box, int min_height,
   BLOBNBOX_IT blob_it(blobs);
   for (blob_it.mark_cycle_pt(); !blob_it.cycled_list(); blob_it.forward()) {
     BLOBNBOX* blob = blob_it.data();
-    TBOX blob_box = blob->bounding_box();
+    const TBOX &blob_box = blob->bounding_box();
     if (blob_box.height() >= min_height && box.major_overlap(blob_box)) {
       ++overlaps;
     }

textord/oldbasel.cpp

@@ -1018,61 +1018,6 @@ int *partcount                   /*no of partitions */
   return bestpart;
 }
 
-
-///*merge_partitions(partids,partcount,blobcount,bestpart) discards funny looking
-//partitions and gives all the rest partid 0*/
-//
-//merge_partitions(partids,partcount,blobcount,bestpart)
-//register char              *partids;                     /*partition numbers*/
-//int                        partcount;                    /*no of partitions*/
-//int                        blobcount;                    /*no of blobs*/
-//int                        bestpart;                     /*best partition*/
-//{
-//   int                     blobindex;                    /*no along text line*/
-//   int                     runlength;                    /*run of same partition*/
-//   int                     bestrun;                      /*biggest runlength*/
-//
-//   bestrun=0;                                            /*no runs yet*/
-//   runlength=1;
-//   for (blobindex=1;blobindex<blobcount;blobindex++)
-//   {  if (partids[blobindex]!=partids[blobindex-1])
-//      {  if (runlength>bestrun)
-//            bestrun=runlength;                           /*find biggest run*/
-//         runlength=1;                                    /*new run*/
-//      }
-//      else
-//      {  runlength++;
-//      }
-//   }
-//   if (runlength>bestrun)
-//      bestrun=runlength;
-//
-//   for (blobindex=0;blobindex<blobcount;blobindex++)
-//   {  if (blobindex<1
-//      || partids[blobindex]!=partids[blobindex-1])
-//      {  if ((blobindex+1>=blobcount
-//         || partids[blobindex]!=partids[blobindex+1])
-//                                                         /*loner*/
-//         && (bestrun>2 || partids[blobindex]!=bestpart))
-//         {  partids[blobindex]=partcount;                /*discard loner*/
-//         }
-//         else if (blobindex+1<blobcount
-//         && partids[blobindex]==partids[blobindex+1]
-//                                                         /*pair*/
-//         && (blobindex+2>=blobcount
-//         || partids[blobindex]!=partids[blobindex+2])
-//         && (bestrun>3 || partids[blobindex]!=bestpart))
-//         {  partids[blobindex]=partcount;                /*discard both*/
-//            partids[blobindex+1]=partcount;
-//         }
-//      }
-//   }
-//   for (blobindex=0;blobindex<blobcount;blobindex++)
-//   {  if (partids[blobindex]<partcount)
-//         partids[blobindex]=0;                           /*all others together*/
-//   }
-//}
-
 /**********************************************************************
  * partition_coords
  *
@@ -1414,7 +1359,6 @@ int bestpart                     /*biggest partition */
   bestneg = 0.0;       /*no step yet */
   for (partition = 0; partition < partcount; partition++) {
     if (partition != bestpart) {
-
       // by jetsoft divide by zero possible
       if (partsizes[partition] == 0)
         partsteps[partition] = 0;
@@ -1422,7 +1366,6 @@ int bestpart                     /*biggest partition */
         partsteps[partition] /= partsizes[partition];
       //
 
-
       if (partsteps[partition] >= MINASCRISE
       && partsizes[partition] > poscount) {
         poscount = partsizes[partition];

textord/strokewidth.cpp

@@ -393,7 +393,7 @@ void StrokeWidth::GradeBlobsIntoPartitions(
 }
 
 static void PrintBoxWidths(BLOBNBOX* neighbour) {
-  TBOX nbox = neighbour->bounding_box();
+  const TBOX& nbox = neighbour->bounding_box();
   tprintf("Box (%d,%d)->(%d,%d): h-width=%.1f, v-width=%.1f p-width=%1.f\n",
           nbox.left(), nbox.bottom(), nbox.right(), nbox.top(),
           neighbour->horz_stroke_width(), neighbour->vert_stroke_width(),
@@ -1939,7 +1939,7 @@ ScrollView* StrokeWidth::DisplayGoodBlobs(const char* window_name,
   gsearch.StartFullSearch();
   BLOBNBOX* bbox;
   while ((bbox = gsearch.NextFullSearch()) != NULL) {
-    TBOX box = bbox->bounding_box();
+    const TBOX& box = bbox->bounding_box();
     int left_x = box.left();
     int right_x = box.right();
     int top_y = box.top();

textord/tabfind.cpp

@@ -229,7 +229,7 @@ void TabFind::GutterWidthAndNeighbourGap(int tab_x, int mean_height,
                                        bbox->flow() == BTFT_TEXT_ON_IMAGE, 0.0,
                                        *gutter_width, box.top(), box.bottom());
   if (gutter_bbox != NULL) {
-    TBOX gutter_box = gutter_bbox->bounding_box();
+    const TBOX& gutter_box = gutter_bbox->bounding_box();
     *gutter_width = left ? tab_x - gutter_box.right()
                         : gutter_box.left() - tab_x;
   }
@@ -261,7 +261,7 @@ void TabFind::GutterWidthAndNeighbourGap(int tab_x, int mean_height,
   int neighbour_edge = left ? RightEdgeForBox(box, true, false)
                             : LeftEdgeForBox(box, true, false);
   if (neighbour != NULL) {
-    TBOX n_box = neighbour->bounding_box();
+    const TBOX& n_box = neighbour->bounding_box();
     if (debug) {
       tprintf("Found neighbour:");
       n_box.print();

textord/tablefind.cpp

@@ -550,7 +550,7 @@ void TableFinder::GroupColumnBlocks(ColSegment_LIST* new_blocks,
   // iterate through the source list
   for (src_it.mark_cycle_pt(); !src_it.cycled_list(); src_it.forward()) {
     ColSegment* src_seg = src_it.data();
-    TBOX src_box = src_seg->bounding_box();
+    const TBOX& src_box = src_seg->bounding_box();
     bool match_found = false;
     // iterate through the destination list to find a matching column block
     for (dest_it.mark_cycle_pt(); !dest_it.cycled_list(); dest_it.forward()) {
@@ -1342,7 +1342,7 @@ void TableFinder::GetTableRegions(ColSegment_LIST* table_columns,
   // create a bool array to hold projection on y-axis
   bool* table_region = new bool[page_height];
   while ((part = gsearch.NextFullSearch()) != NULL) {
-    TBOX part_box = part->bounding_box();
+    const TBOX& part_box = part->bounding_box();
     // reset the projection array
     for (int i = 0; i < page_height; i++) {
       table_region[i] = false;
@@ -1974,7 +1974,7 @@ void TableFinder::DisplayColPartitionConnections(
 
     ColPartition* upper_part = part->nearest_neighbor_above();
     if (upper_part) {
-      TBOX upper_box = upper_part->bounding_box();
+      const TBOX& upper_box = upper_part->bounding_box();
       int mid_x = (left_x + right_x) / 2;
       int mid_y = (top_y + bottom_y) / 2;
       int other_x = (upper_box.left() + upper_box.right()) / 2;
@@ -1985,7 +1985,7 @@ void TableFinder::DisplayColPartitionConnections(
     }
     ColPartition* lower_part = part->nearest_neighbor_below();
     if (lower_part) {
-      TBOX lower_box = lower_part->bounding_box();
+      const TBOX& lower_box = lower_part->bounding_box();
       int mid_x = (left_x + right_x) / 2;
       int mid_y = (top_y + bottom_y) / 2;
       int other_x = (lower_box.left() + lower_box.right()) / 2;
@@ -2098,7 +2098,7 @@ void TableFinder::MakeTableBlocks(ColPartitionGrid* grid,
   table_search.StartFullSearch();
   ColSegment* table;
   while ((table = table_search.NextFullSearch()) != NULL) {
-    TBOX table_box = table->bounding_box();
+    const TBOX& table_box = table->bounding_box();
     // Start a rect search on table_box
     GridSearch<ColPartition, ColPartition_CLIST, ColPartition_C_IT>
         rectsearch(grid);

textord/tabvector.cpp

@@ -435,7 +435,7 @@ bool TabVector::SimilarTo(const ICOORD& vertical,
     vsearch.StartVerticalSearch(left, right, top_y);
     BLOBNBOX* blob;
     while ((blob = vsearch.NextVerticalSearch(true)) != NULL) {
-      TBOX box = blob->bounding_box();
+      const TBOX& box = blob->bounding_box();
       if (box.top() > bottom_y)
         return true;  // Nothing found.
       if (box.bottom() < top_y)
@@ -523,11 +523,11 @@ const char* kAlignmentNames[] = {
 
 // Print basic information about this tab vector.
 void TabVector::Print(const char* prefix) {
-  tprintf("%s %s (%d,%d)->(%d,%d) w=%d s=%d, sort key=%d, boxes=%d,"
+  tprintf(
+      "%s %s (%d,%d)->(%d,%d) w=%d s=%d, sort key=%d, boxes=%d,"
       " partners=%d\n",
-          prefix, kAlignmentNames[alignment_],
+      prefix, kAlignmentNames[alignment_], startpt_.x(), startpt_.y(),
-          startpt_.x(), startpt_.y(), endpt_.x(), endpt_.y(),
+      endpt_.x(), endpt_.y(), mean_width_, percent_score_, sort_key_,
-          mean_width_, percent_score_, sort_key_,
       boxes_.length(), partners_.length());
 }
 
@@ -806,7 +806,7 @@ bool TabVector::Fit(ICOORD vertical, bool force_parallel) {
     // Fit a line to all the boxes in the list.
     for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
       BLOBNBOX* bbox = it.data();
-      TBOX box = bbox->bounding_box();
+      const TBOX& box = bbox->bounding_box();
       int x1 = IsRightTab() ? box.right() : box.left();
       ICOORD boxpt(x1, box.bottom());
       linepoints.Add(boxpt);
@@ -831,7 +831,7 @@ bool TabVector::Fit(ICOORD vertical, bool force_parallel) {
   int width_count = 0;
   for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
     BLOBNBOX* bbox = it.data();
-    TBOX box = bbox->bounding_box();
+    const TBOX& box = bbox->bounding_box();
     mean_width_ += box.width();
     ++width_count;
     int x1 = IsRightTab() ? box.right() : box.left();

textord/textord.cpp

@@ -33,7 +33,8 @@
 namespace tesseract {
 
 Textord::Textord(CCStruct* ccstruct)
-    : ccstruct_(ccstruct), use_cjk_fp_model_(false),
+    : ccstruct_(ccstruct),
+      use_cjk_fp_model_(false),
       // makerow.cpp ///////////////////////////////////////////
       BOOL_MEMBER(textord_single_height_mode, false,
                   "Script has no xheight, so use a single mode",
@@ -46,24 +47,20 @@ Textord::Textord(CCStruct* ccstruct)
                   "old_to_method.",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_only_use_prop_rows, true,
-                  "Block stats to use fixed pitch rows?",
+                  "Block stats to use fixed pitch rows?", ccstruct_->params()),
-                  ccstruct_->params()),
       BOOL_MEMBER(tosp_force_wordbreak_on_punct, false,
                   "Force word breaks on punct to break long lines in non-space "
                   "delimited langs",
                   ccstruct_->params()),
-      BOOL_MEMBER(tosp_use_pre_chopping, false,
+      BOOL_MEMBER(tosp_use_pre_chopping, false, "Space stats use prechopping?",
-                  "Space stats use prechopping?",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_old_to_bug_fix, false, "Fix suspected bug in old code",
                   ccstruct_->params()),
-      BOOL_MEMBER(tosp_block_use_cert_spaces, true,
+      BOOL_MEMBER(tosp_block_use_cert_spaces, true, "Only stat OBVIOUS spaces",
-                  "Only stat OBVIOUS spaces",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_row_use_cert_spaces, true, "Only stat OBVIOUS spaces",
                   ccstruct_->params()),
-      BOOL_MEMBER(tosp_narrow_blobs_not_cert, true,
+      BOOL_MEMBER(tosp_narrow_blobs_not_cert, true, "Only stat OBVIOUS spaces",
-            "Only stat OBVIOUS spaces",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_row_use_cert_spaces1, true, "Only stat OBVIOUS spaces",
                   ccstruct_->params()),
@@ -78,30 +75,24 @@ Textord::Textord(CCStruct* ccstruct)
                   "Don't restrict kn->sp fuzzy limit to tables",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_stats_use_xht_gaps, true,
-                  "Use within xht gap for wd breaks",
+                  "Use within xht gap for wd breaks", ccstruct_->params()),
-                  ccstruct_->params()),
       BOOL_MEMBER(tosp_use_xht_gaps, true, "Use within xht gap for wd breaks",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_only_use_xht_gaps, false,
-                  "Only use within xht gap for wd breaks",
+                  "Only use within xht gap for wd breaks", ccstruct_->params()),
-                  ccstruct_->params()),
       BOOL_MEMBER(tosp_rule_9_test_punct, false,
-                  "Don't chng kn to space next to punct",
+                  "Don't chng kn to space next to punct", ccstruct_->params()),
-                  ccstruct_->params()),
       BOOL_MEMBER(tosp_flip_fuzz_kn_to_sp, true, "Default flip",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_flip_fuzz_sp_to_kn, true, "Default flip",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_improve_thresh, false, "Enable improvement heuristic",
                   ccstruct_->params()),
-      INT_MEMBER(tosp_debug_level, 0, "Debug data",
+      INT_MEMBER(tosp_debug_level, 0, "Debug data", ccstruct_->params()),
-                 ccstruct_->params()),
       INT_MEMBER(tosp_enough_space_samples_for_median, 3,
-           "or should we use mean",
+                 "or should we use mean", ccstruct_->params()),
-                 ccstruct_->params()),
       INT_MEMBER(tosp_redo_kern_limit, 10,
-                 "No.samples reqd to reestimate for row",
+                 "No.samples reqd to reestimate for row", ccstruct_->params()),
-                 ccstruct_->params()),
       INT_MEMBER(tosp_few_samples, 40,
                  "No.gaps reqd with 1 large gap to treat as a table",
                  ccstruct_->params()),
@@ -114,30 +105,24 @@ Textord::Textord(CCStruct* ccstruct)
                     "Factor for defining space threshold in terms of space and "
                     "kern sizes",
                     ccstruct_->params()),
-      double_MEMBER(tosp_threshold_bias1, 0,
+      double_MEMBER(tosp_threshold_bias1, 0, "how far between kern and space?",
-                    "how far between kern and space?",
                     ccstruct_->params()),
-      double_MEMBER(tosp_threshold_bias2, 0,
+      double_MEMBER(tosp_threshold_bias2, 0, "how far between kern and space?",
-                    "how far between kern and space?",
                     ccstruct_->params()),
       double_MEMBER(tosp_narrow_fraction, 0.3, "Fract of xheight for narrow",
                     ccstruct_->params()),
       double_MEMBER(tosp_narrow_aspect_ratio, 0.48,
-                    "narrow if w/h less than this",
+                    "narrow if w/h less than this", ccstruct_->params()),
-                    ccstruct_->params()),
       double_MEMBER(tosp_wide_fraction, 0.52, "Fract of xheight for wide",
                     ccstruct_->params()),
       double_MEMBER(tosp_wide_aspect_ratio, 0.0, "wide if w/h less than this",
                     ccstruct_->params()),
       double_MEMBER(tosp_fuzzy_space_factor, 0.6,
-                    "Fract of xheight for fuzz sp",
+                    "Fract of xheight for fuzz sp", ccstruct_->params()),
-                    ccstruct_->params()),
       double_MEMBER(tosp_fuzzy_space_factor1, 0.5,
-                    "Fract of xheight for fuzz sp",
+                    "Fract of xheight for fuzz sp", ccstruct_->params()),
-                    ccstruct_->params()),
       double_MEMBER(tosp_fuzzy_space_factor2, 0.72,
-                    "Fract of xheight for fuzz sp",
+                    "Fract of xheight for fuzz sp", ccstruct_->params()),
-                    ccstruct_->params()),
       double_MEMBER(tosp_gap_factor, 0.83, "gap ratio to flip sp->kern",
                     ccstruct_->params()),
       double_MEMBER(tosp_kern_gap_factor1, 2.0, "gap ratio to flip kern->sp",
@@ -156,14 +141,11 @@ Textord::Textord(CCStruct* ccstruct)
                     "Fract of kerns reqd for isolated row stats",
                     ccstruct_->params()),
       double_MEMBER(tosp_table_kn_sp_ratio, 2.25,
-                    "Min difference of kn & sp in table",
+                    "Min difference of kn & sp in table", ccstruct_->params()),
-                    ccstruct_->params()),
       double_MEMBER(tosp_table_xht_sp_ratio, 0.33,
-                    "Expect spaces bigger than this",
+                    "Expect spaces bigger than this", ccstruct_->params()),
-                    ccstruct_->params()),
       double_MEMBER(tosp_table_fuzzy_kn_sp_ratio, 3.0,
-                    "Fuzzy if less than this",
+                    "Fuzzy if less than this", ccstruct_->params()),
-                    ccstruct_->params()),
       double_MEMBER(tosp_fuzzy_kn_fraction, 0.5, "New fuzzy kn alg",
                     ccstruct_->params()),
       double_MEMBER(tosp_fuzzy_sp_fraction, 0.5, "New fuzzy sp alg",
@@ -172,20 +154,16 @@ Textord::Textord(CCStruct* ccstruct)
                     "Don't trust spaces less than this time kn",
                     ccstruct_->params()),
       double_MEMBER(tosp_init_guess_kn_mult, 2.2,
-                    "Thresh guess - mult kn by this",
+                    "Thresh guess - mult kn by this", ccstruct_->params()),
-                    ccstruct_->params()),
       double_MEMBER(tosp_init_guess_xht_mult, 0.28,
-                    "Thresh guess - mult xht by this",
+                    "Thresh guess - mult xht by this", ccstruct_->params()),
-                    ccstruct_->params()),
       double_MEMBER(tosp_max_sane_kn_thresh, 5.0,
-                    "Multiplier on kn to limit thresh",
+                    "Multiplier on kn to limit thresh", ccstruct_->params()),
-                    ccstruct_->params()),
       double_MEMBER(tosp_flip_caution, 0.0,
                     "Don't autoflip kn to sp when large separation",
                     ccstruct_->params()),
       double_MEMBER(tosp_large_kerning, 0.19,
-                    "Limit use of xht gap with large kns",
+                    "Limit use of xht gap with large kns", ccstruct_->params()),
-                    ccstruct_->params()),
       double_MEMBER(tosp_dont_fool_with_small_kerns, -1,
                     "Limit use of xht gap with odd small kns",
                     ccstruct_->params()),
@@ -193,11 +171,9 @@ Textord::Textord(CCStruct* ccstruct)
                     "Don't reduce box if the top left is non blank",
                     ccstruct_->params()),
       double_MEMBER(tosp_silly_kn_sp_gap, 0.2,
-                    "Don't let sp minus kn get too small",
+                    "Don't let sp minus kn get too small", ccstruct_->params()),
-                    ccstruct_->params()),
       double_MEMBER(tosp_pass_wide_fuzz_sp_to_context, 0.75,
-                    "How wide fuzzies need context",
+                    "How wide fuzzies need context", ccstruct_->params()),
-                    ccstruct_->params()),
       // tordmain.cpp ///////////////////////////////////////////
       BOOL_MEMBER(textord_no_rejects, false, "Don't remove noise blobs",
                   ccstruct_->params()),
@@ -212,28 +188,21 @@ Textord::Textord(CCStruct* ccstruct)
       double_MEMBER(textord_blob_size_bigile, 95, "Percentile for large blobs",
                     ccstruct_->params()),
       double_MEMBER(textord_noise_area_ratio, 0.7,
-                    "Fraction of bounding box for noise",
+                    "Fraction of bounding box for noise", ccstruct_->params()),
-                    ccstruct_->params()),
       double_MEMBER(textord_blob_size_smallile, 20,
-                    "Percentile for small blobs",
+                    "Percentile for small blobs", ccstruct_->params()),
-                    ccstruct_->params()),
       double_MEMBER(textord_initialx_ile, 0.75,
-                    "Ile of sizes for xheight guess",
+                    "Ile of sizes for xheight guess", ccstruct_->params()),
-                    ccstruct_->params()),
       double_MEMBER(textord_initialasc_ile, 0.90,
-                    "Ile of sizes for xheight guess",
+                    "Ile of sizes for xheight guess", ccstruct_->params()),
-                    ccstruct_->params()),
+      INT_MEMBER(textord_noise_sizefraction, 10, "Fraction of size for maxima",
-      INT_MEMBER(textord_noise_sizefraction, 10,
-                 "Fraction of size for maxima",
                  ccstruct_->params()),
       double_MEMBER(textord_noise_sizelimit, 0.5,
-                    "Fraction of x for big t count",
+                    "Fraction of x for big t count", ccstruct_->params()),
-                    ccstruct_->params()),
       INT_MEMBER(textord_noise_translimit, 16, "Transitions for normal blob",
                  ccstruct_->params()),
       double_MEMBER(textord_noise_normratio, 2.0,
-                    "Dot to norm ratio for deletion",
+                    "Dot to norm ratio for deletion", ccstruct_->params()),
-                    ccstruct_->params()),
       BOOL_MEMBER(textord_noise_rejwords, true, "Reject noise-like words",
                   ccstruct_->params()),
       BOOL_MEMBER(textord_noise_rejrows, true, "Reject noise-like rows",
@@ -242,24 +211,20 @@ Textord::Textord(CCStruct* ccstruct)
                     "xh fract height error for norm blobs",
                     ccstruct_->params()),
       double_MEMBER(textord_noise_sxfract, 0.4,
-                    "xh fract width error for norm blobs",
+                    "xh fract width error for norm blobs", ccstruct_->params()),
-                    ccstruct_->params()),
       double_MEMBER(textord_noise_hfract, 1.0 / 64,
                     "Height fraction to discard outlines as speckle noise",
                     ccstruct_->params()),
       INT_MEMBER(textord_noise_sncount, 1, "super norm blobs to save row",
                  ccstruct_->params()),
       double_MEMBER(textord_noise_rowratio, 6.0,
-                    "Dot to norm ratio for deletion",
+                    "Dot to norm ratio for deletion", ccstruct_->params()),
-                    ccstruct_->params()),
       BOOL_MEMBER(textord_noise_debug, false, "Debug row garbage detector",
                   ccstruct_->params()),
       double_MEMBER(textord_blshift_maxshift, 0.00, "Max baseline shift",
                     ccstruct_->params()),
       double_MEMBER(textord_blshift_xfraction, 9.99,
-                    "Min size of baseline shift",
+                    "Min size of baseline shift", ccstruct_->params()) {}
-                    ccstruct_->params()) {
-}
 
 Textord::~Textord() {
 }
@@ -324,10 +289,9 @@ void Textord::TextordPage(PageSegMode pageseg_mode, const FCOORD& reskew,
   BaselineDetect baseline_detector(textord_baseline_debug,
                                    reskew, to_blocks);
   baseline_detector.ComputeStraightBaselines(use_box_bottoms);
-  baseline_detector.ComputeBaselineSplinesAndXheights(page_tr_, true,
+  baseline_detector.ComputeBaselineSplinesAndXheights(
-                                                      textord_heavy_nr,
+      page_tr_, pageseg_mode != PSM_RAW_LINE, textord_heavy_nr,
-                                                      textord_show_final_rows,
+      textord_show_final_rows, this);
-                                                      this);
   // Now make the words in the lines.
   if (PSM_WORD_FIND_ENABLED(pageseg_mode)) {
     // SINGLE_LINE uses the old word maker on the single line.

textord/tordmain.cpp

@@ -360,7 +360,7 @@ void Textord::cleanup_nontext_block(BLOCK* block) {
   // Non-text blocks must contain at least one row.
   ROW_IT row_it(block->row_list());
   if (row_it.empty()) {
-    TBOX box = block->bounding_box();
+    const TBOX& box = block->bounding_box();
     float height = box.height();
     inT32 xstarts[2] = {box.left(), box.right()};
     double coeffs[3] = {0.0, 0.0, static_cast<double>(box.bottom())};

textord/tospace.cpp

@@ -419,9 +419,8 @@ void Textord::row_spacing_stats(
     if (suspected_table &&
     (row->space_size < tosp_table_kn_sp_ratio * row->kern_size)) {
       if (tosp_debug_level > 5)
-        tprintf ("B:%d R:%d -- DON'T BELIEVE SPACE %3.2f %d %3.2f.\n",
+        tprintf("B:%d R:%d -- DON'T BELIEVE SPACE %3.2f %d %3.2f.\n", block_idx,
-          block_idx, row_idx,
+                row_idx, row->kern_size, row->space_threshold, row->space_size);
-          row->kern_size, row->space_threshold, row->space_size);
       row->space_threshold =
         (inT32) (tosp_table_kn_sp_ratio * row->kern_size);
       row->space_size = MAX (row->space_threshold + 1, row->xheight);
@@ -441,8 +440,7 @@ void Textord::row_spacing_stats(
           MAX (tosp_min_sane_kn_sp * MAX (row->kern_size, 2.5),
           row->xheight / 2);
       if (tosp_debug_level > 5)
-        tprintf
+        tprintf("B:%d R:%d -- DON'T BELIEVE SPACE %3.2f %d %3.2f -> %3.2f.\n",
-          ("B:%d R:%d -- DON'T BELIEVE SPACE %3.2f %d %3.2f -> %3.2f.\n",
                 block_idx, row_idx, row->kern_size, row->space_threshold,
                 row->space_size, sane_space);
       row->space_size = sane_space;
@@ -456,9 +454,8 @@ void Textord::row_spacing_stats(
     if (row->space_threshold > sane_threshold) {
       if (tosp_debug_level > 5)
         tprintf("B:%d R:%d -- DON'T BELIEVE THRESH %3.2f %d %3.2f->%d.\n",
-          block_idx, row_idx,
+                block_idx, row_idx, row->kern_size, row->space_threshold,
-          row->kern_size,
+                row->space_size, sane_threshold);
-          row->space_threshold, row->space_size, sane_threshold);
       row->space_threshold = sane_threshold;
       if (row->space_size <= sane_threshold)
         row->space_size = row->space_threshold + 1.0f;
@@ -700,8 +697,8 @@ BOOL8 Textord::isolated_row_stats(TO_ROW *row,
     ((small_gaps_count / (float) total) < tosp_enough_small_gaps) ||
   (total - small_gaps_count < 1)) {
     if (tosp_debug_level > 5)
-      tprintf ("B:%d R:%d -- Can't do isolated row stats.\n",
+      tprintf("B:%d R:%d -- Can't do isolated row stats.\n", block_idx,
-        block_idx, row_idx);
+              row_idx);
     return FALSE;
   }
   blob_it.set_to_list (row->blob_list ());
@@ -1130,8 +1127,8 @@ ROW *Textord::make_prop_words(
       else
         blanks = 0;
       if (tosp_debug_level > 5)
-        tprintf
+        tprintf(
-          ("Repch wd at EOL (%d,%d). rep spacing %5.2f; Lgap:%d (%d blanks)\n",
+            "Repch wd at EOL (%d,%d). rep spacing %5.2f; Lgap:%d (%d blanks)\n",
             word->bounding_box().left(), word->bounding_box().bottom(),
             repetition_spacing, current_gap, blanks);
       word->set_blanks (blanks);
@@ -1687,9 +1684,8 @@ void Textord::mark_gap(
  }
   if (tosp_debug_level > 5)
     tprintf("  (%d,%d) Sp<->Kn Rule %d %d %d %d %d %d\n",
-      blob.left () - current_gap / 2, blob.bottom (), rule,
+            blob.left() - current_gap / 2, blob.bottom(), rule, prev_gap,
-      prev_gap, prev_blob_width, current_gap,
+            prev_blob_width, current_gap, next_blob_width, next_gap);
-      next_blob_width, next_gap);
 }
 #endif
 
@@ -1727,8 +1723,7 @@ BOOL8 Textord::ignore_big_gap(TO_ROW *row,
                               inT16 right) {
   inT16 gap = right - left + 1;
 
-  if (tosp_ignore_big_gaps > 999)
+  if (tosp_ignore_big_gaps > 999) return FALSE;  // Don't ignore
-    return FALSE;                //Don't ignore
   if (tosp_ignore_big_gaps > 0)
     return (gap > tosp_ignore_big_gaps * row->xheight);
   if (gap > tosp_ignore_very_big_gaps * row->xheight)
@@ -1750,7 +1745,6 @@ BOOL8 Textord::ignore_big_gap(TO_ROW *row,
   return FALSE;
 }
 
-
 /**********************************************************************
  * reduced_box_next
  *

training/cntraining.cpp

@@ -20,7 +20,6 @@
  ** limitations under the License.
 ******************************************************************************/
 
-
 /*----------------------------------------------------------------------------
           Include Files and Type Defines
 ----------------------------------------------------------------------------*/
@@ -53,10 +52,8 @@ int main (
           Private Function Prototypes
 ----------------------------------------------------------------------------*/
 
-void WriteNormProtos (
+void WriteNormProtos(const char *Directory, LIST LabeledProtoList,
-     const char  *Directory,
+                     const FEATURE_DESC_STRUCT *feature_desc);
-     LIST  LabeledProtoList,
-   CLUSTERER *Clusterer);
 
 /*
 PARAMDESC *ConvertToPARAMDESC(
@@ -81,7 +78,6 @@ CLUSTERCONFIG  CNConfig =
   elliptical, 0.025, 0.05, 0.8, 1e-3, 0
 };
 
-
 /*----------------------------------------------------------------------------
               Public Code
 ----------------------------------------------------------------------------*/
@@ -134,8 +130,7 @@ CLUSTERCONFIG  CNConfig =
 * @note Exceptions: none
 * @note History: Fri Aug 18 08:56:17 1989, DSJ, Created.
 */
-int main(int  argc, char* argv[])
+int main(int argc, char *argv[]) {
-{
   // Set the global Config parameters before parsing the command line.
   Config = CNConfig;
 

training/commontraining.cpp

@@ -39,7 +39,6 @@
 #include <math.h>
 
 using tesseract::CCUtil;
-using tesseract::FontInfo;
 using tesseract::IntFeatureSpace;
 using tesseract::ParamUtils;
 using tesseract::ShapeTable;
@@ -314,8 +313,6 @@ const char *GetNextFilename(int argc, const char* const * argv) {
     return NULL;
 } /* GetNextFilename */
 
-
-
 /*---------------------------------------------------------------------------*/
 /**
  * This routine searches through a list of labeled lists to find
@@ -328,10 +325,7 @@ const char *GetNextFilename(int argc, const char* const * argv) {
  * @note Exceptions: none
  * @note History: Fri Aug 18 15:57:41 1989, DSJ, Created.
  */
-LABELEDLIST FindList (
+LABELEDLIST FindList(LIST List, char* Label) {
-    LIST	List,
-    char	*Label)
-{
   LABELEDLIST LabeledList;
 
   iterate (List)
@@ -354,9 +348,7 @@ LABELEDLIST FindList (
  * @note Exceptions: none
  * @note History: Fri Aug 18 16:08:46 1989, DSJ, Created.
  */
-LABELEDLIST NewLabeledList (
+LABELEDLIST NewLabeledList(const char* Label) {
-    const char	*Label)
-{
   LABELEDLIST LabeledList;
 
   LabeledList = (LABELEDLIST) Emalloc (sizeof (LABELEDLISTNODE));
@@ -460,7 +452,7 @@ void FreeTrainingSamples(LIST CharList) {
   FEATURE_SET FeatureSet;
   LIST FeatureList;
 
-
+  LIST nodes = CharList;
   iterate(CharList) { /* iterate through all of the fonts */
     char_sample = (LABELEDLIST) first_node(CharList);
     FeatureList = char_sample->List;
@@ -470,7 +462,7 @@ void FreeTrainingSamples(LIST CharList) {
     }
     FreeLabeledList(char_sample);
   }
-  destroy(CharList);
+  destroy(nodes);
 }  /* FreeTrainingSamples */
 
 /*---------------------------------------------------------------------------*/
@@ -698,10 +690,7 @@ LIST RemoveInsignificantProtos(
 } /* RemoveInsignificantProtos */
 
 /*----------------------------------------------------------------------------*/
-MERGE_CLASS FindClass (
+MERGE_CLASS FindClass(LIST List, const char* Label) {
-    LIST	List,
-    const char	*Label)
-{
   MERGE_CLASS MergeClass;
 
   iterate (List)
@@ -715,9 +704,7 @@ MERGE_CLASS FindClass (
 } /* FindClass */
 
 /*---------------------------------------------------------------------------*/
-MERGE_CLASS NewLabeledClass (
+MERGE_CLASS NewLabeledClass(const char* Label) {
-    const char	*Label)
-{
   MERGE_CLASS MergeClass;
 
   MergeClass = new MERGE_CLASS_NODE;
@@ -738,11 +725,10 @@ MERGE_CLASS NewLabeledClass (
  * @note Exceptions: none
  * @note History: Fri Aug 18 17:44:27 1989, DSJ, Created.
  */
-void FreeLabeledClassList (
+void FreeLabeledClassList(LIST ClassList) {
-    LIST	ClassList)
-{
   MERGE_CLASS MergeClass;
 
+  LIST nodes = ClassList;
   iterate(ClassList) /* iterate through all of the fonts */
   {
     MergeClass = (MERGE_CLASS) first_node (ClassList);
@@ -750,7 +736,7 @@ void FreeLabeledClassList (
     FreeClass(MergeClass->Class);
     delete MergeClass;
   }
-  destroy (ClassList);
+  destroy(nodes);
 
 } /* FreeLabeledClassList */
 
@@ -835,18 +821,18 @@ void Normalize (
 } // Normalize
 
 /*-------------------------------------------------------------------------*/
-void FreeNormProtoList (
+void FreeNormProtoList(LIST CharList)
-    LIST	CharList)
 
 {
   LABELEDLIST char_sample;
 
+  LIST nodes = CharList;
   iterate(CharList) /* iterate through all of the fonts */
   {
     char_sample = (LABELEDLIST) first_node (CharList);
     FreeLabeledList (char_sample);
   }
-  destroy (CharList);
+  destroy(nodes);
 
 }  // FreeNormProtoList
 
@@ -869,11 +855,8 @@ void AddToNormProtosList(
 }
 
 /*---------------------------------------------------------------------------*/
-int NumberOfProtos(
+int NumberOfProtos(LIST ProtoList, BOOL8 CountSigProtos,
-    LIST ProtoList,
+                   BOOL8 CountInsigProtos) {
-    BOOL8	CountSigProtos,
-    BOOL8	CountInsigProtos)
-{
   int N = 0;
   PROTOTYPE* Proto;
 

training/fileio.cpp

@@ -81,8 +81,9 @@ bool File::ReadFileToString(const string& filename, string* out) {
 }
 
 string File::JoinPath(const string& prefix, const string& suffix) {
-  return (!prefix.size() || prefix[prefix.size() - 1] == '/') ?
+  return (prefix.empty() || prefix[prefix.size() - 1] == '/')
-      prefix + suffix : prefix + "/" + suffix;
+             ? prefix + suffix
+             : prefix + "/" + suffix;
 }
 
 bool File::Delete(const char* pathname) {

training/mftraining.cpp

@@ -64,9 +64,6 @@
 #include "tprintf.h"
 #include "unicity_table.h"
 
-using tesseract::Classify;
-using tesseract::FontInfo;
-using tesseract::FontSpacingInfo;
 using tesseract::IndexMapBiDi;
 using tesseract::MasterTrainer;
 using tesseract::Shape;

training/pango_font_info.cpp

@@ -437,10 +437,15 @@ bool PangoFontInfo::CanRenderString(const char* utf8_word, int len,
     PangoGlyph dotted_circle_glyph;
     PangoFont* font = run->item->analysis.font;
 
+#ifdef _WIN32  // Fixme! Leaks memory and breaks unittests.
     PangoGlyphString* glyphs = pango_glyph_string_new();
     char s[] = "\xc2\xa7";
     pango_shape(s, sizeof(s), &(run->item->analysis), glyphs);
     dotted_circle_glyph = glyphs->glyphs[0].glyph;
+#else
+    dotted_circle_glyph = pango_fc_font_get_glyph(
+        reinterpret_cast<PangoFcFont*>(font), kDottedCircleGlyph);
+#endif
 
     if (TLOG_IS_ON(2)) {
       PangoFontDescription* desc = pango_font_describe(font);
@@ -519,7 +524,7 @@ vector<string> FontUtils::available_fonts_;  // cache list
 bool FontUtils::IsAvailableFont(const char* input_query_desc,
                                 string* best_match) {
   string query_desc(input_query_desc);
-  if (PANGO_VERSION <= 12005) {
+#if (PANGO_VERSION <= 12005)
   // Strip commas and any ' Medium' substring in the name.
   query_desc.erase(std::remove(query_desc.begin(), query_desc.end(), ','),
                    query_desc.end());
@@ -528,8 +533,7 @@ bool FontUtils::IsAvailableFont(const char* input_query_desc,
   if (found != std::string::npos) {
     query_desc.erase(found, kMediumStr.length());
   }
-  }
+#endif
-
   PangoFontDescription *desc = pango_font_description_from_string(
       query_desc.c_str());
   PangoFont* selected_font = NULL;
@@ -589,7 +593,7 @@ static bool ShouldIgnoreFontFamilyName(const char* query) {
 // Outputs description names of available fonts.
 /* static */
 const vector<string>& FontUtils::ListAvailableFonts() {
-  if (available_fonts_.size()) {
+  if (!available_fonts_.empty()) {
     return available_fonts_;
   }
 #ifndef USE_STD_NAMESPACE

training/stringrenderer.cpp

@@ -209,8 +209,7 @@ void StringRenderer::SetLayoutProperties() {
 #if (PANGO_VERSION_MAJOR == 1 && PANGO_VERSION_MINOR >= 38)
   if (add_ligatures_) {
     set_features("liga, clig, dlig, hlig");
-    PangoAttribute* feature_attr =
+    PangoAttribute* feature_attr = pango_attr_font_features_new(features_);
-      pango_attr_font_features_new(features_);
     pango_attr_list_change(attr_list, feature_attr);
   }
 #endif
@@ -396,7 +395,7 @@ bool StringRenderer::GetClusterStrings(vector<string>* cluster_text) {
        it != start_byte_to_text.end(); ++it) {
     cluster_text->push_back(it->second);
   }
-  return cluster_text->size();
+  return !cluster_text->empty();
 }
 
 // Merges an array of BoxChars into words based on the identification of
@@ -496,7 +495,7 @@ void StringRenderer::ComputeClusterBoxes() {
     const int end_byte_index = cluster_start_to_end_index[start_byte_index];
     string cluster_text = string(text + start_byte_index,
                                  end_byte_index - start_byte_index);
-    if (cluster_text.size() && cluster_text[0] == '\n') {
+    if (!cluster_text.empty() && cluster_text[0] == '\n') {
       tlog(2, "Skipping newlines at start of text.\n");
       continue;
     }
@@ -596,12 +595,13 @@ void StringRenderer::ComputeClusterBoxes() {
       all_boxes = boxaCreate(0);
     boxaAddBox(all_boxes, page_boxchars[i]->mutable_box(), L_CLONE);
   }
+  if (all_boxes != NULL) {
     boxaGetExtent(all_boxes, NULL, NULL, &page_box);
     boxaDestroy(&all_boxes);
-  if (page_boxes_ == NULL)
+    if (page_boxes_ == NULL) page_boxes_ = boxaCreate(0);
-    page_boxes_ = boxaCreate(0);
     boxaAddBox(page_boxes_, page_box, L_INSERT);
   }
+}
 
 
 void StringRenderer::CorrectBoxPositionsToLayout(vector<BoxChar*>* boxchars) {

training/text2image.cpp

@@ -251,6 +251,8 @@ void ExtractFontProperties(const string &utf8_text,
       // the input consists of the separated characters.  NOTE(ranjith): As per
       // behdad@ this is not currently controllable at the level of the Pango
       // API.
+      // The most frequent of all is a single character "word" made by the CJK
+      // segmenter.
       // Safeguard against these cases here by just skipping the bigram.
       if (IsWhitespaceBox(boxes[b+1])) {
         continue;
@@ -604,7 +606,8 @@ int main(int argc, char** argv) {
           rotation = -1 * page_rotation[page_num];
         }
         if (FLAGS_degrade_image) {
-          pix = DegradeImage(pix, FLAGS_exposure, &randomizer, FLAGS_rotate_image ? &rotation : NULL);
+          pix = DegradeImage(pix, FLAGS_exposure, &randomizer,
+                             FLAGS_rotate_image ? &rotation : NULL);
         }
         render.RotatePageBoxes(rotation);
 

viewer/svutil.cpp

@@ -31,13 +31,13 @@ struct addrinfo {
 };
 #else
 #include <arpa/inet.h>
+#include <netdb.h>
 #include <netinet/in.h>
 #include <pthread.h>
 #include <semaphore.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <string.h>
-#include <netdb.h>
 #include <sys/select.h>
 #include <sys/socket.h>
 #ifdef __linux__
@@ -56,10 +56,34 @@ struct addrinfo {
 #include "config_auto.h"
 #endif
 
-#ifndef GRAPHICS_DISABLED
-
 #include "svutil.h"
 
+SVMutex::SVMutex() {
+#ifdef _WIN32
+  mutex_ = CreateMutex(0, FALSE, 0);
+#else
+  pthread_mutex_init(&mutex_, NULL);
+#endif
+}
+
+void SVMutex::Lock() {
+#ifdef _WIN32
+  WaitForSingleObject(mutex_, INFINITE);
+#else
+  pthread_mutex_lock(&mutex_);
+#endif
+}
+
+void SVMutex::Unlock() {
+#ifdef _WIN32
+  ReleaseMutex(mutex_);
+#else
+  pthread_mutex_unlock(&mutex_);
+#endif
+}
+
+#ifndef GRAPHICS_DISABLED
+
 const int kMaxMsgSize = 4096;
 
 // Signals a thread to exit.
@@ -161,29 +185,6 @@ void SVSemaphore::Wait() {
 #endif
 }
 
-SVMutex::SVMutex() {
-#ifdef _WIN32
-  mutex_ = CreateMutex(0, FALSE, 0);
-#else
-  pthread_mutex_init(&mutex_, NULL);
-#endif
-}
-
-void SVMutex::Lock() {
-#ifdef _WIN32
-  WaitForSingleObject(mutex_, INFINITE);
-#else
-  pthread_mutex_lock(&mutex_);
-#endif
-}
-
-void SVMutex::Unlock() {
-#ifdef _WIN32
-  ReleaseMutex(mutex_);
-#else
-  pthread_mutex_unlock(&mutex_);
-#endif
-}
 
 // Create new thread.
 
@@ -200,7 +201,10 @@ void SVSync::StartThread(void *(*func)(void*), void* arg) {
   &threadid);    // returns the thread identifier
 #else
   pthread_t helper;
-  pthread_create(&helper, NULL, func, arg);
+  pthread_attr_t attr;
+  pthread_attr_init(&attr);
+  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+  pthread_create(&helper, &attr, func, arg);
 #endif
 }
 
@@ -214,7 +218,7 @@ void SVNetwork::Send(const char* msg) {
 // Send the whole buffer.
 void SVNetwork::Flush() {
   mutex_send_->Lock();
-  while (msg_buffer_out_.size() > 0) {
+  while (!msg_buffer_out_.empty()) {
     int i = send(stream_, msg_buffer_out_.c_str(), msg_buffer_out_.length(), 0);
     msg_buffer_out_.erase(0, i);
   }
@@ -302,7 +306,8 @@ static std::string ScrollViewCommand(std::string scrollview_path) {
   const char* cmd_template = "-Djava.library.path=%s -jar %s/ScrollView.jar";
 
 #else
-  const char* cmd_template = "-c \"trap 'kill %%1' 0 1 2 ; java "
+  const char* cmd_template =
+      "-c \"trap 'kill %%1' 0 1 2 ; java "
       "-Xms1024m -Xmx2048m -jar %s/ScrollView.jar"
       " & wait\"";
 #endif

wordrec/associate.h

@@ -47,9 +47,7 @@ struct AssociateStats {
     gap_sum = 0;
   }
 
-  void Print() {
+  void Print() { tprintf("AssociateStats: s(%g %d)\n", shape_cost, bad_shape); }
-    tprintf("AssociateStats: w(%g %d)\n", shape_cost, bad_shape);
-  }
 
   float shape_cost;           // cost of blob shape
   bool bad_shape;             // true if the shape of the blob is unacceptable

wordrec/lm_state.h

@@ -48,8 +48,8 @@ typedef unsigned char LanguageModelFlagsType;
 /// Each ViterbiStateEntry contains information from various components of the
 /// language model: dawgs in which the path is found, character ngram model
 /// probability of the path, script/chartype/font consistency info, state for
-/// language-specific heuristics (e.g. hyphenated and compound words, lower/upper
+/// language-specific heuristics (e.g. hyphenated and compound words,
-/// case preferences, etc).
+/// lower/upper case preferences, etc).
 ///
 /// Each ViterbiStateEntry also contains the parent pointer, so that the path
 /// that it represents (WERD_CHOICE) can be constructed by following these

wordrec/measure.h

@@ -62,8 +62,7 @@ typedef struct
 
 #define ADD_SAMPLE(m, s)           \
   (m.sum_of_samples += (float)(s), \
-	m.sum_of_squares += (float) (s) * (float) (s), \
+   m.sum_of_squares += (float)(s) * (float)(s), ++m.num_samples)
-	++m.num_samples)
 
 /**********************************************************************
  * mean
@@ -72,9 +71,7 @@ typedef struct
  **********************************************************************/
 
 #define MEAN(m) \
-((m).num_samples ?                                  \
+  ((m).num_samples ? ((float)((m).sum_of_samples / (m).num_samples)) : 0)
-	((float) ((m).sum_of_samples / (m).num_samples)) : \
-	0)
 
 /**********************************************************************
  * new_measurement
@@ -84,9 +81,7 @@ typedef struct
  **********************************************************************/
 
 #define new_measurement(m) \
-((m).num_samples    = 0, \
+  ((m).num_samples = 0, (m).sum_of_samples = 0, (m).sum_of_squares = 0)
-	(m).sum_of_samples = 0, \
-	(m).sum_of_squares = 0)
 
 /**********************************************************************
  * number_of_samples
@@ -113,12 +108,11 @@ typedef struct
  **********************************************************************/
 
 #define VARIANCE(m)                                           \
-(((m).num_samples > 1) ?                            \
+  (((m).num_samples > 1)                                      \
-	((float)                                           \
+       ? ((float)(((m).num_samples * (m).sum_of_squares -     \
-	(((m).num_samples * (m).sum_of_squares -          \
                    (m).sum_of_samples * (m).sum_of_samples) / \
-	(((m).num_samples - 1) * (m).num_samples)))   :  \
+                  (((m).num_samples - 1) * (m).num_samples))) \
-	0)
+       : 0)
 
 /**********************************************************************
  * print_summary
@@ -127,9 +121,7 @@ typedef struct
  **********************************************************************/
 
 #define print_summary(string, measure)                             \
-cprintf ("\t%-20s \tn = %d, \tm = %4.2f, \ts = %4.2f\n ",  \
+  cprintf("\t%-20s \tn = %d, \tm = %4.2f, \ts = %4.2f\n ", string, \
-			string,                                          \
+          number_of_samples(measure), MEAN(measure),               \
-			number_of_samples  (measure),                    \
-			MEAN           (measure),                    \
           standard_deviation(measure))
 #endif