tesseract_bin 1.0.0

data/vendor/tesseract-2.04/cutil/oldlist.h

@@ -0,0 +1,350 @@
+/* -*-C-*-
+ ********************************************************************************
+ *
+ * File:        list.h  (Formerly list.h)
+ * Description:  List processing procedures declarations.
+ * Author:       Mark Seaman, SW Productivity
+ * Created:      Fri Oct 16 14:37:00 1987
+ * Modified:     Wed Dec  5 15:43:17 1990 (Mark Seaman) marks@hpgrlt
+ * Language:     C
+ * Package:      N/A
+ * Status:       Reusable Software Component
+ *
+ * (c) Copyright 1987, Hewlett-Packard Company.
+ ** 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.
+ *
+ ********************************************************************************
+ *
+ * This file contains the interface for a set of general purpose list
+ * manipulation routines.  For the implementation of these routines see
+ * the file "list.c".
+ *
+ ********************************************************************************
+ *
+ *                            INDEX
+ *                           =======
+ *
+ * BASICS:
+ * -------
+ * first_node        - Macro to return the first list node (not the cell).
+ * rest              - Macro the return the second list cell
+ * pop               - Destroy one list cell
+ * push              - Create one list cell and set the node and next fields
+ *
+ * ITERATION:
+ * -----------------
+ * iterate           - Macro to create a for loop to visit each cell.
+ * iterate_list      - Macro to visit each cell using a local variable.
+ * for_each          - Applies a function to each node.
+ *
+ * LIST CELL COUNTS:
+ * -----------------
+ * count             - Returns the number of list cells in the list.
+ * second_node       - Returns the second node.
+ * third             - Returns the third node.
+ * fourth            - Returns the fourth node.
+ * fifth             - Returns the fifth node.
+ * last              - Returns the last list cell.
+ * pair              - Creates a list of two elements.
+ *
+ * COPYING:
+ * -----------------
+ * copy_first        - Pushes the first element from list 1 onto list 2.
+ * copy              - Create a copy of a list.
+ * concat            - Creates a new list that is a copy of both input lists.
+ * delete_n          - Creates a new list without the chosen elements.
+ * reverse           - Creates a backwards copy of the input list.
+ * sort              - Use quick sort to construct a new list.
+ * transform         - Creates a new list by transforming each of the nodes.
+ *
+ * TRANFORMS:             (Note: These functions all modify the input list.)
+ * ----------
+ * join              - Concatenates list 1 and list 2.
+ * delete_d          - Removes the requested elements from the list.
+ * transform_d       - Modifies the list by applying a function to each node.
+ * insert            - Add a new element into this spot in a list. (not NIL)
+ * push_last         - Add a new element onto the end of a list.
+ * reverse_d         - Reverse a list and destroy the old one.
+ *
+ * ASSOCIATED LISTS:
+ * -----------------
+ * adelete           - Remove a particular entry from an associated list.
+ * assoc             - Find an entry in an associated list that matches a key.
+ * match             - Return the data element of an a-list entry.
+ *
+ * DISPLAY:
+ * -----------------
+ * print_cell        - Print a hex dump of a list cell.
+ * show              - Displays a string and a list (using lprint).
+ *
+ * SETS:
+ * -----
+ * adjoin            - Add a new element to list if it does not exist already.
+ * intersection      - Create a new list that is the set intersection.
+ * set_union         - Create a new list that is the set intersection.
+ * set_difference    - Create a new list that is the set difference.
+ * s_adjoin          - Add an element to a sort list if it is not there.
+ * s_intersection    - Set intersection on a sorted list. Modifies old list.
+ * s_union           - Set intersection on a sorted list. Modifies old list.
+ * search            - Return the pointer to the list cell whose node matches.
+ *
+ * COMPARISONS:
+ * -----------------
+ * is_same           - Compares each node to the key.
+ * is_not_same       - Compares each node to the key.
+ * is_key            - Compares first of each node to the key.
+ * is_not_key        - Compares first of each node to the key.
+ *
+ * CELL OPERATIONS:
+ * -----------------
+ * new_cell          - Obtain a new list cell from the free list. Allocate.
+ * free_cell         - Return a list cell to the free list.
+ * destroy           - Return all list cells in a list.
+ * destroy_nodes     - Apply a function to each list cell and destroy the list.
+ * set_node          - Assign the node field in a list cell.
+ * set_rest          - Assign the next field in a list cell.
+ *
+ ***********************************************************************/
+
+#ifndef LIST_H
+#define LIST_H
+
+#include "cutil.h"
+
+/*----------------------------------------------------------------------
+                  T y p e s
+----------------------------------------------------------------------*/
+#define NIL  (LIST) 0
+typedef struct list_rec
+{
+  struct list_rec *node;
+  struct list_rec *next;
+} _LIST_;
+typedef _LIST_ *LIST;
+
+/*----------------------------------------------------------------------
+                  M a c r o s
+----------------------------------------------------------------------*/
+/* Predefinitions */
+#define rest(l)  ((l) ? (l)->next : NIL)
+#define first_node(l) ((l) ? (l)->node : NIL)
+
+/**********************************************************************
+ *  c o p y   f i r s t
+ *
+ *  Do the appropriate kind a push operation to copy the first node from
+ *  one list to another.
+ *
+ **********************************************************************/
+
+#define copy_first(l1,l2)  \
+(l2=push(l2, first_node(l1)))
+
+/**********************************************************************
+ *  i t e r a t e
+ *
+ *  Visit each node in the list.  Replace the old list with the list
+ *  minus the head.  Continue until the list is NIL.
+ **********************************************************************/
+
+#define iterate(l)             \
+for (; (l) != NIL; (l) = rest (l))
+
+/**********************************************************************
+ *  i t e r a t e   l i s t
+ *
+ *  Visit each node in the list (l).  Use a local variable (x) to iterate
+ *  through all of the list cells.  This macro is identical to iterate
+ *  except that it does not lose the original list.
+ **********************************************************************/
+
+#define iterate_list(x,l)  \
+for ((x)=(l); (x)!=0; (x)=rest(x))
+
+/**********************************************************************
+ * j o i n   o n
+ *
+ * Add another list onto the tail of this one.  The list given as an input
+ * parameter is modified.
+ **********************************************************************/
+
+#define JOIN_ON(list1,list2)    \
+((list1) = join ((list1), (list2)))
+
+/**********************************************************************
+ * p o p   o f f
+ *
+ * Add a cell onto the front of a list.  The list given as an input
+ * parameter is modified.
+ **********************************************************************/
+
+#define pop_off(list)    \
+((list) = pop (list))
+
+/**********************************************************************
+ * p u s h   o n
+ *
+ * Add a cell onto the front of a list.  The list given as an input
+ * parameter is modified.
+ **********************************************************************/
+
+#define push_on(list,thing)    \
+((list) = push (list, (LIST) (thing)))
+
+/**********************************************************************
+ *  s e c o n d
+ *
+ *  Return the contents of the second list element.
+ *
+ *  #define second_node(l)    first_node (rest (l))
+ **********************************************************************/
+
+#define second_node(l)              \
+first_node (rest (l))
+
+/**********************************************************************
+ *  s e t   r e s t
+ *
+ *  Change the "next" field of a list element to point to a desired place.
+ *
+ *  #define set_rest(l,node)        l->next = node;
+ **********************************************************************/
+
+#define set_rest(l,cell)\
+((l)->next = (cell))
+
+/**********************************************************************
+ *  t h i r d
+ *
+ *  Return the contents of the third list element.
+ *
+ *  #define third(l)     first_node (rest (rest (l)))
+ **********************************************************************/
+
+#define third(l)               \
+first_node (rest (rest (l)))
+
+/*----------------------------------------------------------------------
+          Public Funtion Prototypes
+----------------------------------------------------------------------*/
+int count(LIST var_list);
+
+LIST delete_d(LIST list, void *key, int_compare is_equal);
+
+LIST destroy(LIST list);
+
+void destroy_nodes(LIST list, void_dest destructor);
+
+void insert(LIST list, void *node);
+
+int is_same_node(void *item1, void *item2);
+
+int is_same(void *item1, void *item2);
+
+LIST join(LIST list1, LIST list2);
+
+LIST last(LIST var_list);
+
+void *nth_cell(LIST var_list, int item_num);
+
+LIST pop(LIST list);
+
+LIST push(LIST list, void *element);
+
+LIST push_last(LIST list, void *item);
+
+LIST reverse(LIST list);
+
+LIST reverse_d(LIST list);
+
+LIST s_adjoin(LIST var_list, void *variable, int_compare compare);
+
+LIST search(LIST list, void *key, int_compare is_equal);
+
+/*
+#if defined(__STDC__) || defined(__cplusplus)
+# define _ARGS(s) s
+#else
+# define _ARGS(s) ()
+#endif
+
+typedef void  (*destructor)   _ARGS((LIST l));
+
+typedef LIST  (*list_proc)    _ARGS((LIST a));
+
+int count
+_ARGS((LIST var_list));
+
+LIST delete_d
+_ARGS((LIST list,
+    LIST key,
+    int_compare is_equal));
+
+LIST destroy
+_ARGS((LIST list));
+
+LIST destroy_nodes
+_ARGS((LIST list,
+    void_dest destructor));
+
+void insert
+_ARGS((LIST list,
+    LIST node));
+
+int is_same_node
+_ARGS((LIST s1,
+    LIST s2));
+
+int is_same
+_ARGS((LIST s1,
+    LIST s2));
+
+LIST join
+_ARGS((LIST list1,
+    LIST list2));
+
+LIST last
+_ARGS((LIST var_list));
+
+LIST nth_cell
+_ARGS((LIST var_list,
+    int item_num));
+
+LIST pop
+_ARGS((LIST list));
+
+LIST push
+_ARGS((LIST list,
+    LIST element));
+
+LIST push_last
+_ARGS((LIST list,
+    LIST item));
+
+LIST reverse
+_ARGS((LIST list));
+
+LIST reverse_d
+_ARGS((LIST list));
+
+LIST s_adjoin
+_ARGS((LIST var_list,
+    LIST variable,
+    int_compare compare));
+
+LIST search
+_ARGS((LIST list,
+    LIST key,
+    int_compare is_equal));
+
+#undef _ARGS
+*/
+#endif

data/vendor/tesseract-2.04/cutil/structures.cpp

@@ -0,0 +1,66 @@
+/* -*-C-*-
+ ********************************************************************************
+ *
+ * File:        structures.c  (Formerly structures.c)
+ * Description:  Allocate all the different types of structures.
+ * Author:       Mark Seaman, OCR Technology
+ * Created:      Wed May 30 10:27:26 1990
+ * Modified:     Mon Jul 15 10:39:18 1991 (Mark Seaman) marks@hpgrlt
+ * Language:     C
+ * Package:      N/A
+ * Status:       Experimental (Do Not Distribute)
+ *
+ * (c) Copyright 1990, Hewlett-Packard Company.
+ ** 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.
+ *
+ *********************************************************************************/
+/*----------------------------------------------------------------------
+              I n c l u d e s
+----------------------------------------------------------------------*/
+#include "structures.h"
+#include "callcpp.h"
+
+#include <stdio.h>
+
+/*----------------------------------------------------------------------
+              M a c r o s
+----------------------------------------------------------------------*/
+#define BLOBBLOCK          64    /*no allocated together */
+#define OUTLINEBLOCK       300   /*of each type */
+#define NODEBLOCK          36    /*blocks all about 1K bytes */
+#define EDGEPTBLOCK        50
+#define WERDBLOCK          42
+#define LISTBLOCK          300
+
+/*----------------------------------------------------------------------
+              V a r i a b l e s
+----------------------------------------------------------------------*/
+int structblockcount = 0;
+void_void memory_print_functions[NUM_DATA_TYPES];
+int max_data_types = 0;
+
+/*----------------------------------------------------------------------
+              F u n c t i o n s
+----------------------------------------------------------------------*/
+makestructure (newword, oldword, printword, TWERD,
+freeword, WERDBLOCK, "TWERD", wordcount)
+makestructure (newoutline, oldoutline, printol, TESSLINE,
+freeoutline, OUTLINEBLOCK, "TESSLINE", outlinecount);
+
+makestructure (new_cell, free_cell, printcell, _LIST_,
+freelist, LISTBLOCK, "LIST", listcount);
+
+newstructure (newblob, TBLOB, freeblob, BLOBBLOCK, "newblob", blobcount);
+oldstructure (oldblob, TBLOB, freeblob, "BLOB", blobcount);
+
+newstructure (newedgept, EDGEPT, freeedgept, EDGEPTBLOCK, "newedgept",
+edgeptcount);
+oldstructure (oldedgept, EDGEPT, freeedgept, "EDGEPT", edgeptcount);

data/vendor/tesseract-2.04/cutil/structures.h

@@ -0,0 +1,112 @@
+/* -*-C-*-
+ ********************************************************************************
+ *
+ * File:        structures.h  (Formerly structures.h)
+ * Description:  Allocate all the different types of structures.
+ * Author:       Mark Seaman, OCR Technology
+ * Created:      Wed May 30 10:12:12 1990
+ * Modified:     Tue May 21 11:07:47 1991 (Mark Seaman) marks@hpgrlt
+ * Language:     C
+ * Package:      N/A
+ * Status:       Experimental (Do Not Distribute)
+ *
+ * (c) Copyright 1990, Hewlett-Packard Company.
+ ** 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.
+ *
+ *********************************************************************************/
+#ifndef STRUCTURES_H
+#define STRUCTURES_H
+
+/*----------------------------------------------------------------------
+              I n c l u d e s
+----------------------------------------------------------------------*/
+#include "tessclas.h"
+#include "oldlist.h"
+#include "freelist.h"
+#include "danerror.h"
+
+#define NUM_DATA_TYPES 20
+
+extern int max_data_types;
+extern void_void memory_print_functions[NUM_DATA_TYPES];
+
+/*----------------------------------------------------------------------
+              M a c r o s
+----------------------------------------------------------------------*/
+/**********************************************************************
+ * makestructure
+ *
+ * Allocate a chunk of memory for a particular data type.  This macro
+ * defines an allocation, deallocation, and status printing function
+ * for each new data type.
+ **********************************************************************/
+
+#define makestructure(newfunc,old,print,type,nextfree,blocksize,typestring,usecount)                \
+type *newfunc()                                                                  \
+{                                                                            \
+	return new type; \
+}                                                                            \
+																									\
+																									\
+																									\
+void old(type* deadelement)                                                       \
+{                                                                            \
+	delete deadelement; \
+}                                                                            \
+
+
+/**********************************************************************
+ * newstructure
+ *
+ * Allocate a chunk of memory for a particular data type.
+ **********************************************************************/
+
+#define newstructure(name,type,nextfree,blocksize,errorstring,usecount)\
+type *name()											/*returns a new type*/\
+{\
+	return new type;\
+}
+
+/**********************************************************************
+ * oldstructure
+ *
+ * Returns a structure to the freelist
+ **********************************************************************/
+
+#define oldstructure(name,type,nextfree,stringtype,usecount)\
+\
+type *name(type* deadelement)\
+{\
+	type                    *returnelement;				/*return next ptr*/\
+\
+	returnelement=deadelement->next;					/*return link*/\
+	delete deadelement;  \
+	return returnelement;\
+}
+
+/*----------------------------------------------------------------------
+              F u n c t i o n s
+----------------------------------------------------------------------*/
+extern TBLOB *newblob();
+extern TBLOB *oldblob(TBLOB *);
+
+extern TESSLINE *newoutline();
+extern void oldoutline(TESSLINE *);
+
+extern EDGEPT *newedgept();
+extern EDGEPT *oldedgept(EDGEPT *);
+
+extern TWERD *newword();
+extern void oldword(TWERD *);
+
+extern LIST new_cell();
+extern void free_cell(LIST);
+#endif

data/vendor/tesseract-2.04/cutil/tessarray.cpp

@@ -0,0 +1,115 @@
+/* -*-C-*-
+################################################################################
+#
+# File:						array.c
+# Description:				Dynamic Array of Strings
+# Author:					Mark Seaman, Software Productivity
+# Created:					Thu Jul 23 13:24:09 1987
+# Modified:     Wed Mar  6 15:18:33 1991 (Mark Seaman) marks@hpgrlt
+# Language:					C
+# Package:					N/A
+# Status:					Reusable Software Component
+#
+# (c) Copyright 1987, Hewlett-Packard Company.
+** 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.
+#
+################################################################################
+
+This file contains the implentations of a set of dynamic array of string
+manipulation routines.		For the interface definitions and documentation
+of these routines see the file "das.h".
+
+***************************************************************************/
+
+#include "tessarray.h"
+#include "callcpp.h"
+#include "freelist.h"
+
+#include <stdio.h>
+#include <string.h>
+#ifdef __MSW32__
+#include <process.h>
+#endif
+#include <ctype.h>
+#if MAC_OR_DOS
+#include <stdlib.h>
+#endif
+
+/**********************************************************************
+ * array_insert
+ *
+ * Insert a data element into a particular spot in the array.  Move all
+ * the elements in the array (past that spot) down one to make room for
+ * the new element.
+ **********************************************************************/
+ARRAY array_insert(ARRAY array, int index, void *value) { 
+  int x;
+
+  array = array_push (array, NULL);
+  for (x = array_count (array) - 1; x > index; x--)
+    array_value (array, x) = array_value (array, x - 1);
+  array_value (array, index) = value;
+  return (array);
+}
+
+
+/**********************************************************************
+ * array_new
+ *
+ * Create a new array with a certain number of elements.	If the number
+ * of elements requested is 0 then the default number will be used.
+ **********************************************************************/
+ARRAY array_new(int num) { 
+  ARRAY temp;
+  int x;
+
+  if (num == 0)
+    num = DEFAULT_SIZE;
+  temp = (ARRAY) memalloc ((num - 2) * sizeof (char *) +
+    sizeof (struct array_record));
+  if (!temp) {
+    cprintf ("error: Out of memory in array_new\n");
+    exit (1);                    //?err_exit ();
+  }
+  array_count (temp) = 0;
+  array_limit (temp) = num;
+  for (x = 0; x < num; x++)
+    array_value (temp, x) = (char *) 0;
+  return (temp);
+}
+
+
+/**********************************************************************
+ * array_push
+ *
+ * Add a new element onto the top of the array.	If there is not room
+ * more room is made by "realloc"ing the array.	This means that the
+ * new array location may change.  All previous references to its old
+ * location may no longer be valid.
+ **********************************************************************/
+ARRAY array_push(ARRAY array, void *value) { 
+  if (array_count (array) == array_limit (array)) {
+    array = (ARRAY) memrealloc (array, (array_limit (array) * 2 - 2) *
+      sizeof (char *) +
+      sizeof (struct array_record),
+      (array_limit (array) -
+      2) * sizeof (char *) +
+      sizeof (struct array_record));
+    if (!array) {
+      cprintf ("error: Out of memory in array_push\n");
+      exit (1);                  //?err_exit ();
+    }
+    array_limit (array) *= 2;
+  }
+  array_count (array)++;
+  array_top (array) = value;
+  return (array);
+}