/* %Z%%M% %I% %E% */

/*
 * Copyright (c) 1990-2005 by Wayne C. Gramlich.
 * All rights reserved.
 */

/* Dynamic length array exported routine interfaces: */

#ifndef VECTOR_EXPORTS_H
#define VECTOR_EXPORTS_H

#ifndef HEAP_TYPES_H
#include "heap_types.h"
#endif

#ifndef UNIX_STDIO_H
#include "unix_stdio.h"
#endif

#ifndef VECTOR_TYPES_H
#include "vector_types.h"
#endif

#if defined(lint)

#    define VEC_ROUTINE_TH(type, routine, handle) \
	(Vector_routine_th) (routine((type)0, handle))
#    define VEC_ROUTINE_TTH(type, routine, handle) \
	(Vector_routine_tth) (routine((type)0, (type)0, handle))
#    define VEC_ROUTINE_THF(type, routine, handle) \
	(Vector_routine_thf) (routine((type)0, (Stdio)0, handle))
#    define VEC_ROUTINE_HFH(type, routine, handle) \
	(Vector_routine_hfh) \
		(routine((Stdio)0, (Heap)0, handle) == ((type)0))
#    define VEC_T2D(type, expression) \
	( (Vector_datum)((expression) == ((type)0)) )

#else /* lint */

#    define VEC_ROUTINE_TH(type, routine, handle) \
	(Vector_routine_th)(routine)
#    define VEC_ROUTINE_TTH(type, routine, handle) \
	(Vector_routine_tth)(routine)
#    define VEC_ROUTINE_THF(type, routine, handle) \
	(Vector_routine_thf)(routine)
#    define VEC_ROUTINE_HFH(type, routine, handle) \
	(Vector_routine_hfh)(routine)
#    define VEC_T2D(type, expression) \
	(Vector_datum) (expression)

#endif /* lint */

#define VEC_HANDLE(handle) \
	((Vector_handle)(handle))
#define VEC_LOOP(type, vec, var) \
	for ((vec)->index = 0; \
	     (vec)->index < (vec)->size ? \
	      (unsigned)((var) = (type) ((vec)->data[(vec)->index])) | 1 : 0; \
	     (vec)->index++ )

#define vec_append(type, vec, datum) \
	vector_append(vec, VEC_T2D(type, datum))
#define vec_copy(type, vec) \
	vector_copy(vec)
#define vec_create(type, heap) \
	vector_create(heap)
#define vec_xcreate(type) \
	vector_xcreate()
#define vec_delete(type, vec, index) \
	vector_delete(vec, index)
#define vec_destroy(type, vec) \
	vector_destroy(vec)
#define vec_empty(type, vec) \
	vector_empty(vec)
#define	vec_equal(type, vec1, vec2, routine, handle) \
	vector_equal(vec1, vec2, VEC_ROUTINE_TTH(type, routine, handle), \
		     VEC_HANDLE(handle))
#define vec_fetch(type, vec, index) \
	((type) vector_fetch(vec, index))
#define vec_index(type, vec) \
	vector_index(vec)
#define vec_insert(type, vec, index, datum) \
	vector_insert(vec, index, VEC_T2D(type, datum))
#define vec_iterate(type, vec, routine, handle) \
	vector_iterate(vec, VEC_ROUTINE_TH(type, routine, handle), \
		       VEC_HANDLE(handle))
#define vec_lop(type, vec) \
	((type) vector_lop(vec))
#define vec_pop(type, vec) \
	((type) vector_pop(vec))
#define vec_predict(type, vec, size) \
	vector_predict(vec, size)
#define vec_prepend(type, vec, datum) \
	vector_prepend(vec, VEC_T2D(type, datum))
#define vec_range_delete(type, vec, index, number) \
	vector_range_delete(vec, index, number)
#define vec_range_insert(type, vec, index, number, datum) \
	vector_range_insert(vec, index, number, VEC_T2D(type, datum))
#define vec_range_store(type, vec, index, number, datum) \
	vector_range_store(vec, index, number, VEC_T2D(type, datum))
#define vec_read(type, routine, in_file, heap, handle) \
	vector_read(VEC_ROUTINE_HFH(type, routine, handle), \
				    in_file, heap, VEC_HANDLE(handle))
#define vec_store(type, vec, index, datum) \
	vector_store(vec, index, VEC_T2D(type, datum))
#define vec_search_binary(type, vec, datum, routine, handle) \
	vector_search_binary(vec, VEC_T2D(type, datum), \
			     VEC_ROUTINE_TTH(type, routine, handle), \
			     VEC_HANDLE(handle))
#define vec_sort(type, vec, routine, handle) \
	vector_sort(vec, VEC_ROUTINE_TTH(type, routine, handle), \
		    VEC_HANDLE(handle))
#define vec_size(type, vec) \
	vector_size(vec)
#define vec_trim(type, vec, size) \
	vector_trim(vec, size)
#define	vec_vec_append(type, vec_dest, vec_source) \
	vector_vector_append(vec_dest, vec_source)
#define vec_write(type, vec, routine, out_file, handle) \
	vector_write(vec, VEC_ROUTINE_THF(type, routine, handle), \
		     out_file, VEC_HANDLE(handle))

extern void vector_append
			(Vektor, Vector_datum);
extern Vektor vector_copy
			(Vektor);
extern Vektor vector_create
			(Heap);
extern Vektor vector_xcreate
			(void);
extern void vector_delete
			(Vektor, Vector_index);
extern void vector_destroy
			(Vektor);
extern int vector_empty
			(Vektor);
extern int vector_equal
			(Vektor, Vektor, Vector_routine_tth, Vector_handle);
extern Vector_datum vector_fetch
			(Vektor, Vector_index);
extern Vector_index vector_index
			(Vektor);
extern void vector_insert
			(Vektor, Vector_index, Vector_datum);
extern int vector_iterate
			(Vektor, Vector_routine_th, Vector_handle);
extern Vector_datum vector_lop
			(Vektor);
extern Vector_datum vector_pop
			(Vektor);
extern void vector_predict
			(Vektor, Vector_size);
extern void vector_prepend
			(Vektor, Vector_datum);
extern void vector_range_delete
			(Vektor, Vector_index, Vector_number);
extern void vector_range_insert
			(Vektor, Vector_index, Vector_number, Vector_datum);
extern void vector_range_store
			(Vektor, Vector_index, Vector_number, Vector_datum);
extern Vektor vector_read
			(Vector_routine_hfh, Stdio, Heap, Vector_handle);
extern Vector_index vector_search_binary
		   (Vektor, Vector_datum, Vector_routine_tth, Vector_handle);
extern int vector_size
			(Vektor);
extern void vector_sort
			(Vektor, Vector_routine_tth, Vector_handle);
extern void vector_store
			(Vektor, Vector_index, Vector_datum);
extern void vector_trim
			(Vektor, Vector_size);
extern void vector_vector_append
			(Vektor, Vektor);
extern void vector_write
		       (Vektor, Vector_routine_thf, Stdio, Vector_handle);

#endif /* VECTOR_EXPORTS_H */