From f76d8a14cd49b952bc30d21c0fab14553c8de3a7 Mon Sep 17 00:00:00 2001 From: Stefan Weil Date: Wed, 4 Jul 2018 15:18:59 +0200 Subject: [PATCH] Remove unused code from oldlist Signed-off-by: Stefan Weil --- src/cutil/oldlist.cpp | 184 ++++++------------------------------------ src/cutil/oldlist.h | 135 +------------------------------ 2 files changed, 25 insertions(+), 294 deletions(-) diff --git a/src/cutil/oldlist.cpp b/src/cutil/oldlist.cpp index bcc8bc5e2d..140ed5f401 100644 --- a/src/cutil/oldlist.cpp +++ b/src/cutil/oldlist.cpp @@ -4,11 +4,6 @@ # File: oldlist.cpp # Description: List processing procedures. # Author: Mark Seaman, Software Productivity -# Created: Thu Jul 23 13:24:09 1987 -# Modified: Thu Dec 22 10:59:52 1988 (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"); @@ -53,21 +48,6 @@ count LENGTH x = count(l); search MEMBER if (search(l, x, nullptr)) - To implement SETS use: - - adjoin l = adjoin(l, x); - set_union l = set_union(r, s); - intersection l = intersection(r, s); - set_difference l = set_difference(r, s); - delete l = delete(s, x, nullptr); - search if (search(l, x, nullptr)) - - To Implement Associated LISTS use: - - lpush l = lpush(l, p); - assoc s = assoc(l, x); - adelete l = adelete(l, x); - The following rules of closure exist for the functions provided. a = first_node (push (a, b)) b = list_rest (push (a, b)) @@ -87,9 +67,31 @@ #define add_on(l, x) l = push(l, first_node(x)) #define next_one(l) l = list_rest(l) +/********************************************************************** + * 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))) + /*---------------------------------------------------------------------- F u n c t i o n s ----------------------------------------------------------------------*/ + +/********************************************************************** + * i s s a m e + * + * Compare the list node with the key value return TRUE (non-zero) + * if they are equivalent strings. (Return FALSE if not) + **********************************************************************/ +static int is_same(void *item1, void *item2) { + return strcmp((char *)item1, (char *)item2) == 0; +} + /********************************************************************** * c o u n t * @@ -108,8 +110,7 @@ int count(LIST var_list) { * Delete all the elements out of the current list that match the key. * This operation destroys the original list. The caller will supply a * routine that will compare each node to the - * key, and return a non-zero value when they match. If the value - * nullptr is supplied for is_equal, the is_key routine will be used. + * key, and return a non-zero value when they match. **********************************************************************/ LIST delete_d(LIST list, void *key, int_compare is_equal) { LIST result = NIL_LIST; @@ -137,31 +138,6 @@ LIST delete_d(LIST list, void *key, int_compare is_equal) { return (result); } -LIST delete_d(LIST list, void *key, - TessResultCallback2 *is_equal) { - LIST result = NIL_LIST; - LIST last_one = NIL_LIST; - - while (list != NIL_LIST) { - if (!(*is_equal).Run(first_node(list), key)) { - if (last_one == NIL_LIST) { - last_one = list; - list = list_rest(list); - result = last_one; - set_rest(last_one, NIL_LIST); - } else { - set_rest(last_one, list); - last_one = list; - list = list_rest(list); - set_rest(last_one, NIL_LIST); - } - } else { - list = pop(list); - } - } - return (result); -} - /********************************************************************** * d e s t r o y * @@ -192,48 +168,6 @@ void destroy_nodes(LIST list, void_dest destructor) { } } -/********************************************************************** - * i n s e r t - * - * Create a list element and rearange the pointers so that the first - * element in the list is the second aurgment. - **********************************************************************/ -void insert(LIST list, void *node) { - LIST element; - - if (list != NIL_LIST) { - element = push(NIL_LIST, node); - set_rest(element, list_rest(list)); - set_rest(list, element); - node = first_node(list); - list->node = first_node(list_rest(list)); - list->next->node = (LIST)node; - } -} - -/********************************************************************** - * i s s a m e - * - * Compare the list node with the key value return TRUE (non-zero) - * if they are equivalent strings. (Return FALSE if not) - **********************************************************************/ -int is_same(void *item1, void *item2) { - return strcmp((char *)item1, (char *)item2) == 0 ? 1 : 0; -} - -/********************************************************************** - * j o i n - * - * Join the two lists together. This function is similar to concat - * except that concat creates a new list. This function returns the - * first list updated. - **********************************************************************/ -LIST join(LIST list1, LIST list2) { - if (list1 == NIL_LIST) return (list2); - set_rest(last(list1), list2); - return (list1); -} - /********************************************************************** * l a s t * @@ -244,19 +178,6 @@ LIST last(LIST var_list) { return (var_list); } -/********************************************************************** - * n t h c e l l - * - * Return nth list cell in the list. - **********************************************************************/ -void *nth_cell(LIST var_list, int item_num) { - int x = 0; - iterate(var_list) { - if (x++ == item_num) return (var_list); - } - return (var_list); -} - /********************************************************************** * p o p * @@ -305,63 +226,12 @@ LIST push_last(LIST list, void *item) { return (push(NIL_LIST, item)); } -/********************************************************************** - * r e v e r s e - * - * Create a new list with the elements reversed. The old list is not - * destroyed. - **********************************************************************/ -LIST reverse(LIST list) { - LIST newlist = NIL_LIST; - - iterate(list) copy_first(list, newlist); - return (newlist); -} - -/********************************************************************** - * r e v e r s e d - * - * Create a new list with the elements reversed. The old list is - * destroyed. - **********************************************************************/ -LIST reverse_d(LIST list) { - LIST result = reverse(list); - destroy(list); - return (result); -} - -/********************************************************************** - * s a d j o i n - * - * Adjoin an element to an assorted list. The original list is - * modified. Returns the modified list. - **********************************************************************/ -LIST s_adjoin(LIST var_list, void *variable, int_compare compare) { - LIST l; - int result; - - if (compare == nullptr) compare = (int_compare)strcmp; - - l = var_list; - iterate(l) { - result = (*compare)(variable, first_node(l)); - if (result == 0) - return (var_list); - else if (result < 0) { - insert(l, variable); - return (var_list); - } - } - return (push_last(var_list, variable)); -} - /********************************************************************** * s e a r c h * * Search list, return NIL_LIST if not found. Return the list starting from * the item if found. The compare routine "is_equal" is passed in as - * the third parameter to this routine. If the value nullptr is supplied - * for is_equal, the is_key routine will be used. + * the third parameter to this routine. **********************************************************************/ LIST search(LIST list, void *key, int_compare is_equal) { if (is_equal == nullptr) is_equal = is_same; @@ -369,9 +239,3 @@ LIST search(LIST list, void *key, int_compare is_equal) { iterate(list) if ((*is_equal)(first_node(list), key)) return (list); return (NIL_LIST); } - -LIST search(LIST list, void *key, - TessResultCallback2 *is_equal) { - iterate(list) if ((*is_equal).Run(first_node(list), key)) return (list); - return (NIL_LIST); -} diff --git a/src/cutil/oldlist.h b/src/cutil/oldlist.h index aacc4aa9a8..ccf604de1c 100644 --- a/src/cutil/oldlist.h +++ b/src/cutil/oldlist.h @@ -37,74 +37,25 @@ * 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. * * TRANSFORMS: (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_LIST) 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). + * push_last - Add a new element onto the end of a list. * * 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. * ***********************************************************************/ @@ -113,7 +64,6 @@ #define LIST_H #include "cutil.h" // for int_compare, void_dest, ... -#include "tesscallback.h" /*---------------------------------------------------------------------- T y p e s @@ -135,17 +85,6 @@ using LIST = list_rec *; #define list_rest(l) ((l) ? (l)->next : NIL_LIST) #define first_node(l) ((l) ? (l)->node : NIL_LIST) -/********************************************************************** - * 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 * @@ -156,37 +95,6 @@ using LIST = list_rec *; #define iterate(l) \ for (; (l) != NIL_LIST; (l) = list_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)=list_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 * @@ -197,17 +105,6 @@ for ((x)=(l); (x)!=0; (x)=list_rest(x)) #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 (list_rest (l)) - **********************************************************************/ - -#define second_node(l) \ -first_node (list_rest (l)) - /********************************************************************** * s e t r e s t * @@ -219,17 +116,6 @@ first_node (list_rest (l)) #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 (list_rest (list_rest (l))) - **********************************************************************/ - -#define third(l) \ -first_node (list_rest (list_rest (l))) - /*---------------------------------------------------------------------- Public Function Prototypes ----------------------------------------------------------------------*/ @@ -237,37 +123,18 @@ int count(LIST var_list); LIST delete_d(LIST list, void *key, int_compare is_equal); -LIST delete_d(LIST list, void *key, - TessResultCallback2* is_equal); - LIST destroy(LIST list); void destroy_nodes(LIST list, void_dest destructor); -void insert(LIST list, void *node); - -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); -LIST search(LIST list, void *key, TessResultCallback2*); - #endif