3 echo "This script will create the gen_list contrib files in the current"
4 echo "directory. Do you wish to continue? [y/n]"
9 if [[ ${ans} != [Yy]* ]]; then
15 typeset fileList="Makefile README addr_clean.pl gen_list.c gen_list.h isa.c
16 isa.h main.c malloc_police.c malloc_police.h rec_char.c rec_char.h
17 rec_charptr.c rec_charptr.h rec_double.c rec_double.h rec_long.c
18 rec_long.h rec_malloc_police.c rec_malloc_police.h"
21 for i in ${fileList}; do
25 ####################################
28 ## -e "s/^\(#${i}:\)\(.*\)/\2/"
29 ## Find lines belonging to
30 ## this file and remove the
34 ## Jump to label print if the
35 ## above s command matched
38 ## This command is skipped
39 ## when the s command fails.
40 ## This will remove any
44 ## The last thing sed does
45 ## is print the data. So,
46 ## by now, we only print
47 ## lines belonging to the file.
49 ####################################
51 sed -e "s/^\(#${i}:\)\(.*\)/\2/" \
63 #Makefile:PROGRAM = test_list
65 #Makefile:SRC = main.c isa.c gen_list.c rec_char.c rec_charptr.c rec_double.c rec_long.c rec_malloc_police.c malloc_police.c
66 #Makefile:OBJS = main.o isa.o gen_list.o rec_char.o rec_charptr.o rec_double.o rec_long.o rec_malloc_police.o malloc_police.o
68 #Makefile:all : $(PROGRAM)
70 #Makefile:$(PROGRAM) : $(OBJS)
71 #Makefile: gcc $(CFLAGS) -o $(PROGRAM) $(OBJS)
74 #Makefile: rm -f $(OBJS)
76 #Makefile:clobber: clean
77 #Makefile: rm -f $(PROGRAM)
80 #README:This list supports:
81 #README: copy construction,
82 #README: "virtual" destruction,
84 #README: comparison (equal comparison currently supported).
86 #README:With the "object oriented" nature of the list, nodes, and records; it is
87 #README:easily concievable that sorted lists and hash tables could be implemented
88 #README:with little extra effort.
91 #README:Philosophical point:
93 #README:I am sure there is room for improvement with this design. I am
94 #README:submitting this as a generic doubly linked list recomendation for IJB.
95 #README:Whatever the "collective" decides is fine with me.
97 #README:This implementation uses the "naming space" of gen_list, derived_rec,
98 #README:construct, copy construct, stream, destruct, etc... These are open to
99 #README:argument. I just used what was familiar to me and others in the "OO"
100 #README:community. If these need changed to be adopted ... "so be it".
103 #README:Implementation point:
105 #README:I assume this is too late for a "3.0" release. As I work for an
106 #README:airline, the whole past summer has been hectic (not to mention the
107 #README:last 4 months); but things have begun to settle down and I am
108 #README:following the IJB lists a bit more closely. And I would like to say
109 #README:"HOLY CRAP!" .. you guys have accompolished a lot! Way to go.
111 #README:But, the adoption of a better linked list package should at least be
112 #README:high on the next release list (if not the current one). If you choose
113 #README:this submission or not, so be it. But as a "data structure" man, I
114 #README:think IJB's linked lists need addressing.
117 #README:List/Enlist note:
119 #README:I have noticed the list.c file. If this generic list is adopted, I
120 #README:think all existing functionallity could be duplicated with the
121 #README:"copy_contruct", "equal", and "destruct" `virtuals'. This would also
122 #README:eliminate and/or enhance the other manually maintained lists in IJB.
127 #README:Since the generic list defined a "stream" virtual, it could be programmed
128 #README:that the list could print itself whenever a FATAL error occurs. A user (or
129 #README:programmer) could read the list and hopefully determine the cause of the
133 #README:Potential note:
135 #README:Think of the possibilites of a linked list, sorted list, and/or a hash
136 #README:list. Think of a request to a web site that has been referenced
137 #README:before. If a hash list keep track of all block requests and regexp
138 #README:change commands, then a site could be blocked and/or modified without
139 #README:ever consulting the actions lists again. What a speed up!
141 #README:What if some of the current lists were kept in sorted lists? Then a
142 #README:search for a particular record could be a binary search instead of a
143 #README:linear search.
145 #README:The actions file(s) and regexp files(s) could be inserted into the
146 #README:list from front to back order (or visa versa) and the processing would
147 #README:take place in actual file order (which is more natural); rather than
148 #README:in reverse order (as it is today).
151 #README:Thank you for you time and attention to this contribution. If it is
152 #README:"blessed" by the group, I am available to give time to integrating
153 #README:this into IJB.
155 #README:Let me know what y'all think about this package.
161 #addr_clean.pl:#!/usr/bin/perl
163 #addr_clean.pl:## *********************************************************************
165 #addr_clean.pl:## * File : $Source: /cvsroot/ijbswa/current/contrib.sh,v $
167 #addr_clean.pl:## * Purpose : Cleans addresses out of ./test_list and replaces
168 #addr_clean.pl:## * them with "english" replacements.
170 #addr_clean.pl:## * Usage : ./test_list | ./addr_clean.pl
172 #addr_clean.pl:## * Copyright : This program is free software; you can redistribute it
173 #addr_clean.pl:## * and/or modify it under the terms of the GNU General
174 #addr_clean.pl:## * Public License as published by the Free Software
175 #addr_clean.pl:## * Foundation; either version 2 of the License, or (at
176 #addr_clean.pl:## * your option) any later version.
178 #addr_clean.pl:## * This program is distributed in the hope that it will
179 #addr_clean.pl:## * be useful, but WITHOUT ANY WARRANTY; without even the
180 #addr_clean.pl:## * implied warranty of MERCHANTABILITY or FITNESS FOR A
181 #addr_clean.pl:## * PARTICULAR PURPOSE. See the GNU General Public
182 #addr_clean.pl:## * License for more details.
184 #addr_clean.pl:## * The GNU General Public License should be included with
185 #addr_clean.pl:## * this file. If not, you can view it at
186 #addr_clean.pl:## * http://www.gnu.org/copyleft/gpl.html
187 #addr_clean.pl:## * or write to the Free Software Foundation, Inc., 59
188 #addr_clean.pl:## * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
190 #addr_clean.pl:## **********************************************************************/
192 #addr_clean.pl:use strict;
195 #addr_clean.pl:my $nMaxList = 0;
196 #addr_clean.pl:my $nMaxNode = 0;
197 #addr_clean.pl:my $nMaxRec = 0;
198 #addr_clean.pl:my %aaTranslation;
199 #addr_clean.pl:my $strLine;
201 #addr_clean.pl:while ( $strLine = <STDIN> )
203 #addr_clean.pl: if ( $strLine =~ m!(list.*=\s*)(0x[0-9a-f]+)! )
205 #addr_clean.pl: my $str1 = $1;
206 #addr_clean.pl: my $str2 = $2;
208 #addr_clean.pl: if ( ! defined $aaTranslation{$str2} )
210 #addr_clean.pl: $aaTranslation{$str2} = "list" . ++ $nMaxList;
212 #addr_clean.pl: $strLine =~ s!(list.*=\s*)(0x[0-9a-f]+)!$str1($aaTranslation{$str2})!;
216 #addr_clean.pl: if ( $strLine =~ m!(node.*=\s*)(0x[0-9a-f]+)! )
218 #addr_clean.pl: my $str1 = $1;
219 #addr_clean.pl: my $str2 = $2;
221 #addr_clean.pl: if ( ! defined $aaTranslation{$str2} )
223 #addr_clean.pl: $aaTranslation{$str2} = "node" . ++ $nMaxNode;
225 #addr_clean.pl: $strLine =~ s!(node.*=\s*)(0x[0-9a-f]+)!$str1($aaTranslation{$str2})!;
229 #addr_clean.pl: if ( $strLine =~ m!(rec.*=\s*(iter_. \.\.\. )?)(0x[0-9a-f]+)! )
231 #addr_clean.pl: my $str1 = $1;
232 #addr_clean.pl: my $str2 = $3;
234 #addr_clean.pl: if ( ! defined $aaTranslation{$str2} )
236 #addr_clean.pl: $aaTranslation{$str2} = "rec" . ++ $nMaxRec;
238 #addr_clean.pl: $strLine =~ s!(rec.*=\s*(iter_. \.\.\. )?)(0x[0-9a-f]+)!$str1($aaTranslation{$str2})!;
242 #addr_clean.pl: ## Catch the copy constuct syntax
244 #addr_clean.pl: if ( $strLine =~ m!(list.*=>\s*)(0x[0-9a-f]+)! )
246 #addr_clean.pl: my $str1 = $1;
247 #addr_clean.pl: my $str2 = $2;
249 #addr_clean.pl: if ( ! defined $aaTranslation{$str2} )
251 #addr_clean.pl: $aaTranslation{$str2} = "list" . ++ $nMaxList;
253 #addr_clean.pl: $strLine =~ s!(list.*=>\s*)(0x[0-9a-f]+)!$str1($aaTranslation{$str2})!;
257 #addr_clean.pl: if ( $strLine =~ m!(node.*=>\s*)(0x[0-9a-f]+)! )
259 #addr_clean.pl: my $str1 = $1;
260 #addr_clean.pl: my $str2 = $2;
262 #addr_clean.pl: if ( ! defined $aaTranslation{$str2} )
264 #addr_clean.pl: $aaTranslation{$str2} = "node" . ++ $nMaxNode;
266 #addr_clean.pl: $strLine =~ s!(node.*=>\s*)(0x[0-9a-f]+)!$str1($aaTranslation{$str2})!;
270 #addr_clean.pl: if ( $strLine =~ m!(rec.*=>\s*)(0x[0-9a-f]+)! )
272 #addr_clean.pl: my $str1 = $1;
273 #addr_clean.pl: my $str2 = $2;
275 #addr_clean.pl: if ( ! defined $aaTranslation{$str2} )
277 #addr_clean.pl: $aaTranslation{$str2} = "rec" . ++ $nMaxRec;
279 #addr_clean.pl: $strLine =~ s!(rec.*=>\s*)(0x[0-9a-f]+)!$str1($aaTranslation{$str2})!;
282 #addr_clean.pl: print( $strLine );
287 #gen_list.c:const char gen_list_rcs[] = "$Id: contrib.sh,v 1.1 2001/12/07 01:54:50 iwanttokeepanon Exp $";
288 #gen_list.c:/*********************************************************************
290 #gen_list.c: * File : $Source: /cvsroot/ijbswa/current/contrib.sh,v $
292 #gen_list.c: * Purpose : To create some functions to do generic doubly linked
293 #gen_list.c: * list management.
295 #gen_list.c: * Copyright : Written by and Copyright (C) 2001 the SourceForge
296 #gen_list.c: * Privoxy team. http://ijbswa.sourceforge.net
298 #gen_list.c: * This program is free software; you can redistribute it
299 #gen_list.c: * and/or modify it under the terms of the GNU General
300 #gen_list.c: * Public License as published by the Free Software
301 #gen_list.c: * Foundation; either version 2 of the License, or (at
302 #gen_list.c: * your option) any later version.
304 #gen_list.c: * This program is distributed in the hope that it will
305 #gen_list.c: * be useful, but WITHOUT ANY WARRANTY; without even the
306 #gen_list.c: * implied warranty of MERCHANTABILITY or FITNESS FOR A
307 #gen_list.c: * PARTICULAR PURPOSE. See the GNU General Public
308 #gen_list.c: * License for more details.
310 #gen_list.c: * The GNU General Public License should be included with
311 #gen_list.c: * this file. If not, you can view it at
312 #gen_list.c: * http://www.gnu.org/copyleft/gpl.html
313 #gen_list.c: * or write to the Free Software Foundation, Inc., 59
314 #gen_list.c: * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
316 #gen_list.c: * VI users : Please "set tabstop=3 shiftwidth=3" to view this file,
317 #gen_list.c: * and edit IJB, correctly.
319 #gen_list.c: * Revisions :
320 #gen_list.c: * $Log: contrib.sh,v $
321 #gen_list.c: * Revision 1.1 2001/12/07 01:54:50 iwanttokeepanon
322 #gen_list.c: * A contribution/recomendation to the IJBSWA group for a generic doubly
323 #gen_list.c: * linked list. This file is a home brew "bash tar" (I cannot create a
324 #gen_list.c: * contrib directory and I cannot upload a tarball ... it gets
325 #gen_list.c: * corrupted). This script will expand all files needed to create the
326 #gen_list.c: * linked list modules and an example program. Please see the README.
327 #gen_list.c: * Feed back is welcomed. Enjoy.
330 #gen_list.c: *********************************************************************/
333 #gen_list.c:#include <malloc.h>
334 #gen_list.c:#include <stdio.h>
335 #gen_list.c:#include <stdlib.h>
336 #gen_list.c:#include <string.h>
338 #gen_list.c:#include "gen_list.h"
339 #gen_list.c:#include "malloc_police.h"
341 #gen_list.c:const char gen_list_h_rcs[] = GEN_LIST_H_VERSION;
344 #gen_list.c:/* This is used (for the moment) to cut out all the */
345 #gen_list.c:/* extra verbige of the malloc_police module. After */
346 #gen_list.c:/* all, we do not want to see construct/destruct of a */
347 #gen_list.c:/* class that is supposed to be "in the background". */
349 #gen_list.c:/* But it could lead to broader usage. */
351 #gen_list.c:int list_is_quiet = 0;
354 #gen_list.c:#define CALL_VT_REC_COPY_CONSTRUCT(rec) (((rec_copy_construct)(rec)->vtable[ VT_REC_COPY_CONSTRUCT ])( rec ))
355 #gen_list.c:#define CALL_VT_REC_DESTRUCT(rec) (((rec_destruct)(rec)->vtable[ VT_REC_DESTRUCT ])( rec ))
356 #gen_list.c:#define CALL_VT_REC_STREAM(rec) (((rec_stream)(rec)->vtable[ VT_REC_STREAM ])( rec ))
357 #gen_list.c:#define CALL_VT_REC_EQUAL(rec,eq_rec) (((rec_equal)((rec)->vtable[ VT_REC_EQUAL ]))( rec, eq_rec ))
360 #gen_list.c:/*********************************************************************
362 #gen_list.c: * Function : gen_list_rec_construct
364 #gen_list.c: * Description : Called from a derived list record class ONLY.
365 #gen_list.c: * This function "construct" a classs: malloc_ed,
366 #gen_list.c: * vtable, isa, and sizeof_rec "attributes".
368 #gen_list.c: * Parameters :
369 #gen_list.c: * 1 : The record. If NULL, malloc is called.
370 #gen_list.c: * 2 : isa (prounced "is a") ... type of the record.
371 #gen_list.c: * 3 : Memory image size of this record.
372 #gen_list.c: * ... : The "virtuals" for this record. NOTE: this list
373 #gen_list.c: * may increase if more "virtuals" are added.
375 #gen_list.c: * Returns : A pointer to the record (either the orig record
376 #gen_list.c: * or the malloc_ed copy.
378 #gen_list.c: *********************************************************************/
379 #gen_list.c:struct gen_list_rec *gen_list_rec_construct( enum GEN_LIST_ISA isa, int sizeof_rec, const t_vtable _vtable )
381 #gen_list.c: struct gen_list_rec *this_rec = (struct gen_list_rec *)MALLOC( sizeof_rec );
382 #gen_list.c: this_rec->vtable = _vtable;
383 #gen_list.c: this_rec->isa = isa;
384 #gen_list.c: this_rec->sizeof_rec = sizeof_rec;
386 #gen_list.c: return( this_rec );
391 #gen_list.c:/*********************************************************************
393 #gen_list.c: * Function : gen_list_rec_copy_construct
395 #gen_list.c: * Description : Makes a copy of the current existing record. All
396 #gen_list.c: * inherited properties (isa, vtable, malloc_ed, ...)
397 #gen_list.c: * are kept in tact after the copy.
399 #gen_list.c: * Parameters :
400 #gen_list.c: * 1 : Existing record.
401 #gen_list.c: * 2 : New record.
403 #gen_list.c: * Returns : The newly constructed copy record.
405 #gen_list.c: *********************************************************************/
406 #gen_list.c:struct gen_list_rec *gen_list_rec_copy_construct( const struct gen_list_rec *this_rec )
408 #gen_list.c: struct gen_list_rec *copy_rec = (struct gen_list_rec *)MALLOC( this_rec->sizeof_rec );
409 #gen_list.c: copy_rec->vtable = this_rec->vtable;
410 #gen_list.c: copy_rec->isa = this_rec->isa;
411 #gen_list.c: copy_rec->sizeof_rec = this_rec->sizeof_rec;
413 #gen_list.c: return( copy_rec );
418 #gen_list.c:/*********************************************************************
420 #gen_list.c: * Function : gen_list_rec_destruct
422 #gen_list.c: * Description : Destruct the record. Including free_ing the memory
423 #gen_list.c: * if applicable.
425 #gen_list.c: * Parameters :
426 #gen_list.c: * 1 : The record.
428 #gen_list.c: * Returns : NULL
430 #gen_list.c: *********************************************************************/
431 #gen_list.c:struct gen_list_rec *gen_list_rec_destruct( struct gen_list_rec *this_rec )
433 #gen_list.c: FREE( this_rec );
434 #gen_list.c: return( NULL );
439 #gen_list.c:/*********************************************************************
441 #gen_list.c: * Function : gen_list_rec_stream
443 #gen_list.c: * Description : Displays all attributes on the STDOUT stream.
445 #gen_list.c: * Parameters :
446 #gen_list.c: * 1 : The record.
448 #gen_list.c: * Returns : The record.
450 #gen_list.c: *********************************************************************/
451 #gen_list.c:const struct gen_list_rec *gen_list_rec_stream( const struct gen_list_rec *this_rec )
453 #gen_list.c: LIST_SHOW( printf( "\t\tstream rec isa = %s\n", isa_ra[ this_rec->isa ] ) );
454 #gen_list.c: return( this_rec );
459 #gen_list.c:/*********************************************************************
461 #gen_list.c: * Function : gen_list_rec_equal
463 #gen_list.c: * Description : Compares two records to see if they are equal.
465 #gen_list.c: * Parameters :
466 #gen_list.c: * 1 : A record.
467 #gen_list.c: * 2 : Another record.
469 #gen_list.c: * Returns : 0 => NOT EQUAL, anything else is EQUAL.
471 #gen_list.c: *********************************************************************/
472 #gen_list.c:int gen_list_rec_equal( const struct gen_list_rec *this_rec, const struct gen_list_rec *eq_rec )
474 #gen_list.c: if ( NULL == this_rec && NULL == eq_rec )
476 #gen_list.c: return( 1 );
479 #gen_list.c: if ( ( NULL == this_rec && NULL != eq_rec ) ||
480 #gen_list.c: ( NULL != this_rec && NULL == eq_rec ) )
482 #gen_list.c: return( 0 );
485 #gen_list.c: if ( ( this_rec->isa != eq_rec->isa ) ||
486 #gen_list.c: ( this_rec->sizeof_rec != eq_rec->sizeof_rec ) )
488 #gen_list.c: LIST_SHOW( printf( "INFORMATION: sorry, but comparing different rec types is unsupported at this time.\n" ) );
489 #gen_list.c: return( 0 );
492 #gen_list.c: return( 1 );
497 #gen_list.c:/*
\f*********************************************************************/
500 #gen_list.c:struct gen_list_node
502 #gen_list.c: /* private: */
503 #gen_list.c: struct gen_list_node *next;
504 #gen_list.c: struct gen_list_node *prev;
506 #gen_list.c: struct gen_list_rec *rec;
508 #gen_list.c:/* public: */
509 #gen_list.c:extern struct gen_list_node * gen_list_node_construct( struct gen_list_rec *_rec );
510 #gen_list.c:extern struct gen_list_node * gen_list_node_copy_construct( const struct gen_list_node *this_node );
511 #gen_list.c:extern struct gen_list_node * gen_list_node_destruct( struct gen_list_node *this_node );
512 #gen_list.c:extern struct gen_list_node * gen_list_node_remove( struct gen_list_node *this_node );
514 #gen_list.c:extern struct gen_list_node * gen_list_node_set_next( struct gen_list_node *this_node, struct gen_list_node *_next );
515 #gen_list.c:extern struct gen_list_node * gen_list_node_set_prev( struct gen_list_node *this_node, struct gen_list_node *_prev );
517 #gen_list.c:extern struct gen_list_node * gen_list_node_get_next( const struct gen_list_node *this_node );
518 #gen_list.c:extern struct gen_list_node * gen_list_node_get_prev( const struct gen_list_node *this_node );
520 #gen_list.c:extern const struct gen_list_rec * gen_list_node_stream( const struct gen_list_node *this_node );
521 #gen_list.c:extern int gen_list_node_equal( const struct gen_list_node *this_node, const struct gen_list_node *eq_node );
523 #gen_list.c:/* struct/class COMPLETE */
526 #gen_list.c:/*********************************************************************
528 #gen_list.c: * Function : gen_list_node_construct
530 #gen_list.c: * Description : Constructs a generic list node and sets its record.
532 #gen_list.c: * Parameters :
533 #gen_list.c: * 1 : The node. If NULL, malloc is called.
534 #gen_list.c: * 2 : The nodes record contents.
536 #gen_list.c: * Returns : A pointer to the node (either the orig node
537 #gen_list.c: * or the malloc_ed copy.
539 #gen_list.c: *********************************************************************/
540 #gen_list.c:struct gen_list_node *gen_list_node_construct( struct gen_list_rec *_rec )
542 #gen_list.c: struct gen_list_node *this_node = (struct gen_list_node *)MALLOC( sizeof( struct gen_list_node ) );
544 #gen_list.c: LIST_SHOW( printf( "\
545 #gen_list.c:\tconstruct new node\t\t= %p
546 #gen_list.c:\tconstruct new node->rec\t= %p\n\n", (const void *)this_node, (const void *)_rec ) );
548 #gen_list.c: this_node->rec = _rec;
549 #gen_list.c: this_node->next = NULL;
550 #gen_list.c: this_node->prev = NULL;
552 #gen_list.c: return( this_node );
557 #gen_list.c:/*********************************************************************
559 #gen_list.c: * Function : gen_list_node_copy_construct
561 #gen_list.c: * Description : Makes a copy of the current node.
563 #gen_list.c: * Parameters :
564 #gen_list.c: * 1 : Existing node.
565 #gen_list.c: * 2 : New node.
567 #gen_list.c: * Returns : The newly constructed copy node.
569 #gen_list.c: *********************************************************************/
570 #gen_list.c:struct gen_list_node *gen_list_node_copy_construct( const struct gen_list_node *this_node )
572 #gen_list.c: struct gen_list_node *copy_node = (struct gen_list_node *)MALLOC( sizeof( struct gen_list_node ) );
574 #gen_list.c: LIST_SHOW( printf( "\tcopy construct new node = %p => %p\n\n", (const void *)this_node, (const void *)copy_node ) );
576 #gen_list.c: copy_node->rec = CALL_VT_REC_COPY_CONSTRUCT( this_node->rec );
577 #gen_list.c: copy_node->next = NULL;
578 #gen_list.c: copy_node->prev = NULL;
580 #gen_list.c: return( copy_node );
585 #gen_list.c:/*********************************************************************
587 #gen_list.c: * Function : gen_list_node_destruct
589 #gen_list.c: * Description : Destruct the node. Including free_ing the memory
590 #gen_list.c: * if applicable.
592 #gen_list.c: * Parameters :
593 #gen_list.c: * 1 : The node.
595 #gen_list.c: * Returns : NULL
597 #gen_list.c: *********************************************************************/
598 #gen_list.c:struct gen_list_node *gen_list_node_destruct( struct gen_list_node *this_node )
600 #gen_list.c: LIST_SHOW( printf( "\
601 #gen_list.c:\tdestruct this_node\t\t\t= %p
602 #gen_list.c:\tdestruct this_node->rec\t\t= %p
603 #gen_list.c:\tdestruct this_node->next\t= %p
604 #gen_list.c:\tdestruct this_node->prev\t= %p\n\n", (const void *)this_node, (const void *)this_node->rec, (const void *)this_node->next, (const void *)this_node->prev ) );
606 #gen_list.c: if ( NULL != this_node->rec )
608 #gen_list.c: CALL_VT_REC_DESTRUCT( this_node->rec );
611 #gen_list.c: FREE( this_node );
612 #gen_list.c: return( NULL );
617 #gen_list.c:/*********************************************************************
619 #gen_list.c: * Function : gen_list_node_remove
621 #gen_list.c: * Description : Destruct the node. Including free_ing the memory
622 #gen_list.c: * if applicable.
624 #gen_list.c: * Parameters :
625 #gen_list.c: * 1 : The node.
627 #gen_list.c: * Returns : NULL
629 #gen_list.c: *********************************************************************/
630 #gen_list.c:struct gen_list_node *gen_list_node_remove( struct gen_list_node *this_node )
632 #gen_list.c: LIST_SHOW( printf( "\
633 #gen_list.c:\tremove this_node\t\t\t= %p
634 #gen_list.c:\tremove this_node->rec\t= %p
635 #gen_list.c:\tremove this_node->next\t= %p
636 #gen_list.c:\tremove this_node->prev\t= %p\n\n", (const void *)this_node, (const void *)this_node->rec, (const void *)this_node->next, (const void *)this_node->prev ) );
638 #gen_list.c: FREE( this_node );
639 #gen_list.c: return( NULL );
644 #gen_list.c:/*********************************************************************
646 #gen_list.c: * Function : gen_list_node_set_next
648 #gen_list.c: * Description : Sets the next node in the list series. Used mainly
649 #gen_list.c: * when constructing and adding/removing nodes.
651 #gen_list.c: * Parameters :
652 #gen_list.c: * 1 : The node.
653 #gen_list.c: * 2 : The next node.
655 #gen_list.c: * Returns : The node.
657 #gen_list.c: *********************************************************************/
658 #gen_list.c:struct gen_list_node *gen_list_node_set_next( struct gen_list_node *this_node, struct gen_list_node *_next )
660 #gen_list.c: this_node->next = _next;
661 #gen_list.c: return( this_node );
666 #gen_list.c:/*********************************************************************
668 #gen_list.c: * Function : gen_list_node_set_prev
670 #gen_list.c: * Description : Sets the previous node in the list series. Used mainly
671 #gen_list.c: * when constructing and adding/removing nodes.
673 #gen_list.c: * Parameters :
674 #gen_list.c: * 1 : The node.
675 #gen_list.c: * 2 : The previous node.
677 #gen_list.c: * Returns : The node.
679 #gen_list.c: *********************************************************************/
680 #gen_list.c:struct gen_list_node *gen_list_node_set_prev( struct gen_list_node *this_node, struct gen_list_node *_prev )
682 #gen_list.c: this_node->prev = _prev;
683 #gen_list.c: return( this_node );
688 #gen_list.c:/*********************************************************************
690 #gen_list.c: * Function : gen_list_node_get_next
692 #gen_list.c: * Description : Gets the next node in the list series. Used mainly
693 #gen_list.c: * for traversing a list.
695 #gen_list.c: * Parameters :
696 #gen_list.c: * 1 : The node.
698 #gen_list.c: * Returns : The next node.
700 #gen_list.c: *********************************************************************/
701 #gen_list.c:struct gen_list_node *gen_list_node_get_next( const struct gen_list_node *this_node )
703 #gen_list.c: return( this_node->next );
708 #gen_list.c:/*********************************************************************
710 #gen_list.c: * Function : gen_list_node_get_prev
712 #gen_list.c: * Description : Gets the previous node in the list series. Used mainly
713 #gen_list.c: * for traversing a list.
715 #gen_list.c: * Parameters :
716 #gen_list.c: * 1 : The node.
718 #gen_list.c: * Returns : The previous node.
720 #gen_list.c: *********************************************************************/
721 #gen_list.c:struct gen_list_node *gen_list_node_get_prev( const struct gen_list_node *this_node )
723 #gen_list.c: return( this_node->prev );
728 #gen_list.c:/*********************************************************************
730 #gen_list.c: * Function : gen_list_node_stream
732 #gen_list.c: * Description : Displays all attributes on the STDOUT stream,
733 #gen_list.c: * including the contents of the nodes record.
735 #gen_list.c: * Parameters :
736 #gen_list.c: * 1 : The record.
738 #gen_list.c: * Returns : The result of streaming the nodes record.
740 #gen_list.c: *********************************************************************/
741 #gen_list.c:const struct gen_list_rec *gen_list_node_stream( const struct gen_list_node *this_node )
743 #gen_list.c: LIST_SHOW( printf( "\
744 #gen_list.c:\tstream this_node\t\t\t= %p
745 #gen_list.c:\tstream this_node->rec\t= %p
746 #gen_list.c:\tstream this_node->next\t= %p
747 #gen_list.c:\tstream this_node->prev\t= %p\n\n", (const void *)this_node, (const void *)this_node->rec, (const void *)this_node->next, (const void *)this_node->prev ) );
749 #gen_list.c: return( CALL_VT_REC_STREAM( this_node->rec ) );
754 #gen_list.c:/*********************************************************************
756 #gen_list.c: * Function : gen_list_node_equal
758 #gen_list.c: * Description : Compares two nodes (and their records) to see if they are equal.
760 #gen_list.c: * Parameters :
761 #gen_list.c: * 1 : A node.
762 #gen_list.c: * 2 : Another node.
764 #gen_list.c: * Returns : 0 => NOT EQUAL, anything else is EQUAL.
766 #gen_list.c: *********************************************************************/
767 #gen_list.c:int gen_list_node_equal( const struct gen_list_node *this_node, const struct gen_list_node *eq_node )
769 #gen_list.c: if ( NULL == this_node && NULL == eq_node )
771 #gen_list.c: return( 1 );
774 #gen_list.c: if ( ( NULL == this_node && NULL != eq_node ) ||
775 #gen_list.c: ( NULL != this_node && NULL == eq_node ) )
777 #gen_list.c: return( 0 );
780 #gen_list.c: return( gen_list_rec_equal( this_node->rec, eq_node->rec ) );
785 #gen_list.c:/*
\f*********************************************************************/
788 #gen_list.c:/* private: */
789 #gen_list.c:/*********************************************************************
791 #gen_list.c: * Function : gen_list_insert_node
793 #gen_list.c: * Description : Inserts a node (not a record!) into a list. This
794 #gen_list.c: * is (currently) only used in copy construction.
796 #gen_list.c: * Parameters :
797 #gen_list.c: * 1 : The list.
798 #gen_list.c: * 2 : A new node to insert into the list.
800 #gen_list.c: * Returns : The node.
802 #gen_list.c: *********************************************************************/
803 #gen_list.c:const struct gen_list_node *gen_list_insert_node( struct gen_list *this_list, struct gen_list_node *node )
805 #gen_list.c: gen_list_node_set_next( node, NULL );
807 #gen_list.c: if ( NULL == this_list->first )
809 #gen_list.c: this_list->first = node;
812 #gen_list.c: if ( NULL == this_list->last )
814 #gen_list.c: this_list->last = node;
818 #gen_list.c: gen_list_node_set_next( this_list->last, node );
819 #gen_list.c: gen_list_node_set_prev( node, this_list->last );
820 #gen_list.c: this_list->last = node;
823 #gen_list.c: this_list->last = node;
825 #gen_list.c: return( node );
830 #gen_list.c:/*********************************************************************
832 #gen_list.c: * Function : gen_list_construct
834 #gen_list.c: * Description : Constructs a generic list.
836 #gen_list.c: * Parameters : None
838 #gen_list.c: * Returns : A pointer to the list (either the orig list
839 #gen_list.c: * or the malloc_ed copy.
841 #gen_list.c: *********************************************************************/
842 #gen_list.c:struct gen_list *gen_list_construct()
844 #gen_list.c: struct gen_list *this_list = (struct gen_list *)MALLOC( sizeof( struct gen_list ) );
845 #gen_list.c: LIST_SHOW( printf( "construct new list = %p\n\n", (const void *)this_list ) );
847 #gen_list.c: this_list->first = NULL;
848 #gen_list.c: this_list->last = NULL;
850 #gen_list.c: return( this_list );
855 #gen_list.c:/*********************************************************************
857 #gen_list.c: * Function : gen_list_copy_construct
859 #gen_list.c: * Description : Makes a copy of the current list.
861 #gen_list.c: * Parameters :
862 #gen_list.c: * 1 : Existing list.
863 #gen_list.c: * 2 : New list.
865 #gen_list.c: * Returns : The newly constructed copy list.
867 #gen_list.c: *********************************************************************/
868 #gen_list.c:struct gen_list *gen_list_copy_construct( const struct gen_list *this_list )
870 #gen_list.c: struct gen_list_node *curr = this_list->first;
871 #gen_list.c: struct gen_list *copy_list = (struct gen_list *)MALLOC( sizeof( struct gen_list ) );
873 #gen_list.c: LIST_SHOW( printf( "copy construct new list = %p => %p\n\n", (const void *)this_list, (const void *)copy_list ) );
875 #gen_list.c: copy_list->first = NULL;
876 #gen_list.c: copy_list->last = NULL;
879 #gen_list.c: while ( NULL != curr )
881 #gen_list.c: struct gen_list_node *copy_node = gen_list_node_copy_construct( curr );
882 #gen_list.c: gen_list_insert_node( copy_list, copy_node );
883 #gen_list.c: curr = gen_list_node_get_next( curr );
886 #gen_list.c: return( copy_list );
891 #gen_list.c:/*********************************************************************
893 #gen_list.c: * Function : gen_list_destruct
895 #gen_list.c: * Description : Destruct the list. Including free_ing the memory
896 #gen_list.c: * if applicable.
898 #gen_list.c: * Parameters :
899 #gen_list.c: * 1 : The list.
901 #gen_list.c: * Returns : NULL
903 #gen_list.c: *********************************************************************/
904 #gen_list.c:struct gen_list *gen_list_destruct( struct gen_list *this_list )
906 #gen_list.c: struct gen_list_node *curr = this_list->first;
908 #gen_list.c: LIST_SHOW( printf( "\
909 #gen_list.c:destruct this_list\t\t\t= %p
910 #gen_list.c:destruct this_list->first\t= %p
911 #gen_list.c:destruct this_list->last\t= %p\n\n", (const void *)this_list, (const void *)this_list->first, (const void *)this_list->last ) );
913 #gen_list.c: while ( NULL != curr )
915 #gen_list.c: struct gen_list_node *next = gen_list_node_get_next( curr );
916 #gen_list.c: gen_list_node_destruct( curr );
917 #gen_list.c: curr = next;
920 #gen_list.c: FREE( this_list );
921 #gen_list.c: return( NULL );
926 #gen_list.c:/*********************************************************************
928 #gen_list.c: * Function : gen_list_remove_all
930 #gen_list.c: * Description : Destruct the list. Including free_ing the memory
931 #gen_list.c: * if applicable.
933 #gen_list.c: * Parameters :
934 #gen_list.c: * 1 : The list.
936 #gen_list.c: * Returns : NULL
938 #gen_list.c: *********************************************************************/
939 #gen_list.c:struct gen_list *gen_list_remove_all( struct gen_list *this_list )
941 #gen_list.c: struct gen_list_node *curr = this_list->first;
943 #gen_list.c: LIST_SHOW( printf( "\
944 #gen_list.c:remove_all this_list\t\t\t\t= %p
945 #gen_list.c:remove_all this_list->first\t= %p
946 #gen_list.c:remove_all this_list->last\t\t= %p\n\n", (const void *)this_list, (const void *)this_list->first, (const void *)this_list->last ) );
948 #gen_list.c: while ( NULL != curr )
950 #gen_list.c: struct gen_list_node *next = gen_list_node_get_next( curr );
951 #gen_list.c: gen_list_node_remove( curr );
952 #gen_list.c: curr = next;
955 #gen_list.c: this_list->first = this_list->last = NULL;
956 #gen_list.c: return( this_list );
961 #gen_list.c:/*********************************************************************
963 #gen_list.c: * Function : gen_list_remove
965 #gen_list.c: * Description : A record from the list and return it if found. This
966 #gen_list.c: * will allow a futher call to rec_destruct.
968 #gen_list.c: * Parameters :
969 #gen_list.c: * 1 : The list.
970 #gen_list.c: * 2 : The record to be removed.
972 #gen_list.c: * Returns : rec if found and removed, NULL otherwise.
974 #gen_list.c: *********************************************************************/
975 #gen_list.c:struct gen_list_rec *gen_list_remove( struct gen_list *this_list, struct gen_list_rec *rec )
977 #gen_list.c: struct gen_list_node *curr = this_list->first;
979 #gen_list.c: LIST_SHOW( printf( "\
980 #gen_list.c:remove this_list\t\t\t= %p
981 #gen_list.c:remove this_list->first\t= %p
982 #gen_list.c:remove this_list->last\t= %p
983 #gen_list.c:remove rec\t\t\t\t\t= %p\n\n", (const void *)this_list, (const void *)this_list->first, (const void *)this_list->last, rec ) );
985 #gen_list.c: while ( NULL != curr )
987 #gen_list.c: /* Grab these values before the are destroyed. */
988 #gen_list.c: struct gen_list_node *prev = gen_list_node_get_prev( curr );
989 #gen_list.c: struct gen_list_node *next = gen_list_node_get_next( curr );
991 #gen_list.c: /* Access to rec, next, prev of gen_list_node is allowed since it is private to gen_list */
992 #gen_list.c: if ( curr->rec == rec )
994 #gen_list.c: /* Destruct the node, but not the record. */
995 #gen_list.c: gen_list_node_remove( curr );
997 #gen_list.c: if ( NULL == prev )
999 #gen_list.c: /************************************************/
1000 #gen_list.c: /* This is the first node in the list. */
1001 #gen_list.c: /* Picture: */
1002 #gen_list.c: /* [first] ---------------------> [next] */
1003 #gen_list.c: /* [NULL] <---------------------- [next->prev] */
1004 #gen_list.c: /************************************************/
1005 #gen_list.c: this_list->first = next;
1007 #gen_list.c: if ( NULL == next )
1009 #gen_list.c: /* Since next is NULL, then this is an empty list. */
1010 #gen_list.c: this_list->last = NULL;
1014 #gen_list.c: /* Since next is not NULL, then there is another node to make first. */
1015 #gen_list.c: gen_list_node_set_prev( next, NULL );
1018 #gen_list.c: else if ( NULL == next )
1020 #gen_list.c: /************************************************/
1021 #gen_list.c: /* This is the last node in the list. */
1022 #gen_list.c: /* Picture: */
1023 #gen_list.c: /* [last] ----------------------> [prev] */
1024 #gen_list.c: /* [prev->next] ----------------> [NULL] */
1025 #gen_list.c: /************************************************/
1026 #gen_list.c: this_list->last = prev;
1028 #gen_list.c: if ( NULL == prev )
1030 #gen_list.c: /* Since prev is NULL, then this is an empty list. */
1031 #gen_list.c: this_list->first = NULL;
1035 #gen_list.c: /* Since prev is NULL, then there is another node to make last. */
1036 #gen_list.c: gen_list_node_set_next( prev, NULL );
1041 #gen_list.c: /************************************************/
1042 #gen_list.c: /* This is a middle node in the list. */
1043 #gen_list.c: /* Picture: */
1044 #gen_list.c: /* [prev->next] ----------------> [next] */
1045 #gen_list.c: /* [removing middle] */
1046 #gen_list.c: /* [prev] <---------------------- [next->prev] */
1047 #gen_list.c: /************************************************/
1048 #gen_list.c: gen_list_node_set_next( prev, next );
1049 #gen_list.c: gen_list_node_set_prev( next, prev );
1052 #gen_list.c: return( rec );
1054 #gen_list.c: curr = next;
1057 #gen_list.c: return( NULL );
1062 #gen_list.c:/*********************************************************************
1064 #gen_list.c: * Function : gen_list_get_first
1066 #gen_list.c: * Description : Gets the first record in the list.
1068 #gen_list.c: * Parameters :
1069 #gen_list.c: * 1 : The list.
1071 #gen_list.c: * Returns : The first node.
1073 #gen_list.c: *********************************************************************/
1074 #gen_list.c:struct gen_list_rec *gen_list_get_first( const struct gen_list *this_list )
1076 #gen_list.c: if ( NULL == this_list->first )
1078 #gen_list.c: return( NULL );
1081 #gen_list.c: /* Access to rec of gen_list_node is allowed since it is private to gen_list */
1082 #gen_list.c: return( this_list->first->rec );
1087 #gen_list.c:/*********************************************************************
1089 #gen_list.c: * Function : gen_list_get_last
1091 #gen_list.c: * Description : Gets the last record in the list.
1093 #gen_list.c: * Parameters :
1094 #gen_list.c: * 1 : The list.
1096 #gen_list.c: * Returns : The last node.
1098 #gen_list.c: *********************************************************************/
1099 #gen_list.c:struct gen_list_rec *gen_list_get_last( const struct gen_list *this_list )
1101 #gen_list.c: if ( NULL == this_list->last )
1103 #gen_list.c: return( NULL );
1106 #gen_list.c: /* Access to rec of gen_list_node is allowed since it is private to gen_list */
1107 #gen_list.c: return( this_list->last->rec );
1112 #gen_list.c:/*********************************************************************
1114 #gen_list.c: * Function : gen_list_insert
1116 #gen_list.c: * Description : Inserts a record into the list. This is the
1117 #gen_list.c: * primary API interface for inserting a record.
1119 #gen_list.c: * Parameters :
1120 #gen_list.c: * 1 : The list.
1121 #gen_list.c: * 2 : A new record to insert into the list.
1123 #gen_list.c: * Returns : The node.
1125 #gen_list.c: *********************************************************************/
1126 #gen_list.c:const struct gen_list_node *gen_list_insert( struct gen_list *this_list, struct gen_list_rec *_rec )
1128 #gen_list.c: return( gen_list_insert_node( this_list, gen_list_node_construct( _rec ) ) );
1133 #gen_list.c:/*********************************************************************
1135 #gen_list.c: * Function : gen_list_stream
1137 #gen_list.c: * Description : Displays all attributes on the STDOUT stream,
1138 #gen_list.c: * including the contents of the nodes.
1140 #gen_list.c: * Parameters :
1141 #gen_list.c: * 1 : The list.
1143 #gen_list.c: * Returns : The list.
1145 #gen_list.c: *********************************************************************/
1146 #gen_list.c:const struct gen_list *gen_list_stream( const struct gen_list *this_list )
1148 #gen_list.c: const struct gen_list_node *curr = this_list->first;
1150 #gen_list.c: LIST_SHOW( printf( "\
1151 #gen_list.c:stream this_list\t\t\t= %p
1152 #gen_list.c:stream this_list->first\t= %p
1153 #gen_list.c:stream this_list->last\t= %p\n\n", (const void *)this_list, (const void *)this_list->first, (const void *)this_list->last ) );
1155 #gen_list.c: while ( NULL != curr )
1157 #gen_list.c: struct gen_list_node *next = gen_list_node_get_next( curr );
1158 #gen_list.c: gen_list_node_stream( curr );
1159 #gen_list.c: curr = next;
1162 #gen_list.c: return( this_list );
1167 #gen_list.c:/*********************************************************************
1169 #gen_list.c: * Function : gen_list_equal
1171 #gen_list.c: * Description : Compares two lists (and their nodes) to see if they are equal.
1173 #gen_list.c: * Parameters :
1174 #gen_list.c: * 1 : A list.
1175 #gen_list.c: * 2 : Another list.
1177 #gen_list.c: * Returns : 0 => NOT EQUAL, anything else is EQUAL.
1179 #gen_list.c: *********************************************************************/
1180 #gen_list.c:int gen_list_equal( const struct gen_list *this_list, const struct gen_list *eq_list )
1182 #gen_list.c: struct gen_list_node *c1 = this_list->first;
1183 #gen_list.c: struct gen_list_node *c2 = eq_list->first;
1184 #gen_list.c: int eq = 1;
1186 #gen_list.c: if ( ( NULL == c1 && NULL != c2 ) || ( NULL != c1 && NULL == c2 ) )
1188 #gen_list.c: return( 0 );
1191 #gen_list.c: while ( ( eq ) && ( NULL != c1 ) && ( NULL != c2 ) )
1193 #gen_list.c: /* Access to rec of gen_list_node is allowed since it is private to gen_list */
1194 #gen_list.c: eq = CALL_VT_REC_EQUAL( c1->rec, c2->rec );
1195 #gen_list.c: if ( NULL != c1 )
1197 #gen_list.c: c1 = gen_list_node_get_next( c1 );
1200 #gen_list.c: if ( NULL != c2 )
1202 #gen_list.c: c2 = gen_list_node_get_next( c2 );
1207 #gen_list.c: if ( NULL == c1 && NULL == c2 )
1209 #gen_list.c: return( 1 );
1212 #gen_list.c: return( eq );
1217 #gen_list.c:/*********************************************************************
1219 #gen_list.c: * Function : gen_list_find
1221 #gen_list.c: * Description : Find a record that matches the one passed to this
1222 #gen_list.c: * function.
1223 #gen_list.c: * NOTE: this function receives a RECORD and not a NODE.
1224 #gen_list.c: * Some implementation issues might be easier addressed
1225 #gen_list.c: * if a node was passed ... but for the time being, I
1226 #gen_list.c: * would like to keep the use/programmer isolated from
1227 #gen_list.c: * the node structure/class.
1229 #gen_list.c: * Parameters :
1230 #gen_list.c: * 1 : The list.
1231 #gen_list.c: * 2 : The record to find.
1233 #gen_list.c: * Returns : NULL => none found, anything else is a pointer to the record.
1235 #gen_list.c: *********************************************************************/
1236 #gen_list.c:struct gen_list_rec *gen_list_find( const struct gen_list *this_list, struct gen_list_rec *rec )
1238 #gen_list.c: const struct gen_list_node *curr = this_list->first;
1239 #gen_list.c: int eq = 0;
1241 #gen_list.c: if ( NULL == curr && NULL == rec )
1243 #gen_list.c: return( (struct gen_list_rec *)1 );
1246 #gen_list.c: if ( ( NULL == curr && NULL != rec ) ||
1247 #gen_list.c: ( NULL != curr && NULL == rec ) )
1249 #gen_list.c: return( 0 );
1252 #gen_list.c: /* Access to rec of gen_list_node is allowed since it is private to gen_list */
1253 #gen_list.c: if ( curr->rec->isa != rec->isa )
1255 #gen_list.c: LIST_SHOW( printf( "INFORMATION: sorry, but comparing different list types is unsupported at this time.\n" ) );
1256 #gen_list.c: return( 0 );
1259 #gen_list.c: if ( NULL == curr )
1261 #gen_list.c: return( NULL );
1265 #gen_list.c: while ( ( !eq ) && ( NULL != curr ) )
1267 #gen_list.c: struct gen_list_node *next = gen_list_node_get_next( curr );
1269 #gen_list.c: eq = CALL_VT_REC_EQUAL( curr->rec, rec );
1271 #gen_list.c: if ( eq )
1273 #gen_list.c: return( curr->rec );
1276 #gen_list.c: curr = next;
1280 #gen_list.c: return( NULL );
1285 #gen_list.c:/*********************************************************************
1287 #gen_list.c: * Function : gen_list_iterate
1289 #gen_list.c: * Description : Pass over the list, calling "iter" for every record.
1290 #gen_list.c: * If the "iter" function returns a non-NULL value,
1291 #gen_list.c: * return it and stop iterating.
1293 #gen_list.c: * Parameters :
1294 #gen_list.c: * 1 : The list.
1295 #gen_list.c: * 2 : The iterator function.
1297 #gen_list.c: * Returns : Whatever the iterator does, or NULL if the entire
1298 #gen_list.c: * list was processed.
1300 #gen_list.c: *********************************************************************/
1301 #gen_list.c:struct gen_list_rec *gen_list_iterate( struct gen_list *this_list, rec_iterate iter )
1303 #gen_list.c: struct gen_list_node *curr = this_list->first;
1305 #gen_list.c: if ( NULL == curr )
1307 #gen_list.c: return( NULL );
1310 #gen_list.c: while ( NULL != curr )
1312 #gen_list.c: /* Access to rec of gen_list_node is allowed since it is private to gen_list */
1313 #gen_list.c: struct gen_list_node *next = gen_list_node_get_next( curr );
1314 #gen_list.c: struct gen_list_rec *r = iter( curr->rec );
1316 #gen_list.c: if ( NULL != r )
1318 #gen_list.c: return( r );
1321 #gen_list.c: curr = next;
1325 #gen_list.c: return( NULL );
1330 #gen_list.c:/*********************************************************************
1332 #gen_list.c: * Function : gen_list_iterate
1334 #gen_list.c: * Description : Pass over the list (in reverse order), calling "iter"
1335 #gen_list.c: * for every record. If the "iter" function returns
1336 #gen_list.c: * a non-NULL value, return it and stop iterating.
1338 #gen_list.c: * Parameters :
1339 #gen_list.c: * 1 : The list.
1340 #gen_list.c: * 2 : The iterator function.
1342 #gen_list.c: * Returns : Whatever the iterator does, or NULL if the entire
1343 #gen_list.c: * list was processed.
1345 #gen_list.c: *********************************************************************/
1346 #gen_list.c:struct gen_list_rec *gen_list_iterate_reverse( struct gen_list *this_list, rec_iterate iter )
1348 #gen_list.c: struct gen_list_node *curr = this_list->last;
1350 #gen_list.c: if ( NULL == curr )
1352 #gen_list.c: return( NULL );
1355 #gen_list.c: while ( NULL != curr )
1357 #gen_list.c: /* Access to rec of gen_list_node is allowed since it is private to gen_list */
1358 #gen_list.c: struct gen_list_node *prev = gen_list_node_get_prev( curr );
1359 #gen_list.c: struct gen_list_rec *r = iter( curr->rec );
1361 #gen_list.c: if ( NULL != r )
1363 #gen_list.c: return( r );
1366 #gen_list.c: curr = prev;
1370 #gen_list.c: return( NULL );
1375 #gen_list.h:#ifndef GEN_LIST_H_INCLUDED
1376 #gen_list.h:#define GEN_LIST_H_INCLUDED
1377 #gen_list.h:#define GEN_LIST_H_VERSION "$Id: contrib.sh,v 1.1 2001/12/07 01:54:50 iwanttokeepanon Exp $"
1378 #gen_list.h:/*********************************************************************
1380 #gen_list.h: * File : $Source: /cvsroot/ijbswa/current/contrib.sh,v $
1382 #gen_list.h: * Purpose : To create some functions to do generic doubly linked
1383 #gen_list.h: * list management.
1385 #gen_list.h: * Copyright : Written by and Copyright (C) 2001 the SourceForge
1386 #gen_list.h: * Privoxy team. http://ijbswa.sourceforge.net
1388 #gen_list.h: * This program is free software; you can redistribute it
1389 #gen_list.h: * and/or modify it under the terms of the GNU General
1390 #gen_list.h: * Public License as published by the Free Software
1391 #gen_list.h: * Foundation; either version 2 of the License, or (at
1392 #gen_list.h: * your option) any later version.
1394 #gen_list.h: * This program is distributed in the hope that it will
1395 #gen_list.h: * be useful, but WITHOUT ANY WARRANTY; without even the
1396 #gen_list.h: * implied warranty of MERCHANTABILITY or FITNESS FOR A
1397 #gen_list.h: * PARTICULAR PURPOSE. See the GNU General Public
1398 #gen_list.h: * License for more details.
1400 #gen_list.h: * The GNU General Public License should be included with
1401 #gen_list.h: * this file. If not, you can view it at
1402 #gen_list.h: * http://www.gnu.org/copyleft/gpl.html
1403 #gen_list.h: * or write to the Free Software Foundation, Inc., 59
1404 #gen_list.h: * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
1406 #gen_list.h: * VI users : Please "set tabstop=3 shiftwidth=3" to view this file,
1407 #gen_list.h: * and edit IJB, correctly.
1409 #gen_list.h: * Revisions :
1410 #gen_list.h: * $Log: contrib.sh,v $
1411 #gen_list.h: * Revision 1.1 2001/12/07 01:54:50 iwanttokeepanon
1412 #gen_list.h: * A contribution/recomendation to the IJBSWA group for a generic doubly
1413 #gen_list.h: * linked list. This file is a home brew "bash tar" (I cannot create a
1414 #gen_list.h: * contrib directory and I cannot upload a tarball ... it gets
1415 #gen_list.h: * corrupted). This script will expand all files needed to create the
1416 #gen_list.h: * linked list modules and an example program. Please see the README.
1417 #gen_list.h: * Feed back is welcomed. Enjoy.
1420 #gen_list.h: *********************************************************************/
1423 #gen_list.h:#ifdef __cplusplus
1424 #gen_list.h:extern "C" {
1427 #gen_list.h:#include "isa.h"
1430 #gen_list.h:extern int list_is_quiet;
1432 #gen_list.h:#define LIST_SHOW(stmt) if ( ! list_is_quiet ) { stmt; }
1435 #gen_list.h:struct gen_list_rec;
1436 #gen_list.h:typedef struct gen_list_rec * (*rec_copy_construct)( struct gen_list_rec *copy_rec );
1437 #gen_list.h:typedef struct gen_list_rec * (*rec_destruct)( struct gen_list_rec *this_rec );
1438 #gen_list.h:typedef const struct gen_list_rec * (*rec_stream)( const struct gen_list_rec *this_rec );
1439 #gen_list.h:typedef int (*rec_equal)( const struct gen_list_rec *this_rec, const struct gen_list_rec *eq_rec );
1440 #gen_list.h:typedef struct gen_list_rec * (*rec_iterate)( struct gen_list_rec *this_rec );
1442 #gen_list.h:typedef void * (*rec_method)( void *this_rec, ... );
1445 #gen_list.h:enum VT_ENTRIES
1447 #gen_list.h: VT_REC_COPY_CONSTRUCT,
1448 #gen_list.h: VT_REC_DESTRUCT,
1449 #gen_list.h: VT_REC_STREAM,
1450 #gen_list.h: VT_REC_EQUAL,
1451 #gen_list.h: VT_REC_MAX
1455 #gen_list.h:typedef const rec_method *t_vtable;
1458 #gen_list.h:struct gen_list_rec
1460 #gen_list.h: /* private: */
1461 #gen_list.h: t_vtable vtable;
1462 #gen_list.h: enum GEN_LIST_ISA isa;
1463 #gen_list.h: int sizeof_rec;
1464 #gen_list.h: /* contents HERE */
1466 #gen_list.h:/* public: */
1467 #gen_list.h:extern struct gen_list_rec * gen_list_rec_construct( enum GEN_LIST_ISA isa, int sizeof_rec, const t_vtable _vtable );
1468 #gen_list.h:extern struct gen_list_rec * gen_list_rec_copy_construct( const struct gen_list_rec *this_rec );
1469 #gen_list.h:extern struct gen_list_rec * gen_list_rec_destruct( struct gen_list_rec *this_rec );
1470 #gen_list.h:extern const struct gen_list_rec * gen_list_rec_stream( const struct gen_list_rec *this_rec );
1471 #gen_list.h:extern int gen_list_rec_equal( const struct gen_list_rec *this_rec, const struct gen_list_rec *eq_rec );
1473 #gen_list.h:/* struct/class COMPLETE */
1476 #gen_list.h:/*
\f*********************************************************************/
1478 #gen_list.h:/* private: to gen_list */
1479 #gen_list.h:struct gen_list_node;
1482 #gen_list.h:struct gen_list
1484 #gen_list.h: /* private: */
1485 #gen_list.h: struct gen_list_node *first;
1486 #gen_list.h: struct gen_list_node *last;
1488 #gen_list.h:/* gen_list_insert_node */
1490 #gen_list.h:/* public: */
1491 #gen_list.h:extern struct gen_list * gen_list_construct();
1492 #gen_list.h:extern struct gen_list * gen_list_copy_construct( const struct gen_list *this_list );
1493 #gen_list.h:extern struct gen_list * gen_list_destruct( struct gen_list *this_list );
1494 #gen_list.h:extern struct gen_list * gen_list_remove_all( struct gen_list *this_list );
1495 #gen_list.h:extern struct gen_list_rec * gen_list_remove( struct gen_list *this_list, struct gen_list_rec *_rec );
1496 #gen_list.h:extern struct gen_list_rec * gen_list_get_first( const struct gen_list *this_list );
1497 #gen_list.h:extern struct gen_list_rec * gen_list_get_last( const struct gen_list *this_list );
1498 #gen_list.h:extern const struct gen_list_node * gen_list_insert( struct gen_list *this_list, struct gen_list_rec *_rec );
1499 #gen_list.h:extern const struct gen_list * gen_list_stream( const struct gen_list *this_list );
1500 #gen_list.h:extern int gen_list_equal( const struct gen_list *this_list, const struct gen_list *eq_list );
1501 #gen_list.h:extern struct gen_list_rec * gen_list_find( const struct gen_list *this_list, struct gen_list_rec *rec );
1502 #gen_list.h:extern struct gen_list_rec * gen_list_iterate( struct gen_list *this_list, rec_iterate iter );
1503 #gen_list.h:/* struct/class COMPLETE */
1506 #gen_list.h:#ifdef __cplusplus
1507 #gen_list.h:} /* extern "C" */
1510 #gen_list.h:#endif /* ndef GEN_LIST_H_INCLUDED */
1513 #gen_list.h: Local Variables:
1514 #gen_list.h: tab-width: 3
1519 #isa.c:const char isa_rcs[] = "$Id: contrib.sh,v 1.1 2001/12/07 01:54:50 iwanttokeepanon Exp $";
1520 #isa.c:/*********************************************************************
1522 #isa.c: * File : $Source: /cvsroot/ijbswa/current/contrib.sh,v $
1524 #isa.c: * Purpose : Pronounced "is a". To create "english" translations
1525 #isa.c: * for all linked "classes".
1527 #isa.c: * NOTE: this header file must appear once and only once
1528 #isa.c: * per project.
1530 #isa.c: * Copyright : Written by and Copyright (C) 2001 the SourceForge
1531 #isa.c: * Privoxy team. http://ijbswa.sourceforge.net
1533 #isa.c: * This program is free software; you can redistribute it
1534 #isa.c: * and/or modify it under the terms of the GNU General
1535 #isa.c: * Public License as published by the Free Software
1536 #isa.c: * Foundation; either version 2 of the License, or (at
1537 #isa.c: * your option) any later version.
1539 #isa.c: * This program is distributed in the hope that it will
1540 #isa.c: * be useful, but WITHOUT ANY WARRANTY; without even the
1541 #isa.c: * implied warranty of MERCHANTABILITY or FITNESS FOR A
1542 #isa.c: * PARTICULAR PURPOSE. See the GNU General Public
1543 #isa.c: * License for more details.
1545 #isa.c: * The GNU General Public License should be included with
1546 #isa.c: * this file. If not, you can view it at
1547 #isa.c: * http://www.gnu.org/copyleft/gpl.html
1548 #isa.c: * or write to the Free Software Foundation, Inc., 59
1549 #isa.c: * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
1551 #isa.c: * VI users : Please "set tabstop=3 shiftwidth=3" to view this file,
1552 #isa.c: * and edit IJB, correctly.
1554 #isa.c: * Revisions :
1555 #isa.c: * $Log: contrib.sh,v $
1556 #isa.c: * Revision 1.1 2001/12/07 01:54:50 iwanttokeepanon
1557 #isa.c: * A contribution/recomendation to the IJBSWA group for a generic doubly
1558 #isa.c: * linked list. This file is a home brew "bash tar" (I cannot create a
1559 #isa.c: * contrib directory and I cannot upload a tarball ... it gets
1560 #isa.c: * corrupted). This script will expand all files needed to create the
1561 #isa.c: * linked list modules and an example program. Please see the README.
1562 #isa.c: * Feed back is welcomed. Enjoy.
1564 #isa.c: * Revision 1.1 2001/11/30 21:55:51 rodney
1565 #isa.c: * Initial revision
1568 #isa.c: *********************************************************************/
1571 #isa.c:#include <malloc.h>
1572 #isa.c:#include <stdio.h>
1573 #isa.c:#include <stdlib.h>
1574 #isa.c:#include <string.h>
1576 #isa.c:#include "gen_list.h"
1577 #isa.c:#include "isa.h"
1579 #isa.c:const char isa_h_rcs[] = ISA_H_VERSION;
1582 #isa.c:/* Pronounce "ra" phonectically and you get "array", which this variable is. */
1583 #isa.c:char *isa_ra[] =
1585 #isa.c: "GEN_LIST_REC",
1586 #isa.c: "REC_MALLOC_POLICE",
1588 #isa.c: "REC_CHARPTR",
1589 #isa.c: "REC_DOUBLE",
1595 #isa.h:#ifndef ISA_H_INCLUDED
1596 #isa.h:#define ISA_H_INCLUDED
1597 #isa.h:#define ISA_H_VERSION "$Id: contrib.sh,v 1.1 2001/12/07 01:54:50 iwanttokeepanon Exp $"
1598 #isa.h:/*********************************************************************
1600 #isa.h: * File : $Source: /cvsroot/ijbswa/current/contrib.sh,v $
1602 #isa.h: * Purpose : Pronounced "is a". To create "english" translations
1603 #isa.h: * for all linked "classes".
1605 #isa.h: * NOTE: this header file must appear once and only once
1606 #isa.h: * per project.
1608 #isa.h: * Copyright : Written by and Copyright (C) 2001 the SourceForge
1609 #isa.h: * Privoxy team. http://ijbswa.sourceforge.net
1611 #isa.h: * This program is free software; you can redistribute it
1612 #isa.h: * and/or modify it under the terms of the GNU General
1613 #isa.h: * Public License as published by the Free Software
1614 #isa.h: * Foundation; either version 2 of the License, or (at
1615 #isa.h: * your option) any later version.
1617 #isa.h: * This program is distributed in the hope that it will
1618 #isa.h: * be useful, but WITHOUT ANY WARRANTY; without even the
1619 #isa.h: * implied warranty of MERCHANTABILITY or FITNESS FOR A
1620 #isa.h: * PARTICULAR PURPOSE. See the GNU General Public
1621 #isa.h: * License for more details.
1623 #isa.h: * The GNU General Public License should be included with
1624 #isa.h: * this file. If not, you can view it at
1625 #isa.h: * http://www.gnu.org/copyleft/gpl.html
1626 #isa.h: * or write to the Free Software Foundation, Inc., 59
1627 #isa.h: * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
1629 #isa.h: * VI users : Please "set tabstop=3 shiftwidth=3" to view this file,
1630 #isa.h: * and edit IJB, correctly.
1632 #isa.h: * Revisions :
1633 #isa.h: * $Log: contrib.sh,v $
1634 #isa.h: * Revision 1.1 2001/12/07 01:54:50 iwanttokeepanon
1635 #isa.h: * A contribution/recomendation to the IJBSWA group for a generic doubly
1636 #isa.h: * linked list. This file is a home brew "bash tar" (I cannot create a
1637 #isa.h: * contrib directory and I cannot upload a tarball ... it gets
1638 #isa.h: * corrupted). This script will expand all files needed to create the
1639 #isa.h: * linked list modules and an example program. Please see the README.
1640 #isa.h: * Feed back is welcomed. Enjoy.
1643 #isa.h: *********************************************************************/
1646 #isa.h:#ifdef __cplusplus
1651 #isa.h:enum GEN_LIST_ISA
1653 #isa.h: ISA_GEN_LIST_REC,
1654 #isa.h: ISA_MALLOC_POLICE,
1656 #isa.h: ISA_CHARPTR,
1663 #isa.h:/* Pronounce "ra" phonectically and you get "array", which this variable is. */
1664 #isa.h:extern char *isa_ra[];
1667 #isa.h:#ifdef __cplusplus
1668 #isa.h:} /* extern "C" */
1671 #isa.h:#endif /* ndef ISA_H_INCLUDED */
1674 #isa.h: Local Variables:
1675 #isa.h: tab-width: 3
1680 #main.c:const char main_rcs[] = "$Id: contrib.sh,v 1.1 2001/12/07 01:54:50 iwanttokeepanon Exp $";
1681 #main.c:/*********************************************************************
1683 #main.c: * File : $Source: /cvsroot/ijbswa/current/contrib.sh,v $
1685 #main.c: * Purpose : To test "generic list" creation and manipulation.
1687 #main.c: * Copyright : Written by and Copyright (C) 2001 the SourceForge
1688 #main.c: * Privoxy team. http://ijbswa.sourceforge.net
1690 #main.c: * This program is free software; you can redistribute it
1691 #main.c: * and/or modify it under the terms of the GNU General
1692 #main.c: * Public License as published by the Free Software
1693 #main.c: * Foundation; either version 2 of the License, or (at
1694 #main.c: * your option) any later version.
1696 #main.c: * This program is distributed in the hope that it will
1697 #main.c: * be useful, but WITHOUT ANY WARRANTY; without even the
1698 #main.c: * implied warranty of MERCHANTABILITY or FITNESS FOR A
1699 #main.c: * PARTICULAR PURPOSE. See the GNU General Public
1700 #main.c: * License for more details.
1702 #main.c: * The GNU General Public License should be included with
1703 #main.c: * this file. If not, you can view it at
1704 #main.c: * http://www.gnu.org/copyleft/gpl.html
1705 #main.c: * or write to the Free Software Foundation, Inc., 59
1706 #main.c: * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
1708 #main.c: * VI users : Please "set tabstop=3 shiftwidth=3" to view this file,
1709 #main.c: * and edit IJB, correctly.
1711 #main.c: * Note : This output assumes (per IJB standards) that tabs are
1712 #main.c: * set to 3 characters. If you run this in a terminal,
1713 #main.c: * you may want to run this as so:
1714 #main.c: * >./test_list 2>&1 | expand -t3 | ./addr_clean.pl
1715 #main.c: * This will expand the tab to 3 columns and then replace
1716 #main.c: * "0x" style addresses with more human readable ones.
1718 #main.c: * Revisions :
1719 #main.c: * $Log: contrib.sh,v $
1720 #main.c: * Revision 1.1 2001/12/07 01:54:50 iwanttokeepanon
1721 #main.c: * A contribution/recomendation to the IJBSWA group for a generic doubly
1722 #main.c: * linked list. This file is a home brew "bash tar" (I cannot create a
1723 #main.c: * contrib directory and I cannot upload a tarball ... it gets
1724 #main.c: * corrupted). This script will expand all files needed to create the
1725 #main.c: * linked list modules and an example program. Please see the README.
1726 #main.c: * Feed back is welcomed. Enjoy.
1729 #main.c: *********************************************************************/
1732 #main.c:#include <malloc.h>
1733 #main.c:#include <stdio.h>
1734 #main.c:#include <stdlib.h>
1735 #main.c:#include <string.h>
1737 #main.c:#include "gen_list.h"
1738 #main.c:#include "rec_char.h"
1739 #main.c:#include "rec_charptr.h"
1740 #main.c:#include "rec_double.h"
1741 #main.c:#include "rec_long.h"
1742 #main.c:#include "malloc_police.h"
1745 #main.c:extern const char isa_rcs[];
1746 #main.c:extern const char isa_h_rcs[];
1747 #main.c:extern const char gen_list_rcs[];
1748 #main.c:extern const char gen_list_h_rcs[];
1749 #main.c:extern const char malloc_police_rcs[];
1750 #main.c:extern const char malloc_police_h_rcs[];
1751 #main.c:extern const char rec_charptr_rcs[];
1752 #main.c:extern const char rec_charptr_h_rcs[];
1753 #main.c:extern const char rec_long_rcs[];
1754 #main.c:extern const char rec_long_h_rcs[];
1755 #main.c:extern const char rec_double_rcs[];
1756 #main.c:extern const char rec_double_h_rcs[];
1757 #main.c:extern const char rec_char_rcs[];
1758 #main.c:extern const char rec_char_h_rcs[];
1759 #main.c:extern const char rec_malloc_police_rcs[];
1760 #main.c:extern const char rec_malloc_police_h_rcs[];
1761 #main.c:extern const char main_rcs[];
1764 #main.c:/*********************************************************************
1766 #main.c: * Function : my_custom_charptr_iterator_1
1768 #main.c: * Description : This funtion is called once for every record in a
1769 #main.c: * list. Or at least until we return non-NULL. BTW,
1770 #main.c: * this function always returns NULL, thus it will
1771 #main.c: * iterate over the entire list.
1773 #main.c: * Parameters :
1774 #main.c: * 1 : The record.
1776 #main.c: * Returns : NULL
1778 #main.c: *********************************************************************/
1779 #main.c:struct derived_rec_charptr *my_custom_charptr_iterator_1( struct derived_rec_charptr *this_rec )
1782 #main.c:\t\tcharptr iterator_1 this_rec\t\t\t\t= iter_1 ... %p
1783 #main.c:\t\tcharptr iterator_1 this_rec->contents\t= iter_1 ... %s\n\n", (const void *)this_rec, this_rec->contents );
1784 #main.c: return( NULL );
1789 #main.c:/*********************************************************************
1791 #main.c: * Function : my_custom_charptr_iterator_2
1793 #main.c: * Description : This funtion is called once for every record in a
1794 #main.c: * list. Or at least until we return non-NULL. BTW,
1795 #main.c: * this function always returns non-NULL, thus it will
1796 #main.c: * iterate over only 1 record.
1798 #main.c: * Parameters :
1799 #main.c: * 1 : The record.
1801 #main.c: * Returns : The record.
1803 #main.c: *********************************************************************/
1804 #main.c:struct derived_rec_charptr *my_custom_charptr_iterator_2( struct derived_rec_charptr *this_rec )
1807 #main.c:\t\tcharptr iterator_1 this_rec\t\t\t\t= iter_2 ... %p
1808 #main.c:\t\tcharptr iterator_1 this_rec->contents\t= iter_2 ... %s\n\n", (const void *)this_rec, this_rec->contents );
1809 #main.c: return( this_rec );
1814 #main.c:/*********************************************************************
1816 #main.c: * Function : main
1818 #main.c: * Description : Test the doubly linked list as it is so far.
1820 #main.c: * Parameters : None
1822 #main.c: * Returns : N/A
1824 #main.c: *********************************************************************/
1825 #main.c:int main( int argc, const char **argv )
1827 #main.c: struct gen_list *lcharptr;
1828 #main.c: struct gen_list *llong;
1829 #main.c: struct gen_list *ldouble;
1830 #main.c: struct gen_list *lchar;
1832 #main.c: struct gen_list *lcharptr_c;
1833 #main.c: struct gen_list *llong_c;
1834 #main.c: struct gen_list *ldouble_c;
1835 #main.c: struct gen_list *lchar_c;
1837 #main.c: struct gen_list_rec *f_rec;
1839 #main.c: struct gen_list *no_own_list;
1840 #main.c: struct gen_list_rec *no_own_rec1;
1841 #main.c: struct gen_list_rec *no_own_rec2;
1842 #main.c: struct gen_list_rec *no_own_rec3;
1844 #main.c: printf( "\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n\n",
1845 #main.c: gen_list_rcs,
1846 #main.c: gen_list_h_rcs,
1849 #main.c: malloc_police_rcs,
1850 #main.c: malloc_police_h_rcs,
1851 #main.c: rec_char_rcs,
1852 #main.c: rec_char_h_rcs,
1853 #main.c: rec_charptr_rcs,
1854 #main.c: rec_charptr_h_rcs,
1855 #main.c: rec_long_rcs,
1856 #main.c: rec_long_h_rcs,
1857 #main.c: rec_double_rcs,
1858 #main.c: rec_double_h_rcs,
1859 #main.c: rec_malloc_police_rcs,
1860 #main.c: rec_malloc_police_h_rcs,
1861 #main.c: main_rcs );
1864 #main.c: /* Force a memory leak to test the strdup/malloc/free police. */
1865 #main.c: /* NOTE: this should trigger the alphanum check of allocated memory. */
1866 #main.c: strcpy( MALLOC( 60 ), "Force a memory leak to test the strdup/malloc/free police." );
1869 #main.c: printf( "** -- Calling gen_list_construct to constuct a charptr list -- **\n" );
1870 #main.c: lcharptr = gen_list_construct();
1872 #main.c: gen_list_insert( lcharptr, (struct gen_list_rec *)derived_rec_charptr_construct( "Rodney Stromlund" ) );
1873 #main.c: gen_list_insert( lcharptr, f_rec = (struct gen_list_rec *)derived_rec_charptr_construct( "RJS" ) );
1874 #main.c: gen_list_insert( lcharptr, (struct gen_list_rec *)derived_rec_charptr_construct( "jammin!" ) );
1876 #main.c: printf( "** -- Calling gen_list_stream to test streaming a charptr list -- **\n" );
1877 #main.c: gen_list_stream( lcharptr );
1879 #main.c: printf( "** -- Calling gen_list_find to find the 2nd charptr record -- **\n" );
1880 #main.c: f_rec = gen_list_find( lcharptr, f_rec );
1881 #main.c: printf( "Found rec = %p\n", f_rec );
1882 #main.c: derived_rec_charptr_stream( (const struct derived_rec_charptr *)f_rec );
1885 #main.c: printf( "** -- Calling gen_list_copy_construct to test copy construct the charptr list -- **\n" );
1886 #main.c: lcharptr_c = gen_list_copy_construct( lcharptr );
1888 #main.c: printf( "** -- Calling gen_list_equal to see if the copied list is the same as the orig -- **
1889 #main.c:** -- NOTE: they will NOT be because the charptr copy constructor changes the string contents -- **\n" );
1890 #main.c: printf( "Are these 2 equal? => %d\n\n", gen_list_equal( lcharptr, lcharptr_c ) );
1892 #main.c: printf( "** -- Calling gen_list_stream to stream a copied charptr list -- **\n" );
1893 #main.c: gen_list_stream( lcharptr_c );
1896 #main.c: printf( "** -- Calling gen_list_construct to constuct a long list -- **\n" );
1897 #main.c: llong = gen_list_construct();
1900 #main.c: gen_list_insert( llong, no_own_rec1 = (struct gen_list_rec *)derived_rec_long_construct( 1 ) );
1901 #main.c: gen_list_insert( llong, no_own_rec2 = (struct gen_list_rec *)derived_rec_long_construct( 100 ) );
1902 #main.c: gen_list_insert( llong, no_own_rec3 = (struct gen_list_rec *)derived_rec_long_construct( 200 ) );
1904 #main.c: printf( "** -- Calling gen_list_stream to test streaming a long list -- **\n" );
1905 #main.c: gen_list_stream( llong );
1908 #main.c: printf( "** -- Calling gen_list_copy_construct to test copy construct the long list -- **\n" );
1909 #main.c: llong_c = gen_list_copy_construct( llong );
1911 #main.c: printf( "** -- Calling gen_list_stream to stream a copied long list -- **\n" );
1912 #main.c: gen_list_stream( llong_c );
1914 #main.c: printf( "** -- Calling gen_list_construct to test a no-owner long list -- **\n" );
1915 #main.c: no_own_list = gen_list_construct();
1916 #main.c: gen_list_insert( no_own_list, no_own_rec1 );
1917 #main.c: gen_list_insert( no_own_list, no_own_rec2 );
1918 #main.c: gen_list_insert( no_own_list, no_own_rec3 );
1920 #main.c: printf( "** -- Calling gen_list_stream to stream a no-owner list -- **\n" );
1921 #main.c: gen_list_stream( no_own_list );
1923 #main.c: printf( "** -- Calling gen_list_equal to see if list and no-owner list are equal NOTE: they should be. -- **\n" );
1924 #main.c: printf( "Are these 2 equal? => %d\n\n", gen_list_equal( llong, no_own_list ) );
1927 #main.c: printf( "** -- Calling gen_list_construct to constuct a double list -- **\n" );
1928 #main.c: ldouble = gen_list_construct();
1930 #main.c: gen_list_insert( ldouble, (struct gen_list_rec *)derived_rec_double_construct( 3.0 ) );
1931 #main.c: gen_list_insert( ldouble, (struct gen_list_rec *)derived_rec_double_construct( 3.1 ) );
1932 #main.c: gen_list_insert( ldouble, (struct gen_list_rec *)derived_rec_double_construct( 3.14 ) );
1934 #main.c: printf( "** -- Calling gen_list_stream to test streaming a double list -- **\n" );
1935 #main.c: gen_list_stream( ldouble );
1938 #main.c: printf( "** -- Calling gen_list_copy_construct to test copy construct the double list -- **\n" );
1939 #main.c: ldouble_c = gen_list_copy_construct( ldouble );
1941 #main.c: printf( "** -- Calling gen_list_stream to stream a copied double list -- **\n" );
1942 #main.c: gen_list_stream( ldouble_c );
1945 #main.c: printf( "** -- Calling gen_list_construct to constuct a char list -- **\n" );
1946 #main.c: lchar = gen_list_construct();
1948 #main.c: gen_list_insert( lchar, (struct gen_list_rec *)derived_rec_char_construct( '1' ) );
1949 #main.c: gen_list_insert( lchar, (struct gen_list_rec *)derived_rec_char_construct( 'A' ) );
1950 #main.c: gen_list_insert( lchar, (struct gen_list_rec *)derived_rec_char_construct( 'a' ) );
1952 #main.c: printf( "** -- Calling gen_list_stream to test streaming a char list -- **\n" );
1953 #main.c: gen_list_stream( lchar );
1956 #main.c: printf( "** -- Calling gen_list_copy_construct to test copy construct the char list -- **\n" );
1957 #main.c: lchar_c = gen_list_copy_construct( lchar );
1959 #main.c: printf( "** -- Calling gen_list_equal to see if the copied list is the same as the orig NOTE: they should be. -- **\n" );
1960 #main.c: printf( "Are these 2 equal? => %d\n\n", gen_list_equal( lchar, lchar_c ) );
1962 #main.c: printf( "** -- Calling gen_list_stream to stream a copied char list -- **\n" );
1963 #main.c: gen_list_stream( lchar_c );
1966 #main.c: printf( "** -- Calling gen_list_iterate to iterate a charptr list -- **
1967 #main.c:** -- NOTE: this iterator (my_custom_charptr_iterator_1) will iterate the whole list. -- **\n" );
1968 #main.c: gen_list_iterate( lcharptr, (rec_iterate)my_custom_charptr_iterator_1 );
1970 #main.c: printf( "** -- Calling gen_list_iterate to iterate a copied charptr list -- **
1971 #main.c:** -- NOTE: this iterator (my_custom_charptr_iterator_2) will return after the first iteration. -- **\n" );
1972 #main.c: gen_list_iterate( lcharptr_c, (rec_iterate)my_custom_charptr_iterator_2 );
1975 #main.c: printf( "** -- Calling gen_list_iterate_reverse to iterate a charptr list -- **
1976 #main.c:** -- NOTE: this iterator (my_custom_charptr_iterator_1) will iterate the whole list. -- **\n" );
1977 #main.c: gen_list_iterate_reverse( lcharptr, (rec_iterate)my_custom_charptr_iterator_1 );
1979 #main.c: printf( "** -- Calling gen_list_iterate_reverse to iterate a copied charptr list -- **
1980 #main.c:** -- NOTE: this iterator (my_custom_charptr_iterator_2) will return after the first iteration. -- **\n" );
1981 #main.c: gen_list_iterate_reverse( lcharptr_c, (rec_iterate)my_custom_charptr_iterator_2 );
1984 #main.c: printf( "** -- Calling gen_list_equal to see if 2 different typed lists are equal NOTE: they should not be. -- **\n" );
1985 #main.c: printf( "Are these 2 equal? => %d\n\n", gen_list_equal( lcharptr, llong ) );
1988 #main.c: printf( "** -- Calling gen_list_remove_all to erase a no-owner list -- **\n" );
1989 #main.c: no_own_list = gen_list_remove_all( no_own_list );
1991 #main.c: printf( "** -- Calling gen_list_destruct to destruct a no-owner list -- **\n" );
1992 #main.c: no_own_list = gen_list_destruct( no_own_list );
1995 #main.c: printf( "** -- Calling gen_list_remove to remove the first record of a copied charptr list -- **\n" );
1996 #main.c: derived_rec_charptr_destruct( (struct derived_rec_charptr *)gen_list_remove( lcharptr_c, gen_list_get_first( lcharptr_c ) ) );
1998 #main.c: printf( "** -- Calling gen_list_remove to remove the last record of a copied long list -- **\n" );
1999 #main.c: derived_rec_long_destruct( (struct derived_rec_long *)gen_list_remove( llong_c, gen_list_get_last( llong_c ) ) );
2001 #main.c: printf( "** -- Calling gen_list_remove to remove the middle record of an original charptr list -- **\n" );
2002 #main.c: derived_rec_charptr_destruct( (struct derived_rec_charptr *)gen_list_remove( lcharptr, f_rec ) );
2004 #main.c: printf( "** -- Calling gen_list_remove to remove the all 3 records of a copied char list (first to last) -- **\n" );
2005 #main.c: derived_rec_char_destruct( (struct derived_rec_char *)gen_list_remove( lchar_c, gen_list_get_first( lchar_c ) ) );
2006 #main.c: derived_rec_char_destruct( (struct derived_rec_char *)gen_list_remove( lchar_c, gen_list_get_first( lchar_c ) ) );
2007 #main.c: derived_rec_char_destruct( (struct derived_rec_char *)gen_list_remove( lchar_c, gen_list_get_first( lchar_c ) ) );
2009 #main.c: printf( "** -- Calling gen_list_remove to remove the all 3 records of the original char list (last to first) -- **\n" );
2010 #main.c: derived_rec_char_destruct( (struct derived_rec_char *)gen_list_remove( lchar, gen_list_get_last( lchar ) ) );
2011 #main.c: derived_rec_char_destruct( (struct derived_rec_char *)gen_list_remove( lchar, gen_list_get_last( lchar ) ) );
2012 #main.c: derived_rec_char_destruct( (struct derived_rec_char *)gen_list_remove( lchar, gen_list_get_last( lchar ) ) );
2015 #main.c: printf( "** -- Calling gen_list_destruct to destruct the original charptr list (less the middle record) -- **\n" );
2016 #main.c: lcharptr = gen_list_destruct( lcharptr );
2017 #main.c: printf( "** -- Calling gen_list_destruct to destruct the copied charptr list (less the first record) -- **\n" );
2018 #main.c: lcharptr_c = gen_list_destruct( lcharptr_c );
2020 #main.c: printf( "** -- Calling gen_list_destruct to destruct the original long list -- **\n" );
2021 #main.c: llong = gen_list_destruct( llong );
2022 #main.c: printf( "** -- Calling gen_list_destruct to destruct the copied long list (less the last record) -- **\n" );
2023 #main.c: llong_c = gen_list_destruct( llong_c );
2025 #main.c: printf( "** -- Calling gen_list_destruct to destruct the original double list -- **\n" );
2026 #main.c: ldouble = gen_list_destruct( ldouble );
2027 #main.c: printf( "** -- Calling gen_list_destruct to destruct the copied double list -- **\n" );
2028 #main.c: ldouble_c = gen_list_destruct( ldouble_c );
2030 #main.c: printf( "** -- Calling gen_list_destruct to destruct the original char list (less all records last to first) -- **\n" );
2031 #main.c: lchar = gen_list_destruct( lchar );
2032 #main.c: printf( "** -- Calling gen_list_destruct to destruct the copied char list (less all records first to last) -- **\n" );
2033 #main.c: lchar_c = gen_list_destruct( lchar_c );
2036 #main.c: /* Force another memory leak to test the strdup/malloc/free police. */
2037 #main.c: /* NOTE: this should trigger the alphanum check of allocated memory. */
2038 #main.c: STRDUP( "Force another memory leak to test the strdup/malloc/free police." );
2040 #main.c: /* Force a memory leak in a list and also in 2 nodes. */
2041 #main.c: /* NOTE: this should NOT trigger the alphanum check of allocated memory. */
2042 #main.c: gen_list_construct();
2044 #main.c: /* NOTE: this should trigger 1 NON check (for the node) */
2045 #main.c: /* followed by 1 alphanum check for the charptr string. */
2046 #main.c: derived_rec_charptr_construct( "Leaky charptr node." );
2048 #main.c: /* NOTE: this should NOT trigger the alphanum check of allocated memory. */
2049 #main.c: derived_rec_char_construct( 'Z' );
2052 #main.c: printf( "\ndone" );
2053 #main.c: return( 0 );
2059 #main.c: Local Variables:
2060 #main.c: tab-width: 3
2065 #malloc_police.c:const char malloc_police_rcs[] = "$Id: contrib.sh,v 1.1 2001/12/07 01:54:50 iwanttokeepanon Exp $";
2066 #malloc_police.c:/*********************************************************************
2068 #malloc_police.c: * File : $Source: /cvsroot/ijbswa/current/contrib.sh,v $
2070 #malloc_police.c: * Purpose : This module uses the rec_malloc_police to build a
2071 #malloc_police.c: * list of allocated and freed memory. When the
2072 #malloc_police.c: * program exits, we will print a list of all memory
2073 #malloc_police.c: * that was allocated, but never freed. This could
2074 #malloc_police.c: * be most helpful to developers and debugers.
2076 #malloc_police.c: * Copyright : Written by and Copyright (C) 2001 the SourceForge
2077 #malloc_police.c: * Privoxy team. http://ijbswa.sourceforge.net
2079 #malloc_police.c: * This program is free software; you can redistribute it
2080 #malloc_police.c: * and/or modify it under the terms of the GNU General
2081 #malloc_police.c: * Public License as published by the Free Software
2082 #malloc_police.c: * Foundation; either version 2 of the License, or (at
2083 #malloc_police.c: * your option) any later version.
2085 #malloc_police.c: * This program is distributed in the hope that it will
2086 #malloc_police.c: * be useful, but WITHOUT ANY WARRANTY; without even the
2087 #malloc_police.c: * implied warranty of MERCHANTABILITY or FITNESS FOR A
2088 #malloc_police.c: * PARTICULAR PURPOSE. See the GNU General Public
2089 #malloc_police.c: * License for more details.
2091 #malloc_police.c: * The GNU General Public License should be included with
2092 #malloc_police.c: * this file. If not, you can view it at
2093 #malloc_police.c: * http://www.gnu.org/copyleft/gpl.html
2094 #malloc_police.c: * or write to the Free Software Foundation, Inc., 59
2095 #malloc_police.c: * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
2097 #malloc_police.c: * VI users : Please "set tabstop=3 shiftwidth=3" to view this file,
2098 #malloc_police.c: * and edit IJB, correctly.
2100 #malloc_police.c: * Revisions :
2101 #malloc_police.c: * $Log: contrib.sh,v $
2102 #malloc_police.c: * Revision 1.1 2001/12/07 01:54:50 iwanttokeepanon
2103 #malloc_police.c: * A contribution/recomendation to the IJBSWA group for a generic doubly
2104 #malloc_police.c: * linked list. This file is a home brew "bash tar" (I cannot create a
2105 #malloc_police.c: * contrib directory and I cannot upload a tarball ... it gets
2106 #malloc_police.c: * corrupted). This script will expand all files needed to create the
2107 #malloc_police.c: * linked list modules and an example program. Please see the README.
2108 #malloc_police.c: * Feed back is welcomed. Enjoy.
2111 #malloc_police.c: *********************************************************************/
2114 #malloc_police.c:#include <ctype.h>
2115 #malloc_police.c:#include <malloc.h>
2116 #malloc_police.c:#include <stdio.h>
2117 #malloc_police.c:#include <stdlib.h>
2118 #malloc_police.c:#include <string.h>
2120 #malloc_police.c:#include "gen_list.h"
2121 #malloc_police.c:#include "malloc_police.h"
2122 #malloc_police.c:#include "rec_malloc_police.h"
2124 #malloc_police.c:const char malloc_police_h_rcs[] = MALLOC_POLICE_H_VERSION;
2127 #malloc_police.c:/* When we need to allocate malloc_police records, we */
2128 #malloc_police.c:/* will do recursion infinately. This variable will */
2129 #malloc_police.c:/* stop the STRDUP, MALLOC, and FREE replacements from */
2130 #malloc_police.c:/* trying to log these allocations. */
2132 #malloc_police.c:char recursion_protect = 0;
2134 #malloc_police.c:struct gen_list *get_police_list();
2135 #malloc_police.c:static char called_once = 0;
2136 #malloc_police.c:static const char *leak_report_header = "%s****************************** MEMORY LEAK REPORT %s ******************************%s";
2139 #malloc_police.c:/*********************************************************************
2141 #malloc_police.c: * Function : police_list_release_iterator
2143 #malloc_police.c: * Description : Iterator for the police list. We will report
2144 #malloc_police.c: * "leaked" memory for the developer to correct.
2146 #malloc_police.c: * Parameters :
2147 #malloc_police.c: * 1 : The record.
2149 #malloc_police.c: * Returns : NULL
2151 #malloc_police.c: *********************************************************************/
2152 #malloc_police.c:struct derived_rec_malloc_police *police_list_release_iterator( struct derived_rec_malloc_police *this_rec )
2154 #malloc_police.c: if ( ! called_once )
2156 #malloc_police.c: called_once = 1;
2157 #malloc_police.c: fprintf( stderr, leak_report_header, "\n\n", "BEGIN", "\n\n" );
2160 #malloc_police.c: fprintf( stderr, "\
2161 #malloc_police.c:\t\tmalloc_police leaked memory iterator this_rec\t\t\t\t\t= %p
2162 #malloc_police.c:\t\tmalloc_police leaked memory iterator this_rec->alloced_addr\t= %p
2163 #malloc_police.c:\t\tmalloc_police leaked memory iterator this_rec->source_where\t= %s
2164 #malloc_police.c:\t\tmalloc_police leaked memory iterator this_rec->sz\t\t\t\t= %ld\n",
2165 #malloc_police.c: (const void *)this_rec,
2166 #malloc_police.c: this_rec->alloced_addr,
2167 #malloc_police.c: this_rec->source_where,
2168 #malloc_police.c: this_rec->sz
2169 #malloc_police.c: );
2171 #malloc_police.c: if (
2172 #malloc_police.c: this_rec->sz >= 3 &&
2173 #malloc_police.c: isalnum( ((const char *)this_rec->alloced_addr)[ 0 ] ) &&
2174 #malloc_police.c: isalnum( ((const char *)this_rec->alloced_addr)[ 1 ] ) &&
2175 #malloc_police.c: isalnum( ((const char *)this_rec->alloced_addr)[ 2 ] ) )
2177 #malloc_police.c: /* If the memory starts with 3 alpha-numerics,
2178 #malloc_police.c: * assume a string was allocated. This might be
2179 #malloc_police.c: * a little dangerous for production code, but I
2180 #malloc_police.c: * will take the risk for development payoff
2181 #malloc_police.c: * (at least for now ...) */
2183 #malloc_police.c: fprintf( stderr, "\
2184 #malloc_police.c:\t\tAlpha numeric found, assuming a string was allocated\t\t\t= %s\n",
2185 #malloc_police.c: this_rec->alloced_addr
2186 #malloc_police.c: );
2189 #malloc_police.c: fprintf( stderr, "\n" );
2191 #malloc_police.c: return( NULL );
2196 #malloc_police.c:/*********************************************************************
2198 #malloc_police.c: * Function : release_police_list
2200 #malloc_police.c: * Description : Iterates the police_list and reports "leaked" memory.
2201 #malloc_police.c: * It will then free the list itself.
2203 #malloc_police.c: * Parameters : None
2205 #malloc_police.c: * Returns : None.
2207 #malloc_police.c: *********************************************************************/
2208 #malloc_police.c:void release_police_list()
2210 #malloc_police.c: struct gen_list *police_list = get_police_list();
2211 #malloc_police.c: fflush( stdout );
2212 #malloc_police.c: gen_list_iterate( police_list, (rec_iterate)police_list_release_iterator );
2214 #malloc_police.c: if ( called_once )
2216 #malloc_police.c: called_once = 0;
2217 #malloc_police.c: fprintf( stderr, leak_report_header, "", "END", "\n" );
2223 #malloc_police.c:/*********************************************************************
2225 #malloc_police.c: * Function : get_police_list
2227 #malloc_police.c: * Description : Get the police malloc/strdup/free list. Generate
2228 #malloc_police.c: * a new one if it does not yet exist.
2230 #malloc_police.c: * Parameters : None
2232 #malloc_police.c: * Returns : The police list.
2234 #malloc_police.c: *********************************************************************/
2235 #malloc_police.c:struct gen_list *get_police_list()
2237 #malloc_police.c: static struct gen_list *police_list = NULL;
2239 #malloc_police.c: if ( NULL == police_list )
2241 #malloc_police.c: recursion_protect ++;
2242 #malloc_police.c: list_is_quiet ++;
2244 #malloc_police.c: police_list = gen_list_construct();
2245 #malloc_police.c: atexit( release_police_list );
2247 #malloc_police.c: recursion_protect --;
2248 #malloc_police.c: list_is_quiet --;
2251 #malloc_police.c: return( police_list );
2256 #malloc_police.c:/*********************************************************************
2258 #malloc_police.c: * Function : police_strdup
2260 #malloc_police.c: * Description : Save the results of the strdup into our linked list.
2261 #malloc_police.c: * This will be checked against latter free(s).
2263 #malloc_police.c: * Parameters :
2264 #malloc_police.c: * 1 : The string to be duplicated.
2265 #malloc_police.c: * 2 : Filename where the strdup occured.
2266 #malloc_police.c: * 3 : Line# of where the strdup occured.
2268 #malloc_police.c: * Returns : Pointer to newly allocated memory.
2270 #malloc_police.c: * NOTE : This could replace the custom strdup for __MINGW32__
2271 #malloc_police.c: * systems. We only need to copy the conditionally
2272 #malloc_police.c: * compiled code here and eliminate the strdup copy.
2274 #malloc_police.c: *********************************************************************/
2275 #malloc_police.c:char *police_strdup( const char *s, const char *filename, long lineno )
2277 #malloc_police.c: char *ret = strdup( s );
2279 #malloc_police.c: if ( 0 == recursion_protect )
2281 #malloc_police.c: char buffer[ 255 ];
2282 #malloc_police.c: sprintf( buffer, "strdup : %s @ %ld for %ld (%s)", filename, lineno, strlen( s ) + 1, s );
2284 #malloc_police.c: recursion_protect ++;
2285 #malloc_police.c: list_is_quiet ++;
2287 #malloc_police.c: gen_list_insert(
2288 #malloc_police.c: get_police_list(),
2289 #malloc_police.c: (struct gen_list_rec *)derived_rec_malloc_police_construct( ret, buffer, strlen( s ) + 1 )
2290 #malloc_police.c: );
2292 #malloc_police.c: recursion_protect --;
2293 #malloc_police.c: list_is_quiet --;
2296 #malloc_police.c: return( ret );
2301 #malloc_police.c:/*********************************************************************
2303 #malloc_police.c: * Function : police_malloc
2305 #malloc_police.c: * Description : Save the results of the malloc into our linked list.
2306 #malloc_police.c: * This will be checked against latter free(s).
2308 #malloc_police.c: * Parameters :
2309 #malloc_police.c: * 1 : The size of the memory to be malloc(ed).
2310 #malloc_police.c: * 2 : Filename where the malloc occured.
2311 #malloc_police.c: * 3 : Line# of where the malloc occured.
2313 #malloc_police.c: * Returns : 0 => NOT EQUAL, anything else is EQUAL.
2315 #malloc_police.c: *********************************************************************/
2316 #malloc_police.c:void *police_malloc( size_t sz, const char *filename, long lineno )
2318 #malloc_police.c: void *ret = malloc( sz );
2320 #malloc_police.c: if ( 0 == recursion_protect )
2322 #malloc_police.c: char buffer[ 255 ];
2323 #malloc_police.c: sprintf( buffer, "malloc : %s @ %ld for %ld", filename, lineno, sz );
2325 #malloc_police.c: recursion_protect ++;
2326 #malloc_police.c: list_is_quiet ++;
2328 #malloc_police.c: gen_list_insert(
2329 #malloc_police.c: get_police_list(),
2330 #malloc_police.c: (struct gen_list_rec *)derived_rec_malloc_police_construct( ret, buffer, sz )
2331 #malloc_police.c: );
2333 #malloc_police.c: recursion_protect --;
2334 #malloc_police.c: list_is_quiet --;
2337 #malloc_police.c: return( ret );
2342 #malloc_police.c:/*********************************************************************
2344 #malloc_police.c: * Function : police_free
2346 #malloc_police.c: * Description : Frees the memory allocation and removes the address
2347 #malloc_police.c: * from the linked list. Anything left in this list
2348 #malloc_police.c: * is "leaked" memory.
2350 #malloc_police.c: * Parameters :
2351 #malloc_police.c: * 1 : Pointer to the memory to be freed.
2352 #malloc_police.c: * 2 : Filename where the free occured.
2353 #malloc_police.c: * 3 : Line# of where the free occured.
2355 #malloc_police.c: * Returns : 0 => NOT EQUAL, anything else is EQUAL.
2357 #malloc_police.c: *********************************************************************/
2358 #malloc_police.c:void police_free( void *ptr, const char *filename, long lineno )
2360 #malloc_police.c: if ( 0 == recursion_protect )
2362 #malloc_police.c: struct derived_rec_malloc_police *rec;
2363 #malloc_police.c: struct gen_list_rec *fRec;
2364 #malloc_police.c: struct gen_list *l = get_police_list();
2366 #malloc_police.c: recursion_protect ++;
2367 #malloc_police.c: list_is_quiet ++;
2369 #malloc_police.c: rec = derived_rec_malloc_police_construct( ptr, "FREEING POLICE RECORD.", 23 );
2370 #malloc_police.c: fRec = gen_list_find( l, (struct gen_list_rec *)rec );
2371 #malloc_police.c: derived_rec_malloc_police_destruct( rec );
2373 #malloc_police.c: if ( NULL == fRec )
2375 #malloc_police.c: fprintf( stderr, "\nERROR: free failed to find corresponding strdup/malloc : %s @ %ld\n", filename, lineno );
2377 #malloc_police.c: else
2379 #malloc_police.c: derived_rec_malloc_police_destruct( (struct derived_rec_malloc_police *)gen_list_remove( l, fRec ) );
2382 #malloc_police.c: recursion_protect --;
2383 #malloc_police.c: list_is_quiet --;
2386 #malloc_police.c: free( ptr );
2391 #malloc_police.h:#ifndef MALLOC_POLICE_H_INCLUDED
2392 #malloc_police.h:#define MALLOC_POLICE_H_INCLUDED
2393 #malloc_police.h:#define MALLOC_POLICE_H_VERSION "$Id: contrib.sh,v 1.1 2001/12/07 01:54:50 iwanttokeepanon Exp $"
2394 #malloc_police.h:/*********************************************************************
2396 #malloc_police.h: * File : $Source: /cvsroot/ijbswa/current/contrib.sh,v $
2398 #malloc_police.h: * Purpose : This module uses the rec_malloc_police to build a
2399 #malloc_police.h: * list of allocated and freed memory. When the
2400 #malloc_police.h: * program exits, we will print a list of all memory
2401 #malloc_police.h: * that was allocated, but never freed. This could
2402 #malloc_police.h: * be most helpful to developers and debugers.
2404 #malloc_police.h: * Copyright : Written by and Copyright (C) 2001 the SourceForge
2405 #malloc_police.h: * Privoxy team. http://ijbswa.sourceforge.net
2407 #malloc_police.h: * This program is free software; you can redistribute it
2408 #malloc_police.h: * and/or modify it under the terms of the GNU General
2409 #malloc_police.h: * Public License as published by the Free Software
2410 #malloc_police.h: * Foundation; either version 2 of the License, or (at
2411 #malloc_police.h: * your option) any later version.
2413 #malloc_police.h: * This program is distributed in the hope that it will
2414 #malloc_police.h: * be useful, but WITHOUT ANY WARRANTY; without even the
2415 #malloc_police.h: * implied warranty of MERCHANTABILITY or FITNESS FOR A
2416 #malloc_police.h: * PARTICULAR PURPOSE. See the GNU General Public
2417 #malloc_police.h: * License for more details.
2419 #malloc_police.h: * The GNU General Public License should be included with
2420 #malloc_police.h: * this file. If not, you can view it at
2421 #malloc_police.h: * http://www.gnu.org/copyleft/gpl.html
2422 #malloc_police.h: * or write to the Free Software Foundation, Inc., 59
2423 #malloc_police.h: * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
2425 #malloc_police.h: * VI users : Please "set tabstop=3 shiftwidth=3" to view this file,
2426 #malloc_police.h: * and edit IJB, correctly.
2428 #malloc_police.h: * Revisions :
2429 #malloc_police.h: * $Log: contrib.sh,v $
2430 #malloc_police.h: * Revision 1.1 2001/12/07 01:54:50 iwanttokeepanon
2431 #malloc_police.h: * A contribution/recomendation to the IJBSWA group for a generic doubly
2432 #malloc_police.h: * linked list. This file is a home brew "bash tar" (I cannot create a
2433 #malloc_police.h: * contrib directory and I cannot upload a tarball ... it gets
2434 #malloc_police.h: * corrupted). This script will expand all files needed to create the
2435 #malloc_police.h: * linked list modules and an example program. Please see the README.
2436 #malloc_police.h: * Feed back is welcomed. Enjoy.
2439 #malloc_police.h: *********************************************************************/
2442 #malloc_police.h:#ifdef __cplusplus
2443 #malloc_police.h:extern "C" {
2444 #malloc_police.h:#endif
2447 #malloc_police.h:char *police_strdup( const char *s, const char *filename, long lineno );
2448 #malloc_police.h:void *police_malloc( size_t sz, const char *filename, long lineno );
2449 #malloc_police.h:void police_free( void *ptr, const char *filename, long lineno );
2451 #malloc_police.h:#define STRDUP(s) police_strdup( s, __FILE__, __LINE__ )
2452 #malloc_police.h:#define MALLOC(sz) police_malloc( sz, __FILE__, __LINE__ )
2453 #malloc_police.h:#define FREE(ptr) police_free( ptr, __FILE__, __LINE__ )
2456 #malloc_police.h:#ifdef __cplusplus
2457 #malloc_police.h:} /* extern "C" */
2458 #malloc_police.h:#endif
2460 #malloc_police.h:#endif /* ndef MALLOC_POLICE_H_INCLUDED */
2463 #malloc_police.h: Local Variables:
2464 #malloc_police.h: tab-width: 3
2465 #malloc_police.h: end:
2469 #rec_char.c:const char rec_char_rcs[] = "$Id: contrib.sh,v 1.1 2001/12/07 01:54:50 iwanttokeepanon Exp $";
2470 #rec_char.c:/*********************************************************************
2472 #rec_char.c: * File : $Source: /cvsroot/ijbswa/current/contrib.sh,v $
2474 #rec_char.c: * Purpose : A "derived class" of gen_list_rec.
2476 #rec_char.c: * Copyright : Written by and Copyright (C) 2001 the SourceForge
2477 #rec_char.c: * Privoxy team. http://ijbswa.sourceforge.net
2479 #rec_char.c: * This program is free software; you can redistribute it
2480 #rec_char.c: * and/or modify it under the terms of the GNU General
2481 #rec_char.c: * Public License as published by the Free Software
2482 #rec_char.c: * Foundation; either version 2 of the License, or (at
2483 #rec_char.c: * your option) any later version.
2485 #rec_char.c: * This program is distributed in the hope that it will
2486 #rec_char.c: * be useful, but WITHOUT ANY WARRANTY; without even the
2487 #rec_char.c: * implied warranty of MERCHANTABILITY or FITNESS FOR A
2488 #rec_char.c: * PARTICULAR PURPOSE. See the GNU General Public
2489 #rec_char.c: * License for more details.
2491 #rec_char.c: * The GNU General Public License should be included with
2492 #rec_char.c: * this file. If not, you can view it at
2493 #rec_char.c: * http://www.gnu.org/copyleft/gpl.html
2494 #rec_char.c: * or write to the Free Software Foundation, Inc., 59
2495 #rec_char.c: * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
2497 #rec_char.c: * VI users : Please "set tabstop=3 shiftwidth=3" to view this file,
2498 #rec_char.c: * and edit IJB, correctly.
2500 #rec_char.c: * Revisions :
2501 #rec_char.c: * $Log: contrib.sh,v $
2502 #rec_char.c: * Revision 1.1 2001/12/07 01:54:50 iwanttokeepanon
2503 #rec_char.c: * A contribution/recomendation to the IJBSWA group for a generic doubly
2504 #rec_char.c: * linked list. This file is a home brew "bash tar" (I cannot create a
2505 #rec_char.c: * contrib directory and I cannot upload a tarball ... it gets
2506 #rec_char.c: * corrupted). This script will expand all files needed to create the
2507 #rec_char.c: * linked list modules and an example program. Please see the README.
2508 #rec_char.c: * Feed back is welcomed. Enjoy.
2511 #rec_char.c: *********************************************************************/
2514 #rec_char.c:#include <malloc.h>
2515 #rec_char.c:#include <stdio.h>
2516 #rec_char.c:#include <stdlib.h>
2517 #rec_char.c:#include <string.h>
2519 #rec_char.c:#include "gen_list.h"
2520 #rec_char.c:#include "rec_char.h"
2522 #rec_char.c:const char rec_char_h_rcs[] = REC_CHAR_H_VERSION;
2525 #rec_char.c:static const rec_method rec_char_vtable[] =
2527 #rec_char.c: (rec_method)derived_rec_char_copy_construct,
2528 #rec_char.c: (rec_method)derived_rec_char_destruct,
2529 #rec_char.c: (rec_method)derived_rec_char_stream,
2530 #rec_char.c: (rec_method)derived_rec_char_equal
2534 #rec_char.c:/*********************************************************************
2536 #rec_char.c: * Function : derived_rec_char_construct
2538 #rec_char.c: * Description : A simple derived record class that contains 1 string.
2540 #rec_char.c: * Parameters :
2541 #rec_char.c: * 1 : The record
2542 #rec_char.c: * 2 : The string to contain.
2544 #rec_char.c: * Returns : A pointer to the constructed record.
2546 #rec_char.c: *********************************************************************/
2547 #rec_char.c:struct derived_rec_char *derived_rec_char_construct( const char _contents )
2549 #rec_char.c: struct derived_rec_char *this_rec = (struct derived_rec_char *)gen_list_rec_construct(
2550 #rec_char.c: ISA_CHAR,
2551 #rec_char.c: sizeof( struct derived_rec_char ),
2552 #rec_char.c: rec_char_vtable
2555 #rec_char.c: this_rec->contents = _contents;
2557 #rec_char.c: LIST_SHOW( printf( "\
2558 #rec_char.c:\t\tchar construct new rec\t\t\t\t= %p
2559 #rec_char.c:\t\tchar construct new rec contents\t= %c\n\n", (const void *)this_rec, this_rec->contents ) );
2561 #rec_char.c: return( this_rec );
2566 #rec_char.c:/*********************************************************************
2568 #rec_char.c: * Function : derived_rec_char_copy_construct
2570 #rec_char.c: * Description : Copies one char record to another.
2572 #rec_char.c: * Parameters :
2573 #rec_char.c: * 1 : Existing record.
2574 #rec_char.c: * 2 : Copy record.
2576 #rec_char.c: * Returns : The newly constructed copy record.
2578 #rec_char.c: *********************************************************************/
2579 #rec_char.c:struct derived_rec_char *derived_rec_char_copy_construct( const struct derived_rec_char *this_rec )
2581 #rec_char.c: struct derived_rec_char *copy_rec = (struct derived_rec_char *)gen_list_rec_copy_construct( (struct gen_list_rec *)this_rec );
2582 #rec_char.c: copy_rec->contents = this_rec->contents;
2584 #rec_char.c: LIST_SHOW( printf( "\
2585 #rec_char.c:\t\tchar copy construct new gen rec\t\t\t\t= %p => %p
2586 #rec_char.c:\t\tchar copy construct new gen rec contents\t= %c\n\n", (const void *)this_rec, (const void *)copy_rec, copy_rec->contents ) );
2588 #rec_char.c: return( copy_rec );
2593 #rec_char.c:/*********************************************************************
2595 #rec_char.c: * Function : derived_rec_char_destruct
2597 #rec_char.c: * Description : Destruct the char record.
2599 #rec_char.c: * Parameters :
2600 #rec_char.c: * 1 : The record.
2602 #rec_char.c: * Returns : NULL
2604 #rec_char.c: *********************************************************************/
2605 #rec_char.c:struct derived_rec_char *derived_rec_char_destruct( struct derived_rec_char *this_rec )
2607 #rec_char.c: LIST_SHOW( printf( "\
2608 #rec_char.c:\t\tchar destruct this_rec\t\t\t\t= %p
2609 #rec_char.c:\t\tchar destruct this_rec->contents\t= %c\n\n", (const void *)this_rec, this_rec->contents ) );
2611 #rec_char.c: this_rec->contents = '!';
2612 #rec_char.c: return( (struct derived_rec_char *)gen_list_rec_destruct( (struct gen_list_rec *)this_rec ) );
2617 #rec_char.c:/*********************************************************************
2619 #rec_char.c: * Function : derived_rec_char_stream
2621 #rec_char.c: * Description : Displays all char attributes on the STDOUT stream.
2623 #rec_char.c: * Parameters :
2624 #rec_char.c: * 1 : The record.
2626 #rec_char.c: * Returns : The record.
2628 #rec_char.c: *********************************************************************/
2629 #rec_char.c:const struct derived_rec_char *derived_rec_char_stream( const struct derived_rec_char *this_rec )
2631 #rec_char.c: this_rec = (struct derived_rec_char *)gen_list_rec_stream(
2632 #rec_char.c: (struct gen_list_rec *)this_rec
2634 #rec_char.c: LIST_SHOW( printf( "\
2635 #rec_char.c:\t\tchar stream this_rec\t\t\t\t\t= %p
2636 #rec_char.c:\t\tchar stream this_rec->contents\t= %c\n\n", (const void *)this_rec, this_rec->contents ) );
2638 #rec_char.c: return( this_rec );
2643 #rec_char.c:/*********************************************************************
2645 #rec_char.c: * Function : derived_rec_char_equal
2647 #rec_char.c: * Description : Compares two char records to see if they are equal.
2649 #rec_char.c: * Parameters :
2650 #rec_char.c: * 1 : A record.
2651 #rec_char.c: * 2 : Another record.
2653 #rec_char.c: * Returns : 0 => NOT EQUAL, anything else is EQUAL.
2655 #rec_char.c: *********************************************************************/
2656 #rec_char.c:int derived_rec_char_equal( const struct derived_rec_char *this_rec, const struct derived_rec_char *eq_rec )
2658 #rec_char.c: if ( ! gen_list_rec_equal( (const struct gen_list_rec *)this_rec, (struct gen_list_rec *)eq_rec ) )
2660 #rec_char.c: return( 0 );
2662 #rec_char.c: return( this_rec->contents == eq_rec->contents );
2667 #rec_char.h:#ifndef REC_CHAR_H_INCLUDED
2668 #rec_char.h:#define REC_CHAR_H_INCLUDED
2669 #rec_char.h:#define REC_CHAR_H_VERSION "$Id: contrib.sh,v 1.1 2001/12/07 01:54:50 iwanttokeepanon Exp $"
2670 #rec_char.h:/*********************************************************************
2672 #rec_char.h: * File : $Source: /cvsroot/ijbswa/current/contrib.sh,v $
2674 #rec_char.h: * Purpose : A "derived class" of gen_list_rec.
2676 #rec_char.h: * Copyright : Written by and Copyright (C) 2001 the SourceForge
2677 #rec_char.h: * Privoxy team. http://ijbswa.sourceforge.net
2679 #rec_char.h: * This program is free software; you can redistribute it
2680 #rec_char.h: * and/or modify it under the terms of the GNU General
2681 #rec_char.h: * Public License as published by the Free Software
2682 #rec_char.h: * Foundation; either version 2 of the License, or (at
2683 #rec_char.h: * your option) any later version.
2685 #rec_char.h: * This program is distributed in the hope that it will
2686 #rec_char.h: * be useful, but WITHOUT ANY WARRANTY; without even the
2687 #rec_char.h: * implied warranty of MERCHANTABILITY or FITNESS FOR A
2688 #rec_char.h: * PARTICULAR PURPOSE. See the GNU General Public
2689 #rec_char.h: * License for more details.
2691 #rec_char.h: * The GNU General Public License should be included with
2692 #rec_char.h: * this file. If not, you can view it at
2693 #rec_char.h: * http://www.gnu.org/copyleft/gpl.html
2694 #rec_char.h: * or write to the Free Software Foundation, Inc., 59
2695 #rec_char.h: * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
2697 #rec_char.h: * VI users : Please "set tabstop=3 shiftwidth=3" to view this file,
2698 #rec_char.h: * and edit IJB, correctly.
2700 #rec_char.h: * Revisions :
2701 #rec_char.h: * $Log: contrib.sh,v $
2702 #rec_char.h: * Revision 1.1 2001/12/07 01:54:50 iwanttokeepanon
2703 #rec_char.h: * A contribution/recomendation to the IJBSWA group for a generic doubly
2704 #rec_char.h: * linked list. This file is a home brew "bash tar" (I cannot create a
2705 #rec_char.h: * contrib directory and I cannot upload a tarball ... it gets
2706 #rec_char.h: * corrupted). This script will expand all files needed to create the
2707 #rec_char.h: * linked list modules and an example program. Please see the README.
2708 #rec_char.h: * Feed back is welcomed. Enjoy.
2711 #rec_char.h: *********************************************************************/
2714 #rec_char.h:#ifdef __cplusplus
2715 #rec_char.h:extern "C" {
2719 #rec_char.h:struct derived_rec_char
2721 #rec_char.h: /* private: */
2722 #rec_char.h: struct gen_list_rec parent_rec;
2723 #rec_char.h: char contents;
2726 #rec_char.h:/* public: */
2727 #rec_char.h:extern struct derived_rec_char * derived_rec_char_construct( const char _contents );
2728 #rec_char.h:extern struct derived_rec_char * derived_rec_char_copy_construct( const struct derived_rec_char *this_rec );
2729 #rec_char.h:extern struct derived_rec_char * derived_rec_char_destruct( struct derived_rec_char *this_rec );
2730 #rec_char.h:extern const struct derived_rec_char *derived_rec_char_stream( const struct derived_rec_char *this_rec );
2731 #rec_char.h:extern int derived_rec_char_equal( const struct derived_rec_char *this_rec, const struct derived_rec_char *eq_rec );
2733 #rec_char.h:/* struct/class COMPLETE */
2736 #rec_char.h:#ifdef __cplusplus
2737 #rec_char.h:} /* extern "C" */
2740 #rec_char.h:#endif /* ndef REC_CHAR_H_INCLUDED */
2743 #rec_char.h: Local Variables:
2744 #rec_char.h: tab-width: 3
2749 #rec_charptr.c:const char rec_charptr_rcs[] = "$Id: contrib.sh,v 1.1 2001/12/07 01:54:50 iwanttokeepanon Exp $";
2750 #rec_charptr.c:/*********************************************************************
2752 #rec_charptr.c: * File : $Source: /cvsroot/ijbswa/current/contrib.sh,v $
2754 #rec_charptr.c: * Purpose : A "derived class" of gen_list_rec.
2756 #rec_charptr.c: * Copyright : Written by and Copyright (C) 2001 the SourceForge
2757 #rec_charptr.c: * Privoxy team. http://ijbswa.sourceforge.net
2759 #rec_charptr.c: * This program is free software; you can redistribute it
2760 #rec_charptr.c: * and/or modify it under the terms of the GNU General
2761 #rec_charptr.c: * Public License as published by the Free Software
2762 #rec_charptr.c: * Foundation; either version 2 of the License, or (at
2763 #rec_charptr.c: * your option) any later version.
2765 #rec_charptr.c: * This program is distributed in the hope that it will
2766 #rec_charptr.c: * be useful, but WITHOUT ANY WARRANTY; without even the
2767 #rec_charptr.c: * implied warranty of MERCHANTABILITY or FITNESS FOR A
2768 #rec_charptr.c: * PARTICULAR PURPOSE. See the GNU General Public
2769 #rec_charptr.c: * License for more details.
2771 #rec_charptr.c: * The GNU General Public License should be included with
2772 #rec_charptr.c: * this file. If not, you can view it at
2773 #rec_charptr.c: * http://www.gnu.org/copyleft/gpl.html
2774 #rec_charptr.c: * or write to the Free Software Foundation, Inc., 59
2775 #rec_charptr.c: * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
2777 #rec_charptr.c: * VI users : Please "set tabstop=3 shiftwidth=3" to view this file,
2778 #rec_charptr.c: * and edit IJB, correctly.
2780 #rec_charptr.c: * Revisions :
2781 #rec_charptr.c: * $Log: contrib.sh,v $
2782 #rec_charptr.c: * Revision 1.1 2001/12/07 01:54:50 iwanttokeepanon
2783 #rec_charptr.c: * A contribution/recomendation to the IJBSWA group for a generic doubly
2784 #rec_charptr.c: * linked list. This file is a home brew "bash tar" (I cannot create a
2785 #rec_charptr.c: * contrib directory and I cannot upload a tarball ... it gets
2786 #rec_charptr.c: * corrupted). This script will expand all files needed to create the
2787 #rec_charptr.c: * linked list modules and an example program. Please see the README.
2788 #rec_charptr.c: * Feed back is welcomed. Enjoy.
2791 #rec_charptr.c: *********************************************************************/
2794 #rec_charptr.c:#include <malloc.h>
2795 #rec_charptr.c:#include <stdio.h>
2796 #rec_charptr.c:#include <stdlib.h>
2797 #rec_charptr.c:#include <string.h>
2799 #rec_charptr.c:#include "gen_list.h"
2800 #rec_charptr.c:#include "rec_charptr.h"
2801 #rec_charptr.c:#include "malloc_police.h"
2803 #rec_charptr.c:const char rec_charptr_h_rcs[] = REC_CHARPTR_H_VERSION;
2806 #rec_charptr.c:static const rec_method rec_charptr_vtable[] =
2808 #rec_charptr.c: (rec_method)derived_rec_charptr_copy_construct,
2809 #rec_charptr.c: (rec_method)derived_rec_charptr_destruct,
2810 #rec_charptr.c: (rec_method)derived_rec_charptr_stream,
2811 #rec_charptr.c: (rec_method)derived_rec_charptr_equal
2815 #rec_charptr.c:/*********************************************************************
2817 #rec_charptr.c: * Function : derived_rec_charptr_construct
2819 #rec_charptr.c: * Description : A simple derived record class that contains 1 string.
2821 #rec_charptr.c: * Parameters :
2822 #rec_charptr.c: * 1 : The record
2823 #rec_charptr.c: * 2 : The string to contain.
2825 #rec_charptr.c: * Returns : A pointer to the constructed record.
2827 #rec_charptr.c: *********************************************************************/
2828 #rec_charptr.c:struct derived_rec_charptr *derived_rec_charptr_construct( const char *_contents )
2830 #rec_charptr.c: struct derived_rec_charptr *this_rec = (struct derived_rec_charptr *)gen_list_rec_construct(
2831 #rec_charptr.c: ISA_CHARPTR,
2832 #rec_charptr.c: sizeof( struct derived_rec_charptr ),
2833 #rec_charptr.c: rec_charptr_vtable
2836 #rec_charptr.c: this_rec->contents = STRDUP( _contents );
2838 #rec_charptr.c: LIST_SHOW( printf( "\
2839 #rec_charptr.c:\t\tcharptr construct new rec\t\t\t\t= %p
2840 #rec_charptr.c:\t\tcharptr construct new rec contents\t= %s\n\n", (const void *)this_rec, this_rec->contents ) );
2842 #rec_charptr.c: return( this_rec );
2847 #rec_charptr.c:/*********************************************************************
2849 #rec_charptr.c: * Function : derived_rec_charptr_copy_construct
2851 #rec_charptr.c: * Description : Copies one charptr record to another.
2853 #rec_charptr.c: * Parameters :
2854 #rec_charptr.c: * 1 : Existing record.
2855 #rec_charptr.c: * 2 : Copy record.
2857 #rec_charptr.c: * Returns : The newly constructed copy record.
2859 #rec_charptr.c: *********************************************************************/
2860 #rec_charptr.c:struct derived_rec_charptr *derived_rec_charptr_copy_construct( const struct derived_rec_charptr *this_rec )
2862 #rec_charptr.c: int len;
2863 #rec_charptr.c: char *new_contents;
2865 #rec_charptr.c: struct derived_rec_charptr *copy_rec = (struct derived_rec_charptr *)gen_list_rec_copy_construct( (struct gen_list_rec *)this_rec );
2867 #rec_charptr.c: len = strlen( this_rec->contents );
2868 #rec_charptr.c: len += sizeof( "COPY " );
2870 #rec_charptr.c: copy_rec->contents = (char *)MALLOC( len );
2871 #rec_charptr.c: strcpy( copy_rec->contents, "COPY " );
2872 #rec_charptr.c: strcat( copy_rec->contents, this_rec->contents );
2874 #rec_charptr.c: LIST_SHOW( printf( "\
2875 #rec_charptr.c:\t\tcharptr copy construct new gen rec\t\t\t\t= %p => %p
2876 #rec_charptr.c:\t\tcharptr copy construct new gen rec contents\t= %s\n\n", (const void *)this_rec, (const void *)copy_rec, copy_rec->contents ) );
2879 #rec_charptr.c: return( copy_rec );
2884 #rec_charptr.c:/*********************************************************************
2886 #rec_charptr.c: * Function : derived_rec_charptr_destruct
2888 #rec_charptr.c: * Description : Destruct the charptr record.
2890 #rec_charptr.c: * Parameters :
2891 #rec_charptr.c: * 1 : The record.
2893 #rec_charptr.c: * Returns : NULL
2895 #rec_charptr.c: *********************************************************************/
2896 #rec_charptr.c:struct derived_rec_charptr *derived_rec_charptr_destruct( struct derived_rec_charptr *this_rec )
2898 #rec_charptr.c: LIST_SHOW( printf( "\
2899 #rec_charptr.c:\t\tcharptr destruct this_rec\t\t\t\t= %p
2900 #rec_charptr.c:\t\tcharptr destruct this_rec->contents\t= %s\n\n", (const void *)this_rec, (const void *)this_rec->contents ) );
2902 #rec_charptr.c: memset( this_rec->contents, '!', strlen( this_rec->contents ) );
2903 #rec_charptr.c: FREE( this_rec->contents );
2904 #rec_charptr.c: return( (struct derived_rec_charptr *)gen_list_rec_destruct( (struct gen_list_rec *)this_rec ) );
2909 #rec_charptr.c:/*********************************************************************
2911 #rec_charptr.c: * Function : derived_rec_charptr_stream
2913 #rec_charptr.c: * Description : Displays all charptr attributes on the STDOUT stream.
2915 #rec_charptr.c: * Parameters :
2916 #rec_charptr.c: * 1 : The record.
2918 #rec_charptr.c: * Returns : The record.
2920 #rec_charptr.c: *********************************************************************/
2921 #rec_charptr.c:const struct derived_rec_charptr *derived_rec_charptr_stream( const struct derived_rec_charptr *this_rec )
2923 #rec_charptr.c: this_rec = (struct derived_rec_charptr *)gen_list_rec_stream(
2924 #rec_charptr.c: (struct gen_list_rec *)this_rec
2926 #rec_charptr.c: LIST_SHOW( printf( "\
2927 #rec_charptr.c:\t\tcharptr stream this_rec\t\t\t\t\t= %p
2928 #rec_charptr.c:\t\tcharptr stream this_rec->contents\t= %s\n\n", (const void *)this_rec, this_rec->contents ) );
2930 #rec_charptr.c: return( this_rec );
2935 #rec_charptr.c:/*********************************************************************
2937 #rec_charptr.c: * Function : derived_rec_charptr_equal
2939 #rec_charptr.c: * Description : Compares two charptr records to see if they are equal.
2941 #rec_charptr.c: * Parameters :
2942 #rec_charptr.c: * 1 : A record.
2943 #rec_charptr.c: * 2 : Another record.
2945 #rec_charptr.c: * Returns : 0 => NOT EQUAL, anything else is EQUAL.
2947 #rec_charptr.c: *********************************************************************/
2948 #rec_charptr.c:int derived_rec_charptr_equal( const struct derived_rec_charptr *this_rec, const struct derived_rec_charptr *eq_rec )
2950 #rec_charptr.c: if ( ! gen_list_rec_equal( (const struct gen_list_rec *)this_rec, (struct gen_list_rec *)eq_rec ) )
2952 #rec_charptr.c: return( 0 );
2954 #rec_charptr.c: return( 0 == strcmp( this_rec->contents, eq_rec->contents ) );
2959 #rec_charptr.h:#ifndef REC_CHARPTR_H_INCLUDED
2960 #rec_charptr.h:#define REC_CHARPTR_H_INCLUDED
2961 #rec_charptr.h:#define REC_CHARPTR_H_VERSION "$Id: contrib.sh,v 1.1 2001/12/07 01:54:50 iwanttokeepanon Exp $"
2962 #rec_charptr.h:/*********************************************************************
2964 #rec_charptr.h: * File : $Source: /cvsroot/ijbswa/current/contrib.sh,v $
2966 #rec_charptr.h: * Purpose : A "derived class" of gen_list_rec.
2968 #rec_charptr.h: * Copyright : Written by and Copyright (C) 2001 the SourceForge
2969 #rec_charptr.h: * Privoxy team. http://ijbswa.sourceforge.net
2971 #rec_charptr.h: * This program is free software; you can redistribute it
2972 #rec_charptr.h: * and/or modify it under the terms of the GNU General
2973 #rec_charptr.h: * Public License as published by the Free Software
2974 #rec_charptr.h: * Foundation; either version 2 of the License, or (at
2975 #rec_charptr.h: * your option) any later version.
2977 #rec_charptr.h: * This program is distributed in the hope that it will
2978 #rec_charptr.h: * be useful, but WITHOUT ANY WARRANTY; without even the
2979 #rec_charptr.h: * implied warranty of MERCHANTABILITY or FITNESS FOR A
2980 #rec_charptr.h: * PARTICULAR PURPOSE. See the GNU General Public
2981 #rec_charptr.h: * License for more details.
2983 #rec_charptr.h: * The GNU General Public License should be included with
2984 #rec_charptr.h: * this file. If not, you can view it at
2985 #rec_charptr.h: * http://www.gnu.org/copyleft/gpl.html
2986 #rec_charptr.h: * or write to the Free Software Foundation, Inc., 59
2987 #rec_charptr.h: * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
2989 #rec_charptr.h: * VI users : Please "set tabstop=3 shiftwidth=3" to view this file,
2990 #rec_charptr.h: * and edit IJB, correctly.
2992 #rec_charptr.h: * Revisions :
2993 #rec_charptr.h: * $Log: contrib.sh,v $
2994 #rec_charptr.h: * Revision 1.1 2001/12/07 01:54:50 iwanttokeepanon
2995 #rec_charptr.h: * A contribution/recomendation to the IJBSWA group for a generic doubly
2996 #rec_charptr.h: * linked list. This file is a home brew "bash tar" (I cannot create a
2997 #rec_charptr.h: * contrib directory and I cannot upload a tarball ... it gets
2998 #rec_charptr.h: * corrupted). This script will expand all files needed to create the
2999 #rec_charptr.h: * linked list modules and an example program. Please see the README.
3000 #rec_charptr.h: * Feed back is welcomed. Enjoy.
3003 #rec_charptr.h: *********************************************************************/
3006 #rec_charptr.h:#ifdef __cplusplus
3007 #rec_charptr.h:extern "C" {
3008 #rec_charptr.h:#endif
3011 #rec_charptr.h:struct derived_rec_charptr
3013 #rec_charptr.h: /* private: */
3014 #rec_charptr.h: struct gen_list_rec parent_rec;
3015 #rec_charptr.h: char *contents;
3018 #rec_charptr.h:/* public: */
3019 #rec_charptr.h:extern struct derived_rec_charptr * derived_rec_charptr_construct( const char *_contents );
3020 #rec_charptr.h:extern struct derived_rec_charptr * derived_rec_charptr_copy_construct( const struct derived_rec_charptr *this_rec );
3021 #rec_charptr.h:extern struct derived_rec_charptr * derived_rec_charptr_destruct( struct derived_rec_charptr *this_rec );
3022 #rec_charptr.h:extern const struct derived_rec_charptr *derived_rec_charptr_stream( const struct derived_rec_charptr *this_rec );
3023 #rec_charptr.h:extern int derived_rec_charptr_equal( const struct derived_rec_charptr *this_rec, const struct derived_rec_charptr *eq_rec );
3025 #rec_charptr.h:/* struct/class COMPLETE */
3028 #rec_charptr.h:#ifdef __cplusplus
3029 #rec_charptr.h:} /* extern "C" */
3030 #rec_charptr.h:#endif
3032 #rec_charptr.h:#endif /* ndef REC_CHARPTR_H_INCLUDED */
3035 #rec_charptr.h: Local Variables:
3036 #rec_charptr.h: tab-width: 3
3037 #rec_charptr.h: end:
3041 #rec_double.c:const char rec_double_rcs[] = "$Id: contrib.sh,v 1.1 2001/12/07 01:54:50 iwanttokeepanon Exp $";
3042 #rec_double.c:/*********************************************************************
3044 #rec_double.c: * File : $Source: /cvsroot/ijbswa/current/contrib.sh,v $
3046 #rec_double.c: * Purpose : A "derived class" of gen_list_rec.
3048 #rec_double.c: * Copyright : Written by and Copyright (C) 2001 the SourceForge
3049 #rec_double.c: * Privoxy team. http://ijbswa.sourceforge.net
3051 #rec_double.c: * This program is free software; you can redistribute it
3052 #rec_double.c: * and/or modify it under the terms of the GNU General
3053 #rec_double.c: * Public License as published by the Free Software
3054 #rec_double.c: * Foundation; either version 2 of the License, or (at
3055 #rec_double.c: * your option) any later version.
3057 #rec_double.c: * This program is distributed in the hope that it will
3058 #rec_double.c: * be useful, but WITHOUT ANY WARRANTY; without even the
3059 #rec_double.c: * implied warranty of MERCHANTABILITY or FITNESS FOR A
3060 #rec_double.c: * PARTICULAR PURPOSE. See the GNU General Public
3061 #rec_double.c: * License for more details.
3063 #rec_double.c: * The GNU General Public License should be included with
3064 #rec_double.c: * this file. If not, you can view it at
3065 #rec_double.c: * http://www.gnu.org/copyleft/gpl.html
3066 #rec_double.c: * or write to the Free Software Foundation, Inc., 59
3067 #rec_double.c: * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3069 #rec_double.c: * VI users : Please "set tabstop=3 shiftwidth=3" to view this file,
3070 #rec_double.c: * and edit IJB, correctly.
3072 #rec_double.c: * Revisions :
3073 #rec_double.c: * $Log: contrib.sh,v $
3074 #rec_double.c: * Revision 1.1 2001/12/07 01:54:50 iwanttokeepanon
3075 #rec_double.c: * A contribution/recomendation to the IJBSWA group for a generic doubly
3076 #rec_double.c: * linked list. This file is a home brew "bash tar" (I cannot create a
3077 #rec_double.c: * contrib directory and I cannot upload a tarball ... it gets
3078 #rec_double.c: * corrupted). This script will expand all files needed to create the
3079 #rec_double.c: * linked list modules and an example program. Please see the README.
3080 #rec_double.c: * Feed back is welcomed. Enjoy.
3083 #rec_double.c: *********************************************************************/
3086 #rec_double.c:#include <malloc.h>
3087 #rec_double.c:#include <stdio.h>
3088 #rec_double.c:#include <stdlib.h>
3089 #rec_double.c:#include <string.h>
3091 #rec_double.c:#include "gen_list.h"
3092 #rec_double.c:#include "rec_double.h"
3094 #rec_double.c:const char rec_double_h_rcs[] = REC_DOUBLE_H_VERSION;
3097 #rec_double.c:static const rec_method rec_double_vtable[] =
3099 #rec_double.c: (rec_method)derived_rec_double_copy_construct,
3100 #rec_double.c: (rec_method)derived_rec_double_destruct,
3101 #rec_double.c: (rec_method)derived_rec_double_stream,
3102 #rec_double.c: (rec_method)derived_rec_double_equal
3106 #rec_double.c:/*********************************************************************
3108 #rec_double.c: * Function : derived_rec_double_construct
3110 #rec_double.c: * Description : A simple derived record class that contains 1 string.
3112 #rec_double.c: * Parameters :
3113 #rec_double.c: * 1 : The record
3114 #rec_double.c: * 2 : The string to contain.
3116 #rec_double.c: * Returns : A pointer to the constructed record.
3118 #rec_double.c: *********************************************************************/
3119 #rec_double.c:struct derived_rec_double *derived_rec_double_construct( const double _contents )
3121 #rec_double.c: struct derived_rec_double *this_rec = (struct derived_rec_double *)gen_list_rec_construct(
3122 #rec_double.c: ISA_DOUBLE,
3123 #rec_double.c: sizeof( struct derived_rec_double ),
3124 #rec_double.c: rec_double_vtable
3127 #rec_double.c: this_rec->contents = _contents;
3129 #rec_double.c: LIST_SHOW( printf( "\
3130 #rec_double.c:\t\tdouble construct new rec\t\t\t\t= %p
3131 #rec_double.c:\t\tdouble construct new rec contents\t= %8.2lf\n\n", (const void *)this_rec, this_rec->contents ) );
3133 #rec_double.c: return( this_rec );
3138 #rec_double.c:/*********************************************************************
3140 #rec_double.c: * Function : derived_rec_double_copy_construct
3142 #rec_double.c: * Description : Copies one double record to another.
3144 #rec_double.c: * Parameters :
3145 #rec_double.c: * 1 : Existing record.
3146 #rec_double.c: * 2 : Copy record.
3148 #rec_double.c: * Returns : The newly constructed copy record.
3150 #rec_double.c: *********************************************************************/
3151 #rec_double.c:struct derived_rec_double *derived_rec_double_copy_construct( const struct derived_rec_double *this_rec )
3153 #rec_double.c: struct derived_rec_double *copy_rec = (struct derived_rec_double *)gen_list_rec_copy_construct( (struct gen_list_rec *)this_rec );
3154 #rec_double.c: copy_rec->contents = - this_rec->contents;
3156 #rec_double.c: LIST_SHOW( printf( "\
3157 #rec_double.c:\t\tdouble copy construct new gen rec\t\t\t\t= %p => %p
3158 #rec_double.c:\t\tdouble copy construct new gen rec contents\t= %8.2lf\n\n", (const void *)this_rec, (const void *)copy_rec, copy_rec->contents ) );
3160 #rec_double.c: return( copy_rec );
3165 #rec_double.c:/*********************************************************************
3167 #rec_double.c: * Function : derived_rec_double_destruct
3169 #rec_double.c: * Description : Destruct the double record.
3171 #rec_double.c: * Parameters :
3172 #rec_double.c: * 1 : The record.
3174 #rec_double.c: * Returns : NULL
3176 #rec_double.c: *********************************************************************/
3177 #rec_double.c:struct derived_rec_double *derived_rec_double_destruct( struct derived_rec_double *this_rec )
3179 #rec_double.c: LIST_SHOW( printf( "\
3180 #rec_double.c:\t\tdouble destruct this_rec\t\t\t\t= %p
3181 #rec_double.c:\t\tdouble destruct this_rec->contents\t= %8.2lf\n\n", (const void *)this_rec, this_rec->contents ) );
3183 #rec_double.c: this_rec->contents = -1.1111;
3184 #rec_double.c: return( (struct derived_rec_double *)gen_list_rec_destruct( (struct gen_list_rec *)this_rec ) );
3189 #rec_double.c:/*********************************************************************
3191 #rec_double.c: * Function : derived_rec_double_stream
3193 #rec_double.c: * Description : Displays all double attributes on the STDOUT stream.
3195 #rec_double.c: * Parameters :
3196 #rec_double.c: * 1 : The record.
3198 #rec_double.c: * Returns : The record.
3200 #rec_double.c: *********************************************************************/
3201 #rec_double.c:const struct derived_rec_double *derived_rec_double_stream( const struct derived_rec_double *this_rec )
3203 #rec_double.c: this_rec = (struct derived_rec_double *)gen_list_rec_stream(
3204 #rec_double.c: (struct gen_list_rec *)this_rec
3206 #rec_double.c: LIST_SHOW( printf( "\
3207 #rec_double.c:\t\tdouble stream this_rec\t\t\t\t= %p
3208 #rec_double.c:\t\tdouble stream this_rec->contents\t= %8.2lf\n\n", (const void *)this_rec, this_rec->contents ) );
3210 #rec_double.c: return( this_rec );
3215 #rec_double.c:/*********************************************************************
3217 #rec_double.c: * Function : derived_rec_double_equal
3219 #rec_double.c: * Description : Compares two double records to see if they are equal.
3221 #rec_double.c: * Parameters :
3222 #rec_double.c: * 1 : A record.
3223 #rec_double.c: * 2 : Another record.
3225 #rec_double.c: * Returns : 0 => NOT EQUAL, anything else is EQUAL.
3227 #rec_double.c: *********************************************************************/
3228 #rec_double.c:int derived_rec_double_equal( const struct derived_rec_double *this_rec, const struct derived_rec_double *eq_rec )
3230 #rec_double.c: if ( ! gen_list_rec_equal( (const struct gen_list_rec *)this_rec, (struct gen_list_rec *)eq_rec ) )
3232 #rec_double.c: return( 0 );
3234 #rec_double.c: return( this_rec->contents == eq_rec->contents );
3239 #rec_double.h:#ifndef REC_DOUBLE_H_INCLUDED
3240 #rec_double.h:#define REC_DOUBLE_H_INCLUDED
3241 #rec_double.h:#define REC_DOUBLE_H_VERSION "$Id: contrib.sh,v 1.1 2001/12/07 01:54:50 iwanttokeepanon Exp $"
3242 #rec_double.h:/*********************************************************************
3244 #rec_double.h: * File : $Source: /cvsroot/ijbswa/current/contrib.sh,v $
3246 #rec_double.h: * Purpose : gen_A "derived class" of gen_list_rec.
3248 #rec_double.h: * Copyright : Written by and Copyright (C) 2001 the SourceForge
3249 #rec_double.h: * Privoxy team. http://ijbswa.sourceforge.net
3251 #rec_double.h: * This program is free software; you can redistribute it
3252 #rec_double.h: * and/or modify it under the terms of the GNU General
3253 #rec_double.h: * Public License as published by the Free Software
3254 #rec_double.h: * Foundation; either version 2 of the License, or (at
3255 #rec_double.h: * your option) any later version.
3257 #rec_double.h: * This program is distributed in the hope that it will
3258 #rec_double.h: * be useful, but WITHOUT ANY WARRANTY; without even the
3259 #rec_double.h: * implied warranty of MERCHANTABILITY or FITNESS FOR A
3260 #rec_double.h: * PARTICULAR PURPOSE. See the GNU General Public
3261 #rec_double.h: * License for more details.
3263 #rec_double.h: * The GNU General Public License should be included with
3264 #rec_double.h: * this file. If not, you can view it at
3265 #rec_double.h: * http://www.gnu.org/copyleft/gpl.html
3266 #rec_double.h: * or write to the Free Software Foundation, Inc., 59
3267 #rec_double.h: * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3269 #rec_double.h: * VI users : Please "set tabstop=3 shiftwidth=3" to view this file,
3270 #rec_double.h: * and edit IJB, correctly.
3272 #rec_double.h: * Revisions :
3273 #rec_double.h: * $Log: contrib.sh,v $
3274 #rec_double.h: * Revision 1.1 2001/12/07 01:54:50 iwanttokeepanon
3275 #rec_double.h: * A contribution/recomendation to the IJBSWA group for a generic doubly
3276 #rec_double.h: * linked list. This file is a home brew "bash tar" (I cannot create a
3277 #rec_double.h: * contrib directory and I cannot upload a tarball ... it gets
3278 #rec_double.h: * corrupted). This script will expand all files needed to create the
3279 #rec_double.h: * linked list modules and an example program. Please see the README.
3280 #rec_double.h: * Feed back is welcomed. Enjoy.
3283 #rec_double.h: *********************************************************************/
3286 #rec_double.h:#ifdef __cplusplus
3287 #rec_double.h:extern "C" {
3288 #rec_double.h:#endif
3291 #rec_double.h:struct derived_rec_double
3293 #rec_double.h: /* private: */
3294 #rec_double.h: struct gen_list_rec parent_rec;
3295 #rec_double.h: double contents;
3298 #rec_double.h:/* public: */
3299 #rec_double.h:extern struct derived_rec_double * derived_rec_double_construct( const double _contents );
3300 #rec_double.h:extern struct derived_rec_double * derived_rec_double_copy_construct( const struct derived_rec_double *this_rec );
3301 #rec_double.h:extern struct derived_rec_double * derived_rec_double_destruct( struct derived_rec_double *this_rec );
3302 #rec_double.h:extern const struct derived_rec_double *derived_rec_double_stream( const struct derived_rec_double *this_rec );
3303 #rec_double.h:extern int derived_rec_double_equal( const struct derived_rec_double *this_rec, const struct derived_rec_double *eq_rec );
3305 #rec_double.h:/* struct/class COMPLETE */
3308 #rec_double.h:#ifdef __cplusplus
3309 #rec_double.h:} /* extern "C" */
3310 #rec_double.h:#endif
3312 #rec_double.h:#endif /* ndef REC_DOUBLE_H_INCLUDED */
3315 #rec_double.h: Local Variables:
3316 #rec_double.h: tab-width: 3
3321 #rec_long.c:const char rec_long_rcs[] = "$Id: contrib.sh,v 1.1 2001/12/07 01:54:50 iwanttokeepanon Exp $";
3322 #rec_long.c:/*********************************************************************
3324 #rec_long.c: * File : $Source: /cvsroot/ijbswa/current/contrib.sh,v $
3326 #rec_long.c: * Purpose : A "derived class" of gen_list_rec.
3328 #rec_long.c: * Copyright : Written by and Copyright (C) 2001 the SourceForge
3329 #rec_long.c: * Privoxy team. http://ijbswa.sourceforge.net
3331 #rec_long.c: * This program is free software; you can redistribute it
3332 #rec_long.c: * and/or modify it under the terms of the GNU General
3333 #rec_long.c: * Public License as published by the Free Software
3334 #rec_long.c: * Foundation; either version 2 of the License, or (at
3335 #rec_long.c: * your option) any later version.
3337 #rec_long.c: * This program is distributed in the hope that it will
3338 #rec_long.c: * be useful, but WITHOUT ANY WARRANTY; without even the
3339 #rec_long.c: * implied warranty of MERCHANTABILITY or FITNESS FOR A
3340 #rec_long.c: * PARTICULAR PURPOSE. See the GNU General Public
3341 #rec_long.c: * License for more details.
3343 #rec_long.c: * The GNU General Public License should be included with
3344 #rec_long.c: * this file. If not, you can view it at
3345 #rec_long.c: * http://www.gnu.org/copyleft/gpl.html
3346 #rec_long.c: * or write to the Free Software Foundation, Inc., 59
3347 #rec_long.c: * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3349 #rec_long.c: * VI users : Please "set tabstop=3 shiftwidth=3" to view this file,
3350 #rec_long.c: * and edit IJB, correctly.
3352 #rec_long.c: * Revisions :
3353 #rec_long.c: * $Log: contrib.sh,v $
3354 #rec_long.c: * Revision 1.1 2001/12/07 01:54:50 iwanttokeepanon
3355 #rec_long.c: * A contribution/recomendation to the IJBSWA group for a generic doubly
3356 #rec_long.c: * linked list. This file is a home brew "bash tar" (I cannot create a
3357 #rec_long.c: * contrib directory and I cannot upload a tarball ... it gets
3358 #rec_long.c: * corrupted). This script will expand all files needed to create the
3359 #rec_long.c: * linked list modules and an example program. Please see the README.
3360 #rec_long.c: * Feed back is welcomed. Enjoy.
3363 #rec_long.c: *********************************************************************/
3366 #rec_long.c:#include <malloc.h>
3367 #rec_long.c:#include <stdio.h>
3368 #rec_long.c:#include <stdlib.h>
3369 #rec_long.c:#include <string.h>
3371 #rec_long.c:#include "gen_list.h"
3372 #rec_long.c:#include "rec_long.h"
3374 #rec_long.c:const char rec_long_h_rcs[] = REC_LONG_H_VERSION;
3377 #rec_long.c:static const rec_method rec_long_vtable[] =
3379 #rec_long.c: (rec_method)derived_rec_long_copy_construct,
3380 #rec_long.c: (rec_method)derived_rec_long_destruct,
3381 #rec_long.c: (rec_method)derived_rec_long_stream,
3382 #rec_long.c: (rec_method)derived_rec_long_equal
3386 #rec_long.c:/*********************************************************************
3388 #rec_long.c: * Function : derived_rec_long_construct
3390 #rec_long.c: * Description : A simple derived record class that contains 1 string.
3392 #rec_long.c: * Parameters :
3393 #rec_long.c: * 1 : The record
3394 #rec_long.c: * 2 : The string to contain.
3396 #rec_long.c: * Returns : A pointer to the constructed record.
3398 #rec_long.c: *********************************************************************/
3399 #rec_long.c:struct derived_rec_long *derived_rec_long_construct( const long _contents )
3401 #rec_long.c: struct derived_rec_long *this_rec = (struct derived_rec_long *)gen_list_rec_construct(
3402 #rec_long.c: ISA_LONG,
3403 #rec_long.c: sizeof( struct derived_rec_long ),
3404 #rec_long.c: rec_long_vtable
3407 #rec_long.c: this_rec->contents = _contents;
3409 #rec_long.c: LIST_SHOW( printf( "\
3410 #rec_long.c:\t\tlong construct new rec\t\t\t\t= %p
3411 #rec_long.c:\t\tlong construct new rec contents\t= %d\n\n", (const void *)this_rec, this_rec->contents ) );
3413 #rec_long.c: return( this_rec );
3418 #rec_long.c:/*********************************************************************
3420 #rec_long.c: * Function : derived_rec_long_copy_construct
3422 #rec_long.c: * Description : Copies one long record to another.
3424 #rec_long.c: * Parameters :
3425 #rec_long.c: * 1 : Existing record.
3426 #rec_long.c: * 2 : Copy record.
3428 #rec_long.c: * Returns : The newly constructed copy record.
3430 #rec_long.c: *********************************************************************/
3431 #rec_long.c:struct derived_rec_long *derived_rec_long_copy_construct( const struct derived_rec_long *this_rec )
3433 #rec_long.c: struct derived_rec_long *copy_rec = (struct derived_rec_long *)gen_list_rec_copy_construct( (struct gen_list_rec *)this_rec );
3434 #rec_long.c: copy_rec->contents = - this_rec->contents;
3436 #rec_long.c: LIST_SHOW( printf( "\
3437 #rec_long.c:\t\tlong copy construct new gen rec\t\t\t\t= %p => %p
3438 #rec_long.c:\t\tlong copy construct new gen rec contents\t= %d\n\n", (const void *)this_rec, (const void *)copy_rec, copy_rec->contents ) );
3440 #rec_long.c: return( copy_rec );
3445 #rec_long.c:/*********************************************************************
3447 #rec_long.c: * Function : derived_rec_long_destruct
3449 #rec_long.c: * Description : Destruct the long record.
3451 #rec_long.c: * Parameters :
3452 #rec_long.c: * 1 : The record.
3454 #rec_long.c: * Returns : NULL
3456 #rec_long.c: *********************************************************************/
3457 #rec_long.c:struct derived_rec_long *derived_rec_long_destruct( struct derived_rec_long *this_rec )
3459 #rec_long.c: LIST_SHOW( printf( "\
3460 #rec_long.c:\t\tlong destruct this_rec\t\t\t\t= %p
3461 #rec_long.c:\t\tlong destruct this_rec->contents\t= %d\n\n", (const void *)this_rec, this_rec->contents ) );
3463 #rec_long.c: this_rec->contents = -1;
3464 #rec_long.c: return( (struct derived_rec_long *)gen_list_rec_destruct( (struct gen_list_rec *)this_rec ) );
3469 #rec_long.c:/*********************************************************************
3471 #rec_long.c: * Function : derived_rec_long_stream
3473 #rec_long.c: * Description : Displays all long attributes on the STDOUT stream.
3475 #rec_long.c: * Parameters :
3476 #rec_long.c: * 1 : The record.
3478 #rec_long.c: * Returns : The record.
3480 #rec_long.c: *********************************************************************/
3481 #rec_long.c:const struct derived_rec_long *derived_rec_long_stream( const struct derived_rec_long *this_rec )
3483 #rec_long.c: this_rec = (struct derived_rec_long *)gen_list_rec_stream(
3484 #rec_long.c: (struct gen_list_rec *)this_rec
3486 #rec_long.c: LIST_SHOW( printf( "\
3487 #rec_long.c:\t\tlong stream this_rec\t\t\t\t\t= %p
3488 #rec_long.c:\t\tlong stream this_rec->contents\t= %d\n\n", (const void *)this_rec, this_rec->contents ) );
3490 #rec_long.c: return( this_rec );
3495 #rec_long.c:/*********************************************************************
3497 #rec_long.c: * Function : derived_rec_long_equal
3499 #rec_long.c: * Description : Compares two long records to see if they are equal.
3501 #rec_long.c: * Parameters :
3502 #rec_long.c: * 1 : A record.
3503 #rec_long.c: * 2 : Another record.
3505 #rec_long.c: * Returns : 0 => NOT EQUAL, anything else is EQUAL.
3507 #rec_long.c: *********************************************************************/
3508 #rec_long.c:int derived_rec_long_equal( const struct derived_rec_long *this_rec, const struct derived_rec_long *eq_rec )
3510 #rec_long.c: if ( ! gen_list_rec_equal( (const struct gen_list_rec *)this_rec, (struct gen_list_rec *)eq_rec ) )
3512 #rec_long.c: return( 0 );
3514 #rec_long.c: return( this_rec->contents == eq_rec->contents );
3519 #rec_long.h:#ifndef REC_LONG_H_INCLUDED
3520 #rec_long.h:#define REC_LONG_H_INCLUDED
3521 #rec_long.h:#define REC_LONG_H_VERSION "$Id: contrib.sh,v 1.1 2001/12/07 01:54:50 iwanttokeepanon Exp $"
3522 #rec_long.h:/*********************************************************************
3524 #rec_long.h: * File : $Source: /cvsroot/ijbswa/current/contrib.sh,v $
3526 #rec_long.h: * Purpose : A "derived class" of gen_list_rec.
3528 #rec_long.h: * Copyright : Written by and Copyright (C) 2001 the SourceForge
3529 #rec_long.h: * Privoxy team. http://ijbswa.sourceforge.net
3531 #rec_long.h: * This program is free software; you can redistribute it
3532 #rec_long.h: * and/or modify it under the terms of the GNU General
3533 #rec_long.h: * Public License as published by the Free Software
3534 #rec_long.h: * Foundation; either version 2 of the License, or (at
3535 #rec_long.h: * your option) any later version.
3537 #rec_long.h: * This program is distributed in the hope that it will
3538 #rec_long.h: * be useful, but WITHOUT ANY WARRANTY; without even the
3539 #rec_long.h: * implied warranty of MERCHANTABILITY or FITNESS FOR A
3540 #rec_long.h: * PARTICULAR PURPOSE. See the GNU General Public
3541 #rec_long.h: * License for more details.
3543 #rec_long.h: * The GNU General Public License should be included with
3544 #rec_long.h: * this file. If not, you can view it at
3545 #rec_long.h: * http://www.gnu.org/copyleft/gpl.html
3546 #rec_long.h: * or write to the Free Software Foundation, Inc., 59
3547 #rec_long.h: * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3549 #rec_long.h: * VI users : Please "set tabstop=3 shiftwidth=3" to view this file,
3550 #rec_long.h: * and edit IJB, correctly.
3552 #rec_long.h: * Revisions :
3553 #rec_long.h: * $Log: contrib.sh,v $
3554 #rec_long.h: * Revision 1.1 2001/12/07 01:54:50 iwanttokeepanon
3555 #rec_long.h: * A contribution/recomendation to the IJBSWA group for a generic doubly
3556 #rec_long.h: * linked list. This file is a home brew "bash tar" (I cannot create a
3557 #rec_long.h: * contrib directory and I cannot upload a tarball ... it gets
3558 #rec_long.h: * corrupted). This script will expand all files needed to create the
3559 #rec_long.h: * linked list modules and an example program. Please see the README.
3560 #rec_long.h: * Feed back is welcomed. Enjoy.
3563 #rec_long.h: *********************************************************************/
3566 #rec_long.h:#ifdef __cplusplus
3567 #rec_long.h:extern "C" {
3571 #rec_long.h:struct derived_rec_long
3573 #rec_long.h: /* private: */
3574 #rec_long.h: struct gen_list_rec parent_rec;
3575 #rec_long.h: long contents;
3578 #rec_long.h:/* public: */
3579 #rec_long.h:extern struct derived_rec_long * derived_rec_long_construct( const long _contents );
3580 #rec_long.h:extern struct derived_rec_long * derived_rec_long_copy_construct( const struct derived_rec_long *this_rec );
3581 #rec_long.h:extern struct derived_rec_long * derived_rec_long_destruct( struct derived_rec_long *this_rec );
3582 #rec_long.h:extern const struct derived_rec_long *derived_rec_long_stream( const struct derived_rec_long *this_rec );
3583 #rec_long.h:extern int derived_rec_long_equal( const struct derived_rec_long *this_rec, const struct derived_rec_long *eq_rec );
3585 #rec_long.h:/* struct/class COMPLETE */
3588 #rec_long.h:#ifdef __cplusplus
3589 #rec_long.h:} /* extern "C" */
3592 #rec_long.h:#endif /* ndef REC_LONG_H_INCLUDED */
3595 #rec_long.h: Local Variables:
3596 #rec_long.h: tab-width: 3
3601 #rec_malloc_police.c:const char rec_malloc_police_rcs[] = "$Id: contrib.sh,v 1.1 2001/12/07 01:54:50 iwanttokeepanon Exp $";
3602 #rec_malloc_police.c:/*********************************************************************
3603 #rec_malloc_police.c: *
3604 #rec_malloc_police.c: * File : $Source: /cvsroot/ijbswa/current/contrib.sh,v $
3605 #rec_malloc_police.c: *
3606 #rec_malloc_police.c: * Purpose : A "derived class" of gen_list_rec.
3607 #rec_malloc_police.c: * This class helps to build a list of allocated and
3608 #rec_malloc_police.c: * freed memory. When the program exits, we will print
3609 #rec_malloc_police.c: * a list of all memory that was allocated, but never
3610 #rec_malloc_police.c: * freed. This could be most helpful to developers
3611 #rec_malloc_police.c: * and debugers.
3612 #rec_malloc_police.c: *
3613 #rec_malloc_police.c: * Copyright : Written by and Copyright (C) 2001 the SourceForge
3614 #rec_malloc_police.c: * Privoxy team. http://ijbswa.sourceforge.net
3615 #rec_malloc_police.c: *
3616 #rec_malloc_police.c: * This program is free software; you can redistribute it
3617 #rec_malloc_police.c: * and/or modify it under the terms of the GNU General
3618 #rec_malloc_police.c: * Public License as published by the Free Software
3619 #rec_malloc_police.c: * Foundation; either version 2 of the License, or (at
3620 #rec_malloc_police.c: * your option) any later version.
3621 #rec_malloc_police.c: *
3622 #rec_malloc_police.c: * This program is distributed in the hope that it will
3623 #rec_malloc_police.c: * be useful, but WITHOUT ANY WARRANTY; without even the
3624 #rec_malloc_police.c: * implied warranty of MERCHANTABILITY or FITNESS FOR A
3625 #rec_malloc_police.c: * PARTICULAR PURPOSE. See the GNU General Public
3626 #rec_malloc_police.c: * License for more details.
3627 #rec_malloc_police.c: *
3628 #rec_malloc_police.c: * The GNU General Public License should be included with
3629 #rec_malloc_police.c: * this file. If not, you can view it at
3630 #rec_malloc_police.c: * http://www.gnu.org/copyleft/gpl.html
3631 #rec_malloc_police.c: * or write to the Free Software Foundation, Inc., 59
3632 #rec_malloc_police.c: * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3633 #rec_malloc_police.c: *
3634 #rec_malloc_police.c: * VI users : Please "set tabstop=3 shiftwidth=3" to view this file,
3635 #rec_malloc_police.c: * and edit IJB, correctly.
3636 #rec_malloc_police.c: *
3637 #rec_malloc_police.c: * Revisions :
3638 #rec_malloc_police.c: * $Log: contrib.sh,v $
3639 #rec_malloc_police.c: * Revision 1.1 2001/12/07 01:54:50 iwanttokeepanon
3640 #rec_malloc_police.c: * A contribution/recomendation to the IJBSWA group for a generic doubly
3641 #rec_malloc_police.c: * linked list. This file is a home brew "bash tar" (I cannot create a
3642 #rec_malloc_police.c: * contrib directory and I cannot upload a tarball ... it gets
3643 #rec_malloc_police.c: * corrupted). This script will expand all files needed to create the
3644 #rec_malloc_police.c: * linked list modules and an example program. Please see the README.
3645 #rec_malloc_police.c: * Feed back is welcomed. Enjoy.
3646 #rec_malloc_police.c: *
3647 #rec_malloc_police.c: *
3648 #rec_malloc_police.c: *********************************************************************/
3649 #rec_malloc_police.c:
\f
3650 #rec_malloc_police.c:
3651 #rec_malloc_police.c:#include <stdio.h>
3652 #rec_malloc_police.c:
3653 #rec_malloc_police.c:#include "gen_list.h"
3654 #rec_malloc_police.c:#include "malloc_police.h"
3655 #rec_malloc_police.c:#include "rec_malloc_police.h"
3656 #rec_malloc_police.c:
3657 #rec_malloc_police.c:const char rec_malloc_police_h_rcs[] = REC_MALLOC_POLICE_H_VERSION;
3658 #rec_malloc_police.c:
3659 #rec_malloc_police.c:
3660 #rec_malloc_police.c:static const rec_method rec_malloc_police_vtable[] =
3661 #rec_malloc_police.c:{
3662 #rec_malloc_police.c: (rec_method)derived_rec_malloc_police_copy_construct,
3663 #rec_malloc_police.c: (rec_method)derived_rec_malloc_police_destruct,
3664 #rec_malloc_police.c: (rec_method)derived_rec_malloc_police_stream,
3665 #rec_malloc_police.c: (rec_method)derived_rec_malloc_police_equal
3666 #rec_malloc_police.c:};
3667 #rec_malloc_police.c:
3668 #rec_malloc_police.c:
3669 #rec_malloc_police.c:/*********************************************************************
3670 #rec_malloc_police.c: *
3671 #rec_malloc_police.c: * Function : derived_rec_malloc_police_construct
3672 #rec_malloc_police.c: *
3673 #rec_malloc_police.c: * Description : A simple derived record class that contains 1 string.
3674 #rec_malloc_police.c: *
3675 #rec_malloc_police.c: * Parameters :
3676 #rec_malloc_police.c: * 1 : The record
3677 #rec_malloc_police.c: * 2 : The string to contain.
3678 #rec_malloc_police.c: *
3679 #rec_malloc_police.c: * Returns : A pointer to the constructed record.
3680 #rec_malloc_police.c: *
3681 #rec_malloc_police.c: *********************************************************************/
3682 #rec_malloc_police.c:struct derived_rec_malloc_police *derived_rec_malloc_police_construct( void *_alloced_addr, char *_source_where, size_t _sz )
3683 #rec_malloc_police.c:{
3684 #rec_malloc_police.c: struct derived_rec_malloc_police *this_rec;
3685 #rec_malloc_police.c: list_is_quiet ++;
3686 #rec_malloc_police.c:
3687 #rec_malloc_police.c: this_rec = (struct derived_rec_malloc_police *)gen_list_rec_construct(
3688 #rec_malloc_police.c: ISA_MALLOC_POLICE,
3689 #rec_malloc_police.c: sizeof( struct derived_rec_malloc_police ),
3690 #rec_malloc_police.c: rec_malloc_police_vtable
3691 #rec_malloc_police.c: );
3692 #rec_malloc_police.c:
3693 #rec_malloc_police.c: this_rec->alloced_addr = _alloced_addr;
3694 #rec_malloc_police.c: this_rec->source_where = STRDUP( _source_where );
3695 #rec_malloc_police.c: this_rec->sz = _sz;
3696 #rec_malloc_police.c:
3697 #rec_malloc_police.c:/* LIST_SHOW( printf( "\ */
3698 #rec_malloc_police.c:/* \t\tmalloc_police construct new rec\t\t\t\t\t= %p */
3699 #rec_malloc_police.c:/* \t\tmalloc_police construct new rec alloced_addr = %p */
3700 #rec_malloc_police.c:/* \t\tmalloc_police construct new rec source_where = %s */
3701 #rec_malloc_police.c:/* \t\tmalloc_police construct new rec sz\t\t\t\t\t= %ld\n\n", */
3702 #rec_malloc_police.c:/* (const void *)this_rec, */
3703 #rec_malloc_police.c:/* this_rec->alloced_addr, */
3704 #rec_malloc_police.c:/* this_rec->source_where, */
3705 #rec_malloc_police.c:/* this_rec->sz */
3706 #rec_malloc_police.c:/* ) ); */
3707 #rec_malloc_police.c:
3708 #rec_malloc_police.c: list_is_quiet --;
3709 #rec_malloc_police.c:
3710 #rec_malloc_police.c: return( this_rec );
3711 #rec_malloc_police.c:
3712 #rec_malloc_police.c:}
3713 #rec_malloc_police.c:
3714 #rec_malloc_police.c:
3715 #rec_malloc_police.c:/*********************************************************************
3716 #rec_malloc_police.c: *
3717 #rec_malloc_police.c: * Function : derived_rec_malloc_police_copy_construct
3718 #rec_malloc_police.c: *
3719 #rec_malloc_police.c: * Description : Copies one malloc_police record to another.
3720 #rec_malloc_police.c: *
3721 #rec_malloc_police.c: * Parameters :
3722 #rec_malloc_police.c: * 1 : Existing record.
3723 #rec_malloc_police.c: * 2 : Copy record.
3724 #rec_malloc_police.c: *
3725 #rec_malloc_police.c: * Returns : The newly constructed copy record.
3726 #rec_malloc_police.c: *
3727 #rec_malloc_police.c: *********************************************************************/
3728 #rec_malloc_police.c:struct derived_rec_malloc_police *derived_rec_malloc_police_copy_construct( const struct derived_rec_malloc_police *this_rec )
3729 #rec_malloc_police.c:{
3730 #rec_malloc_police.c: int len;
3731 #rec_malloc_police.c: char *new_contents;
3732 #rec_malloc_police.c: struct derived_rec_malloc_police *copy_rec;
3733 #rec_malloc_police.c:
3734 #rec_malloc_police.c: list_is_quiet ++;
3735 #rec_malloc_police.c:
3736 #rec_malloc_police.c: copy_rec = (struct derived_rec_malloc_police *)gen_list_rec_copy_construct( (struct gen_list_rec *)this_rec );
3737 #rec_malloc_police.c:
3738 #rec_malloc_police.c: copy_rec->alloced_addr = this_rec->alloced_addr;
3739 #rec_malloc_police.c: copy_rec->source_where = STRDUP( this_rec->source_where );
3740 #rec_malloc_police.c: copy_rec->sz = this_rec->sz;
3741 #rec_malloc_police.c:
3742 #rec_malloc_police.c:/* LIST_SHOW( printf( "\ */
3743 #rec_malloc_police.c:/* \t\tmalloc_police copy construct new gen rec = %p => %p */
3744 #rec_malloc_police.c:/* \t\tmalloc_police copy construct new gen rec alloced_addr = %p */
3745 #rec_malloc_police.c:/* \t\tmalloc_police copy construct new gen rec source_where = %s */
3746 #rec_malloc_police.c:/* \t\tmalloc_police copy construct new gen rec sz\t\t\t\t\t= %ld\n\n", */
3747 #rec_malloc_police.c:/* (const void *)this_rec, (const void *)copy_rec, */
3748 #rec_malloc_police.c:/* copy_rec->alloced_addr, */
3749 #rec_malloc_police.c:/* copy_rec->source_where, */
3750 #rec_malloc_police.c:/* copy_rec->sz */
3751 #rec_malloc_police.c:/* ) ); */
3752 #rec_malloc_police.c:
3753 #rec_malloc_police.c: list_is_quiet --;
3754 #rec_malloc_police.c:
3755 #rec_malloc_police.c: return( copy_rec );
3756 #rec_malloc_police.c:
3757 #rec_malloc_police.c:}
3758 #rec_malloc_police.c:
3759 #rec_malloc_police.c:
3760 #rec_malloc_police.c:/*********************************************************************
3761 #rec_malloc_police.c: *
3762 #rec_malloc_police.c: * Function : derived_rec_malloc_police_destruct
3763 #rec_malloc_police.c: *
3764 #rec_malloc_police.c: * Description : Destruct the malloc_police record.
3765 #rec_malloc_police.c: *
3766 #rec_malloc_police.c: * Parameters :
3767 #rec_malloc_police.c: * 1 : The record.
3768 #rec_malloc_police.c: *
3769 #rec_malloc_police.c: * Returns : NULL
3770 #rec_malloc_police.c: *
3771 #rec_malloc_police.c: *********************************************************************/
3772 #rec_malloc_police.c:struct derived_rec_malloc_police *derived_rec_malloc_police_destruct( struct derived_rec_malloc_police *this_rec )
3773 #rec_malloc_police.c:{
3774 #rec_malloc_police.c: struct derived_rec_malloc_police *d;
3775 #rec_malloc_police.c: list_is_quiet ++;
3776 #rec_malloc_police.c:
3777 #rec_malloc_police.c:/* LIST_SHOW( printf( "\ */
3778 #rec_malloc_police.c:/* \t\tmalloc_police destruct this_rec\t\t\t\t\t\t= %p */
3779 #rec_malloc_police.c:/* \t\tmalloc_police destruct this_rec->alloced_addr\t= %p */
3780 #rec_malloc_police.c:/* \t\tmalloc_police destruct this_rec->source_where\t= %s, */
3781 #rec_malloc_police.c:/* \t\tmalloc_police destruct this_rec->sz\t\t\t\t\t= %ld\n\n", */
3782 #rec_malloc_police.c:/* (const void *)this_rec, */
3783 #rec_malloc_police.c:/* this_rec->alloced_addr, */
3784 #rec_malloc_police.c:/* this_rec->source_where, */
3785 #rec_malloc_police.c:/* this_rec->sz */
3786 #rec_malloc_police.c:/* ) ); */
3787 #rec_malloc_police.c:
3788 #rec_malloc_police.c: memset( this_rec->source_where, '!', strlen( this_rec->source_where ) );
3789 #rec_malloc_police.c: FREE( this_rec->source_where );
3790 #rec_malloc_police.c:
3791 #rec_malloc_police.c: d = (struct derived_rec_malloc_police *)gen_list_rec_destruct( (struct gen_list_rec *)this_rec );
3792 #rec_malloc_police.c: list_is_quiet --;
3793 #rec_malloc_police.c:
3794 #rec_malloc_police.c: return( d );
3795 #rec_malloc_police.c:
3796 #rec_malloc_police.c:}
3797 #rec_malloc_police.c:
3798 #rec_malloc_police.c:
3799 #rec_malloc_police.c:/*********************************************************************
3800 #rec_malloc_police.c: *
3801 #rec_malloc_police.c: * Function : derived_rec_malloc_police_stream
3802 #rec_malloc_police.c: *
3803 #rec_malloc_police.c: * Description : Displays all malloc_police attributes on the STDOUT stream.
3804 #rec_malloc_police.c: *
3805 #rec_malloc_police.c: * Parameters :
3806 #rec_malloc_police.c: * 1 : The record.
3807 #rec_malloc_police.c: *
3808 #rec_malloc_police.c: * Returns : The record.
3809 #rec_malloc_police.c: *
3810 #rec_malloc_police.c: *********************************************************************/
3811 #rec_malloc_police.c:const struct derived_rec_malloc_police *derived_rec_malloc_police_stream( const struct derived_rec_malloc_police *this_rec )
3812 #rec_malloc_police.c:{
3813 #rec_malloc_police.c: list_is_quiet ++;
3814 #rec_malloc_police.c:
3815 #rec_malloc_police.c: this_rec = (struct derived_rec_malloc_police *)gen_list_rec_stream(
3816 #rec_malloc_police.c: (struct gen_list_rec *)this_rec
3817 #rec_malloc_police.c: );
3818 #rec_malloc_police.c: LIST_SHOW( printf( "\
3819 #rec_malloc_police.c:\t\tmalloc_police stream this_rec\t\t\t\t\t= %p
3820 #rec_malloc_police.c:\t\tmalloc_police stream this_rec->alloced_addr\t= %p
3821 #rec_malloc_police.c:\t\tmalloc_police stream this_rec->source_where\t= %s
3822 #rec_malloc_police.c:\t\tmalloc_police stream this_rec->sz\t\t\t\t= %ld\n\n",
3823 #rec_malloc_police.c: (const void *)this_rec,
3824 #rec_malloc_police.c: this_rec->alloced_addr,
3825 #rec_malloc_police.c: this_rec->source_where,
3826 #rec_malloc_police.c: this_rec->sz
3827 #rec_malloc_police.c: ) );
3828 #rec_malloc_police.c:
3829 #rec_malloc_police.c: list_is_quiet --;
3830 #rec_malloc_police.c: return( this_rec );
3831 #rec_malloc_police.c:
3832 #rec_malloc_police.c:}
3833 #rec_malloc_police.c:
3834 #rec_malloc_police.c:
3835 #rec_malloc_police.c:/*********************************************************************
3836 #rec_malloc_police.c: *
3837 #rec_malloc_police.c: * Function : derived_rec_malloc_police_equal
3838 #rec_malloc_police.c: *
3839 #rec_malloc_police.c: * Description : Compares two malloc_police records to see if they are equal.
3840 #rec_malloc_police.c: *
3841 #rec_malloc_police.c: * Parameters :
3842 #rec_malloc_police.c: * 1 : A record.
3843 #rec_malloc_police.c: * 2 : Another record.
3844 #rec_malloc_police.c: *
3845 #rec_malloc_police.c: * Returns : 0 => NOT EQUAL, anything else is EQUAL.
3846 #rec_malloc_police.c: *
3847 #rec_malloc_police.c: *********************************************************************/
3848 #rec_malloc_police.c:int derived_rec_malloc_police_equal( const struct derived_rec_malloc_police *this_rec, const struct derived_rec_malloc_police *eq_rec )
3849 #rec_malloc_police.c:{
3850 #rec_malloc_police.c: list_is_quiet ++;
3851 #rec_malloc_police.c:
3852 #rec_malloc_police.c: if ( ! gen_list_rec_equal( (const struct gen_list_rec *)this_rec, (struct gen_list_rec *)eq_rec ) )
3853 #rec_malloc_police.c: {
3854 #rec_malloc_police.c: return( 0 );
3855 #rec_malloc_police.c: }
3856 #rec_malloc_police.c:
3857 #rec_malloc_police.c: list_is_quiet --;
3858 #rec_malloc_police.c: return( this_rec->alloced_addr == eq_rec->alloced_addr );
3859 #rec_malloc_police.c:
3860 #rec_malloc_police.c:}
3863 #rec_malloc_police.h:#ifndef REC_MALLOC_POLICE_H_INCLUDED
3864 #rec_malloc_police.h:#define REC_MALLOC_POLICE_H_INCLUDED
3865 #rec_malloc_police.h:#define REC_MALLOC_POLICE_H_VERSION "$Id: contrib.sh,v 1.1 2001/12/07 01:54:50 iwanttokeepanon Exp $"
3866 #rec_malloc_police.h:/*********************************************************************
3867 #rec_malloc_police.h: *
3868 #rec_malloc_police.h: * File : $Source: /cvsroot/ijbswa/current/contrib.sh,v $
3869 #rec_malloc_police.h: *
3870 #rec_malloc_police.h: * Purpose : A "derived class" of gen_list_rec.
3871 #rec_malloc_police.h: * This class helps to build a list of allocated and
3872 #rec_malloc_police.h: * freed memory. When the program exits, we will print
3873 #rec_malloc_police.h: * a list of all memory that was allocated, but never
3874 #rec_malloc_police.h: * freed. This could be most helpful to developers
3875 #rec_malloc_police.h: * and debugers.
3876 #rec_malloc_police.h: *
3877 #rec_malloc_police.h: * Copyright : Written by and Copyright (C) 2001 the SourceForge
3878 #rec_malloc_police.h: * Privoxy team. http://ijbswa.sourceforge.net
3879 #rec_malloc_police.h: *
3880 #rec_malloc_police.h: * This program is free software; you can redistribute it
3881 #rec_malloc_police.h: * and/or modify it under the terms of the GNU General
3882 #rec_malloc_police.h: * Public License as published by the Free Software
3883 #rec_malloc_police.h: * Foundation; either version 2 of the License, or (at
3884 #rec_malloc_police.h: * your option) any later version.
3885 #rec_malloc_police.h: *
3886 #rec_malloc_police.h: * This program is distributed in the hope that it will
3887 #rec_malloc_police.h: * be useful, but WITHOUT ANY WARRANTY; without even the
3888 #rec_malloc_police.h: * implied warranty of MERCHANTABILITY or FITNESS FOR A
3889 #rec_malloc_police.h: * PARTICULAR PURPOSE. See the GNU General Public
3890 #rec_malloc_police.h: * License for more details.
3891 #rec_malloc_police.h: *
3892 #rec_malloc_police.h: * The GNU General Public License should be included with
3893 #rec_malloc_police.h: * this file. If not, you can view it at
3894 #rec_malloc_police.h: * http://www.gnu.org/copyleft/gpl.html
3895 #rec_malloc_police.h: * or write to the Free Software Foundation, Inc., 59
3896 #rec_malloc_police.h: * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3897 #rec_malloc_police.h: *
3898 #rec_malloc_police.h: * VI users : Please "set tabstop=3 shiftwidth=3" to view this file,
3899 #rec_malloc_police.h: * and edit IJB, correctly.
3900 #rec_malloc_police.h: *
3901 #rec_malloc_police.h: * Revisions :
3902 #rec_malloc_police.h: * $Log: contrib.sh,v $
3903 #rec_malloc_police.h: * Revision 1.1 2001/12/07 01:54:50 iwanttokeepanon
3904 #rec_malloc_police.h: * A contribution/recomendation to the IJBSWA group for a generic doubly
3905 #rec_malloc_police.h: * linked list. This file is a home brew "bash tar" (I cannot create a
3906 #rec_malloc_police.h: * contrib directory and I cannot upload a tarball ... it gets
3907 #rec_malloc_police.h: * corrupted). This script will expand all files needed to create the
3908 #rec_malloc_police.h: * linked list modules and an example program. Please see the README.
3909 #rec_malloc_police.h: * Feed back is welcomed. Enjoy.
3910 #rec_malloc_police.h: *
3911 #rec_malloc_police.h: *
3912 #rec_malloc_police.h: *********************************************************************/
3913 #rec_malloc_police.h:
\f
3914 #rec_malloc_police.h:
3915 #rec_malloc_police.h:#ifdef __cplusplus
3916 #rec_malloc_police.h:extern "C" {
3917 #rec_malloc_police.h:#endif
3918 #rec_malloc_police.h:
3919 #rec_malloc_police.h:
3920 #rec_malloc_police.h:struct derived_rec_malloc_police
3921 #rec_malloc_police.h:{
3922 #rec_malloc_police.h: /* private: */
3923 #rec_malloc_police.h: struct gen_list_rec parent_rec;
3924 #rec_malloc_police.h: void *alloced_addr;
3925 #rec_malloc_police.h: char *source_where;
3926 #rec_malloc_police.h: size_t sz;
3927 #rec_malloc_police.h:};
3928 #rec_malloc_police.h:
3929 #rec_malloc_police.h:/* public: */
3930 #rec_malloc_police.h:extern struct derived_rec_malloc_police * derived_rec_malloc_police_construct( void *_alloced_addr, char *_source_where, size_t _sz );
3931 #rec_malloc_police.h:extern struct derived_rec_malloc_police * derived_rec_malloc_police_copy_construct( const struct derived_rec_malloc_police *this_rec );
3932 #rec_malloc_police.h:extern struct derived_rec_malloc_police * derived_rec_malloc_police_destruct( struct derived_rec_malloc_police *this_rec );
3933 #rec_malloc_police.h:extern const struct derived_rec_malloc_police *derived_rec_malloc_police_stream( const struct derived_rec_malloc_police *this_rec );
3934 #rec_malloc_police.h:extern int derived_rec_malloc_police_equal( const struct derived_rec_malloc_police *this_rec, const struct derived_rec_malloc_police *eq_rec );
3935 #rec_malloc_police.h:
3936 #rec_malloc_police.h:/* struct/class COMPLETE */
3937 #rec_malloc_police.h:
3938 #rec_malloc_police.h:
3939 #rec_malloc_police.h:#ifdef __cplusplus
3940 #rec_malloc_police.h:} /* extern "C" */
3941 #rec_malloc_police.h:#endif
3942 #rec_malloc_police.h:
3943 #rec_malloc_police.h:
3944 #rec_malloc_police.h:#endif /* ndef REC_MALLOC_POLICE_H_INCLUDED */
3945 #rec_malloc_police.h:
3946 #rec_malloc_police.h:/*
3947 #rec_malloc_police.h: Local Variables:
3948 #rec_malloc_police.h: tab-width: 3
3949 #rec_malloc_police.h: end:
3950 #rec_malloc_police.h:*/
3953 ###########################################################################
3954 ## Description: makeInsertableFile
3955 ## Use this function to make a file suitable for insertion into this
3956 ## script. This file (x), will contain all of the files listed.
3962 ## Return status: (0) - Everything is Okay, anything else is an error
3963 ###########################################################################
3965 function makeInsertableFile {
3969 for i in ${fileList}; do
3970 sed -e "s/^/#${i}:/" ${i} >> x
projects / privoxy.git / blob