tesseract_bin 1.0.0

data/vendor/tesseract-2.04/ccutil/varable.cpp

@@ -0,0 +1,672 @@
+/**********************************************************************
+ * File:        varable.c  (Formerly variable.c)
+ * Description: Initialization and setting of VARIABLEs.
+ * Author:					Ray Smith
+ * Created:					Fri Feb 22 16:22:34 GMT 1991
+ *
+ * (C) Copyright 1991, Hewlett-Packard Ltd.
+ ** Licensed under the Apache License, Version 2.0 (the "License");
+ ** you may not use this file except in compliance with the License.
+ ** You may obtain a copy of the License at
+ ** http://www.apache.org/licenses/LICENSE-2.0
+ ** Unless required by applicable law or agreed to in writing, software
+ ** distributed under the License is distributed on an "AS IS" BASIS,
+ ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ** See the License for the specific language governing permissions and
+ ** limitations under the License.
+ *
+ **********************************************************************/
+
+#include          "mfcpch.h"     //precompiled headers
+#include          <stdio.h>
+#include          <string.h>
+#include          <stdlib.h>
+#include          "tprintf.h"
+//#include                                      "ipeerr.h"
+#include          "varable.h"
+#include          "scanutils.h"
+
+#define PLUS          '+'        //flag states
+#define MINUS         '-'
+#define EQUAL         '='
+
+CLISTIZE (INT_VARIABLE)
+CLISTIZE (BOOL_VARIABLE) CLISTIZE (STRING_VARIABLE) CLISTIZE (double_VARIABLE)
+INT_VAR_FROM
+INT_VARIABLE::copy;
+INT_VARIABLE_CLIST
+INT_VARIABLE::head;              //global definition
+INT_VAR_TO
+INT_VARIABLE::replace;
+BOOL_VAR_FROM
+BOOL_VARIABLE::copy;
+BOOL_VARIABLE_CLIST
+BOOL_VARIABLE::head;             //global definition
+BOOL_VAR_TO
+BOOL_VARIABLE::replace;
+STRING_VAR_FROM
+STRING_VARIABLE::copy;
+STRING_VARIABLE_CLIST
+STRING_VARIABLE::head;           //global definition
+STRING_VAR_TO
+STRING_VARIABLE::replace;
+double_VAR_FROM
+double_VARIABLE::copy;
+double_VARIABLE_CLIST
+double_VARIABLE::head;           //global definition
+double_VAR_TO
+double_VARIABLE::replace;
+
+/**********************************************************************
+ * INT_VAR_FROM::INT_VAR_FROM
+ *
+ * Constructor to copy the list to a temporary location while the
+ * list head gets constructed.
+ **********************************************************************/
+
+INT_VAR_FROM::INT_VAR_FROM() {  //constructor
+  INT_VARIABLE_C_IT start_it = &INT_VARIABLE::head;
+  INT_VARIABLE_C_IT end_it = &INT_VARIABLE::head;
+
+  if (!start_it.empty ()) {
+    while (!end_it.at_last ())
+      end_it.forward ();
+                                 //move to copy
+    list.assign_to_sublist (&start_it, &end_it);
+  }
+}
+
+
+/**********************************************************************
+ * INT_VAR_TO::INT_VAR_TO
+ *
+ * Constructor to copy the list back to its rightful place.
+ **********************************************************************/
+
+INT_VAR_TO::INT_VAR_TO() {  //constructor
+  INT_VARIABLE_C_IT start_it = &INT_VARIABLE::copy.list;
+  INT_VARIABLE_C_IT end_it = &INT_VARIABLE::copy.list;
+
+  if (!start_it.empty ()) {
+    while (!end_it.at_last ())
+      end_it.forward ();
+    INT_VARIABLE::head.assign_to_sublist (&start_it, &end_it);
+  }
+}
+
+
+/**********************************************************************
+ * INT_VARIABLE::INT_VARIABLE
+ *
+ * Constructor for INT_VARIABLE. Add the variable to the static list.
+ **********************************************************************/
+
+INT_VARIABLE::INT_VARIABLE(                     //constructor
+                           inT32 v,             //the variable
+                           const char *vname,   //of variable
+                           const char *comment  //info on variable
+                          ) {
+  INT_VARIABLE_C_IT it = &head;  //list iterator
+
+  //tprintf("Constructing %s\n",vname);
+  set_value(v);  //set the value
+  name = vname;                  //strings must be static
+  info = comment;
+  it.add_before_stay_put (this); //add it to stack
+}
+
+
+INT_VARIABLE::~INT_VARIABLE (    //constructor
+) {
+  INT_VARIABLE_C_IT it = &head;  //list iterator
+
+  for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ())
+    if (it.data () == this)
+      it.extract ();
+}
+
+
+/**********************************************************************
+ * INT_VARIABLE::get_head
+ *
+ * Get the head of the list of the variables.
+ **********************************************************************/
+
+INT_VARIABLE_CLIST *INT_VARIABLE::get_head() {  //access to static
+  return &head;
+}
+
+
+/**********************************************************************
+ * INT_VARIABLE::print
+ *
+ * Print the entire list of INT_VARIABLEs.
+ **********************************************************************/
+
+void INT_VARIABLE::print(          //print full list
+                         FILE *fp  //file to print on
+                        ) {
+  INT_VARIABLE_C_IT it = &head;  //list iterator
+  INT_VARIABLE *elt;             //current element
+
+  if (fp == stdout) {
+    tprintf ("#Variables of type INT_VARIABLE:\n");
+    for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
+      elt = it.data ();
+      tprintf ("%s %d #%s\n", elt->name, elt->value, elt->info);
+    }
+  }
+  else {
+    fprintf (fp, "#Variables of type INT_VARIABLE:\n");
+    for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
+      elt = it.data ();
+      fprintf (fp, "%s " INT32FORMAT " #%s\n", elt->name, elt->value,
+        elt->info);
+    }
+  }
+}
+
+
+/**********************************************************************
+ * BOOL_VAR_FROM::BOOL_VAR_FROM
+ *
+ * Constructor to copy the list to a temporary location while the
+ * list head gets constructed.
+ **********************************************************************/
+
+BOOL_VAR_FROM::BOOL_VAR_FROM() {  //constructor
+  BOOL_VARIABLE_C_IT start_it = &BOOL_VARIABLE::head;
+  BOOL_VARIABLE_C_IT end_it = &BOOL_VARIABLE::head;
+
+  if (!start_it.empty ()) {
+    while (!end_it.at_last ())
+      end_it.forward ();
+                                 //move to copy
+    list.assign_to_sublist (&start_it, &end_it);
+  }
+}
+
+
+/**********************************************************************
+ * BOOL_VAR_TO::BOOL_VAR_TO
+ *
+ * Constructor to copy the list back to its rightful place.
+ **********************************************************************/
+
+BOOL_VAR_TO::BOOL_VAR_TO() {  //constructor
+  BOOL_VARIABLE_C_IT start_it = &BOOL_VARIABLE::copy.list;
+  BOOL_VARIABLE_C_IT end_it = &BOOL_VARIABLE::copy.list;
+
+  if (!start_it.empty ()) {
+    while (!end_it.at_last ())
+      end_it.forward ();
+    BOOL_VARIABLE::head.assign_to_sublist (&start_it, &end_it);
+  }
+}
+
+
+/**********************************************************************
+ * BOOL_VARIABLE::BOOL_VARIABLE
+ *
+ * Constructor for BOOL_VARIABLE. Add the variable to the static list.
+ **********************************************************************/
+
+BOOL_VARIABLE::BOOL_VARIABLE(                     //constructor
+                             BOOL8 v,             //the variable
+                             const char *vname,   //of variable
+                             const char *comment  //info on variable
+                            ) {
+  BOOL_VARIABLE_C_IT it = &head; //list iterator
+
+  //tprintf("Constructing %s\n",vname);
+  set_value(v);  //set the value
+  name = vname;                  //strings must be static
+  info = comment;
+  it.add_before_stay_put (this); //add it to stack
+
+}
+
+
+/**********************************************************************
+ * BOOL_VARIABLE::BOOL_VARIABLE
+ *
+ * Constructor for BOOL_VARIABLE. Add the variable to the static list.
+ **********************************************************************/
+
+BOOL_VARIABLE::~BOOL_VARIABLE () {
+  BOOL_VARIABLE_C_IT it = &head; //list iterator
+
+  for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ())
+    if (it.data () == this)
+      it.extract ();
+}
+
+
+/**********************************************************************
+ * BOOL_VARIABLE::get_head
+ *
+ * Get the head of the list of the variables.
+ **********************************************************************/
+
+BOOL_VARIABLE_CLIST *BOOL_VARIABLE::get_head() {  //access to static
+  return &head;
+}
+
+
+/**********************************************************************
+ * BOOL_VARIABLE::print
+ *
+ * Print the entire list of BOOL_VARIABLEs.
+ **********************************************************************/
+
+void BOOL_VARIABLE::print(          //print full list
+                          FILE *fp  //file to print on
+                         ) {
+  BOOL_VARIABLE_C_IT it = &head; //list iterator
+  BOOL_VARIABLE *elt;            //current element
+
+  if (fp == stdout) {
+    tprintf ("#Variables of type BOOL_VARIABLE:\n");
+    for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
+      elt = it.data ();
+      tprintf ("%s %c #%s\n",
+        elt->name, elt->value ? 'T' : 'F', elt->info);
+    }
+  }
+  else {
+    fprintf (fp, "#Variables of type BOOL_VARIABLE:\n");
+    for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
+      elt = it.data ();
+      fprintf (fp, "%s %c #%s\n",
+        elt->name, elt->value ? 'T' : 'F', elt->info);
+    }
+  }
+}
+
+
+/**********************************************************************
+ * STRING_VAR_FROM::STRING_VAR_FROM
+ *
+ * Constructor to copy the list to a temporary location while the
+ * list head gets constructed.
+ **********************************************************************/
+
+STRING_VAR_FROM::STRING_VAR_FROM() {  //constructor
+  STRING_VARIABLE_C_IT start_it = &STRING_VARIABLE::head;
+  STRING_VARIABLE_C_IT end_it = &STRING_VARIABLE::head;
+
+  if (!start_it.empty ()) {
+    while (!end_it.at_last ())
+      end_it.forward ();
+                                 //move to copy
+    list.assign_to_sublist (&start_it, &end_it);
+  }
+}
+
+
+/**********************************************************************
+ * STRING_VAR_TO::STRING_VAR_TO
+ *
+ * Constructor to copy the list back to its rightful place.
+ **********************************************************************/
+
+STRING_VAR_TO::STRING_VAR_TO() {  //constructor
+  STRING_VARIABLE_C_IT start_it = &STRING_VARIABLE::copy.list;
+  STRING_VARIABLE_C_IT end_it = &STRING_VARIABLE::copy.list;
+
+  if (!start_it.empty ()) {
+    while (!end_it.at_last ())
+      end_it.forward ();
+    STRING_VARIABLE::head.assign_to_sublist (&start_it, &end_it);
+  }
+}
+
+
+/**********************************************************************
+ * STRING_VARIABLE::STRING_VARIABLE
+ *
+ * Constructor for STRING_VARIABLE. Add the variable to the static list.
+ **********************************************************************/
+
+STRING_VARIABLE::STRING_VARIABLE (
+                                 //constructor
+const char *v,                   //the variable
+const char *vname,               //of variable
+const char *comment              //info on variable
+):
+value(v) {
+                                 // list iterator
+  STRING_VARIABLE_C_IT it = &head;
+
+  name = vname;                  // strings must be static
+  info = comment;
+  it.add_before_stay_put(this);  // add it to stack
+}
+
+
+/**********************************************************************
+ * STRING_VARIABLE::~STRING_VARIABLE
+ *
+ * Destructor for STRING_VARIABLE. Add the variable to the static list.
+ **********************************************************************/
+
+                                 // constructor
+STRING_VARIABLE::~STRING_VARIABLE(
+) {
+                                 // list iterator
+  STRING_VARIABLE_C_IT it = &head;
+
+  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward())
+    if (it.data() == this)
+      it.extract();
+}
+
+
+/**********************************************************************
+ * STRING_VARIABLE::get_head
+ *
+ * Get the head of the list of the variables.
+ **********************************************************************/
+
+STRING_VARIABLE_CLIST *STRING_VARIABLE::get_head() {  // access to static
+  return &head;
+}
+
+
+/**********************************************************************
+ * STRING_VARIABLE::print
+ *
+ * Print the entire list of STRING_VARIABLEs.
+ **********************************************************************/
+
+void STRING_VARIABLE::print(FILE *fp  // file to print on
+                           ) {
+                                 // list iterator
+  STRING_VARIABLE_C_IT it = &head;
+  STRING_VARIABLE *elt;          // current element
+
+  if (fp == stdout) {
+    tprintf("#Variables of type STRING_VARIABLE:\n");
+    for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
+      elt = it.data();
+      tprintf("%s #%s %s\n", elt->name, elt->value.string(), elt->info);
+    }
+  } else {
+    fprintf(fp, "#Variables of type STRING_VARIABLE:\n");
+    for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
+      elt = it.data();
+      fprintf(fp, "%s #%s %s\n",
+        elt->name, elt->value.string(), elt->info);
+    }
+  }
+}
+
+
+/**********************************************************************
+ * double_VAR_FROM::double_VAR_FROM
+ *
+ * Constructor to copy the list to a temporary location while the
+ * list head gets constructed.
+ **********************************************************************/
+
+double_VAR_FROM::double_VAR_FROM() {  // constructor
+  double_VARIABLE_C_IT start_it = &double_VARIABLE::head;
+  double_VARIABLE_C_IT end_it = &double_VARIABLE::head;
+
+  if (!start_it.empty()) {
+    while (!end_it.at_last())
+      end_it.forward();
+                                 // move to copy
+    list.assign_to_sublist(&start_it, &end_it);
+  }
+}
+
+
+/**********************************************************************
+ * double_VAR_TO::double_VAR_TO
+ *
+ * Constructor to copy the list back to its rightful place.
+ **********************************************************************/
+
+double_VAR_TO::double_VAR_TO() {  // constructor
+  double_VARIABLE_C_IT start_it = &double_VARIABLE::copy.list;
+  double_VARIABLE_C_IT end_it = &double_VARIABLE::copy.list;
+
+  if (!start_it.empty()) {
+    while (!end_it.at_last())
+      end_it.forward();
+    double_VARIABLE::head.assign_to_sublist(&start_it, &end_it);
+  }
+}
+
+
+/**********************************************************************
+ * double_VARIABLE::double_VARIABLE
+ *
+ * Constructor for double_VARIABLE. Add the variable to the static list.
+ **********************************************************************/
+
+double_VARIABLE::double_VARIABLE(double v,            // the variable
+                                 const char *vname,   // of variable
+                                 const char *comment  // info on variable
+                                ) {
+                                 // list iterator
+  double_VARIABLE_C_IT it = &head;
+
+  set_value(v);  // set the value
+  name = vname;                  // strings must be static
+  info = comment;
+  it.add_before_stay_put(this); // add it to stack
+}
+
+
+double_VARIABLE::~double_VARIABLE() {
+                                 // list iterator
+  double_VARIABLE_C_IT it = &head;
+
+  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward())
+    if (it.data() == this)
+      it.extract();
+}
+
+
+/**********************************************************************
+ * double_VARIABLE::get_head
+ *
+ * Get the head of the list of the variables.
+ **********************************************************************/
+
+double_VARIABLE_CLIST *double_VARIABLE::get_head() {  // access to static
+  return &head;
+}
+
+
+/**********************************************************************
+ * double_VARIABLE::print
+ *
+ * Print the entire list of double_VARIABLEs.
+ **********************************************************************/
+
+void double_VARIABLE::print(FILE *fp  // file to print on
+                           ) {
+                                 // list iterator
+  double_VARIABLE_C_IT it = &head;
+  double_VARIABLE *elt;          // current element
+
+  if (fp == stdout) {
+    tprintf("#Variables of type double_VARIABLE:\n");
+    for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
+      elt = it.data();
+      tprintf ("%s %lg #%s\n", elt->name, elt->value, elt->info);
+    }
+  } else {
+    fprintf(fp, "#Variables of type double_VARIABLE:\n");
+    for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
+      elt = it.data();
+      fprintf(fp, "%s %g #%s\n", elt->name, elt->value, elt->info);
+    }
+  }
+}
+
+
+/**********************************************************************
+ * read_variables_file
+ *
+ * Read a file of variables definitions and set/modify the values therein.
+ * If the filename begins with a + or -, the BOOL_VARIABLEs will be
+ * ORed or ANDed with any current values.
+ * Blank lines and lines beginning # are ignored.
+ * Values may have any whitespace after the name and are the rest of line.
+ **********************************************************************/
+
+DLLSYM BOOL8 read_variables_file(const char *file  // name to read
+                                ) {
+  BOOL8 anyerr;                  // true if any error
+  char flag;                     // file flag
+  BOOL8 foundit;                 // found variable
+  inT16 length;                  // length of line
+  inT16 nameoffset;              // offset for real name
+  char *valptr;                  // value field
+  char *stringend;               // end of string value
+  FILE *fp;                      // file pointer
+                                 // iterators
+  char line[MAX_PATH];           // input line
+
+  anyerr = FALSE;
+  if (*file == PLUS) {
+    flag = PLUS;                 // file has flag
+    nameoffset = 1;
+  } else if (*file == MINUS) {
+    flag = MINUS;
+    nameoffset = 1;
+  } else {
+    flag = EQUAL;
+    nameoffset = 0;
+  }
+
+  fp = fopen(file + nameoffset, "r");
+  if (fp == NULL) {
+    tprintf("read_variables_file:Can't open %s", file + nameoffset);
+    return TRUE;                 // can't open it
+  }
+  while (fgets (line, MAX_PATH, fp)) {
+    if (line[0] != '\n' && line[0] != '#') {
+      length = strlen (line);
+      if (line[length - 1] == '\n')
+        line[length - 1] = '\0';  // cut newline
+      for (valptr = line; *valptr && *valptr != ' ' && *valptr != '\t';
+        valptr++);
+      if (*valptr) {             //found blank
+        *valptr = '\0';          //make name a string
+        do
+
+        valptr++;              //find end of blanks
+        while (*valptr == ' ' || *valptr == '\t');
+
+        if (*valptr && *valptr != '#') {
+                                 //last char in string
+          stringend = valptr + strlen (valptr) - 1;
+          while (stringend != valptr) {
+            while (stringend != valptr
+              && (*stringend == ' ' || *stringend == '\t'))
+              // cut trailing blanks
+              stringend--;
+            stringend[1] = '\0'; // terminate string
+
+            while (stringend != valptr
+              && ((*stringend != ' ' && *stringend != '\t')
+              || stringend[1] != '#'))
+              stringend--;       // find word start
+          }
+        }
+      }
+      foundit = set_new_style_variable(line, valptr);
+
+      if (!foundit) {
+        anyerr = TRUE;         // had an error
+        tprintf("read_variables_file:variable not found: %s\n",
+          line);
+      }
+    }
+  }
+  fclose(fp);  // close file
+  return anyerr;
+}
+
+bool set_new_style_variable(const char *variable, const char* value) {
+  INT_VARIABLE_C_IT int_it = &INT_VARIABLE::head;
+  BOOL_VARIABLE_C_IT BOOL_it = &BOOL_VARIABLE::head;
+  STRING_VARIABLE_C_IT STRING_it = &STRING_VARIABLE::head;
+  double_VARIABLE_C_IT double_it = &double_VARIABLE::head;
+
+  bool foundit = false;
+  // find name
+  for (STRING_it.mark_cycle_pt();
+       !STRING_it.cycled_list() && strcmp(variable, STRING_it.data()->name);
+       STRING_it.forward());
+  if (!STRING_it.cycled_list()) {
+    foundit = true;          // found the varaible
+    if (*value == '\0')
+      STRING_it.data()->set_value((char *) NULL);  // No value.
+    else
+      STRING_it.data()->set_value(value);  // set its value
+  }
+
+  if (*value) {
+    // find name
+    for (int_it.mark_cycle_pt();
+         !int_it.cycled_list() && strcmp(variable, int_it.data()->name);
+         int_it.forward());
+    int intval;
+    if (!int_it.cycled_list()
+    && sscanf(value, INT32FORMAT, &intval) == 1) {
+      foundit = true;        // found the varaible
+      int_it.data()->set_value(intval);  // set its value.
+    }
+    for (BOOL_it.mark_cycle_pt();
+         !BOOL_it.cycled_list () && strcmp(variable, BOOL_it.data()->name);
+         BOOL_it.forward());
+    if (!BOOL_it.cycled_list()) {
+      if (*value == 'T' || *value == 't' ||
+          *value == 'Y' || *value == 'y' || *value == '1') {
+        foundit = true;
+        BOOL_it.data()->set_value(TRUE);
+      }
+      else if (*value == 'F' || *value == 'f' ||
+               *value == 'N' || *value == 'n' || *value == '0') {
+        foundit = true;
+        BOOL_it.data()->set_value(FALSE);
+      }
+    }
+    for (double_it.mark_cycle_pt();
+         !double_it.cycled_list() && strcmp(variable, double_it.data ()->name);
+         double_it.forward());
+    double doubleval;
+#ifdef EMBEDDED
+    if (!double_it.cycled_list ()) {
+      doubleval = strtofloat(value);
+#else
+    if (!double_it.cycled_list()
+        && sscanf(value, "%lf", &doubleval) == 1) {
+#endif
+      foundit = true;        // found the varaible
+      double_it.data()->set_value(doubleval);
+    }
+  }
+  return foundit;
+}
+
+/**********************************************************************
+ * print_variables
+ *
+ * Print all variable types to the given file
+ **********************************************************************/
+
+DLLSYM void print_variables(          //print all vars
+                            FILE *fp  //file to print on
+                           ) {
+  INT_VARIABLE::print(fp);  //print INTs
+  BOOL_VARIABLE::print(fp);  //print BOOLs
+  STRING_VARIABLE::print(fp);  //print STRINGs
+  double_VARIABLE::print(fp);  //print doubles
+}