Judy1PrevEmpty man page on HP-UX

Printed from http://www.polarhome.com/service/man/?qf=Judy1PrevEmpty&af=0&tf=2&of=HP-UX

Judy1_funcs(3X)						       Judy1_funcs(3X)

       Judy1  functions - C library for creating and accessing a dynamic array
       of bits, using any value of a word as an index

       int    Judy1Set(	      PPvoid_t PPJ1Array, Word_t   Index,  PJError_t PJError);
       int    Judy1Unset(     PPvoid_t PPJ1Array, Word_t   Index,  PJError_t PJError);
       int    Judy1Test(      Pcvoid_t	PJ1Array, Word_t   Index,  PJError_t PJError);
       Word_t Judy1Count(     Pcvoid_t	PJ1Array, Word_t   Index1, Word_t    Index2, PJError_t PJError);
       int    Judy1ByCount(   Pcvoid_t	PJ1Array, Word_t   Nth,	   Word_t * PIndex,  PJError_t PJError);
       Word_t Judy1FreeArray( PPvoid_t PPJ1Array, PJError_t PJError);
       Word_t Judy1MemUsed(   Pcvoid_t	PJ1Array);
       int    Judy1First(     Pcvoid_t	PJ1Array, Word_t * PIndex, PJError_t PJError);
       int    Judy1Next(      Pcvoid_t	PJ1Array, Word_t * PIndex, PJError_t PJError);
       int    Judy1Last(      Pcvoid_t	PJ1Array, Word_t * PIndex, PJError_t PJError);
       int    Judy1Prev(      Pcvoid_t	PJ1Array, Word_t * PIndex, PJError_t PJError);
       int    Judy1FirstEmpty(Pcvoid_t	PJ1Array, Word_t * PIndex, PJError_t PJError);
       int    Judy1NextEmpty( Pcvoid_t	PJ1Array, Word_t * PIndex, PJError_t PJError);
       int    Judy1LastEmpty( Pcvoid_t	PJ1Array, Word_t * PIndex, PJError_t PJError);
       int    Judy1PrevEmpty( Pcvoid_t	PJ1Array, Word_t * PIndex, PJError_t PJError);

       A macro equivalent exists for each function call.   Because  the	 macro
       forms  are  faster and have a simpler error handling interface than the
       equivalent functions, they are the preferred way of calling  the	 Judy1
       functions.  See Judy1(3X) for more information.	The function call def‐
       initions are included here for completeness.

       One of the difficulties in using	 the  Judy1  function  calls  lies  in
       determining  whether  to	 pass  a  pointer or the address of a pointer.
       Since the functions that modify the Judy1 array must  also  modify  the
       pointer	to  the	 Judy1 array, you must pass the address of the pointer
       rather than the pointer itself.	This often leads to hard-to-debug pro‐
       grammatic  errors.  In practice, the macros allow the compiler to catch
       programming errors when pointers instead of addresses of	 pointers  are

       The  Judy1  function  calls  have  an additional parameter beyond those
       specified in the macro calls.  This parameter is either a pointer to an
       error  structure, or NULL (in which case the detailed error information
       is not returned).

       In the following descriptions, the functions are described in terms  of
       how  the	 macros use them (only in the case of #define JUDYERROR_NOTEST
       1).  This is the suggested use of the macros  after  your  program  has
       been fully debugged.  When the JUDYERROR_NOTEST macro is not specified,
       an error structure is declared to store error information returned from
       the Judy1 functions when an error occurs.

       Notice the placement of the & in the different functions.

			     #define J1S(Rc_int, PJ1Array, Index) \
			 Rc_int = Judy1Set(&PJ1Array, Index, PJE0)

			     #define J1U(Rc_int, PJ1Array, Index) \
			 Rc_int = Judy1Unset(&PJ1Array, Index, PJE0)

			     #define J1T(Rc_int, PJ1Array, Index) \
			 Rc_int = Judy1Test(PJ1Array, Index, PJE0)

			     #define J1C(Rc_word, PJ1Array, Index1, Index2) \
			 Rc_word = Judy1Count(PJ1Array, Index1, Index2, PJE0)

		      A	 return	 value of 0 can be an error, valid as a count,
		      or it can indicate a special case for a  fully-populated
		      array (32-bit machines only).  If necessary, the follow‐
		      ing code can be used to disambiguate this return:

		      JError_t JError;

		      Rc_word = Judy1Count(PJ1Array, Index1, Index2, &JError);
		      if (Rc_word == 0)
			  if (JU_ERRNO(&JError) == JU_ERRNO_NONE)
			      printf("Judy1 array population == 0\n");
			  if (JU_ERRNO(&JError) == JU_ERRNO_FULL)
			      printf("Judy1 array population == 2^32\n");
			      goto NullArray;
			  if (JU_ERRNO(&JError) >  JU_ERRNO_NFMAX)
			      goto Null_or_CorruptArray;

			     #define J1BC(Rc_int, PJ1Array, Nth, Index) \
			 Rc_int = Judy1ByCount(PJ1Array, Nth, &Index, PJE0)

			     #define J1FA(Rc_word, PJ1Array) \
			 Rc_word = Judy1FreeArray(&PJ1Array, PJE0)

			     #define J1MU(Rc_word, PJ1Array) \
			 Rc_word = Judy1MemUsed(PJ1Array)

			     #define J1F(Rc_int, PJ1Array, Index) \
			 Rc_int = Judy1First(PJ1Array, &Index, PJE0)

			     #define J1N(Rc_int, PJ1Array, Index) \
			 Rc_int = Judy1Next(PJ1Array, &Index, PJE0)

			     #define J1L(Rc_int, PJ1Array, Index) \
			 Rc_int = Judy1Last(PJ1Array, &Index, PJE0)

			     #define J1P(Rc_int, PJ1Array, Index) \
			 Rc_int = Judy1Prev(PJ1Array, &Index, PJE0)

			     #define J1FE(Rc_int, PJ1Array, Index) \
			 Rc_int = Judy1FirstEmpty(PJ1Array, &Index, PJE0)

			     #define J1NE(Rc_int, PJ1Array, Index) \
			 Rc_int = Judy1NextEmpty(PJ1Array, &Index, PJE0)

			     #define J1LE(Rc_int, PJ1Array, Index) \
			 Rc_int = Judy1LastEmpty(PJ1Array, &Index, PJE0)

			     #define J1PE(Rc_int, PJ1Array, Index) \
			 Rc_int = Judy1PrevEmpty(PJ1Array, &Index, PJE0)

       Definitions for all of the Judy functions, the types Pvoid_t, Pcvoid_t,
       PPvoid_t,   Word_t,   JError_t,	and  PJError_t,	 the  constants	 NULL,
       JU_ERRNO_*, JERR, and PJE0, are provided	 in  the  Judy.h  header  file
       (/usr/include/Judy.h).	Note:	Callers	 should define Judy1 arrays as
       type Pvoid_t, which can be passed  by  value  to	 functions  that  take
       Pcvoid_t (constant Pvoid_t), and also by address to functions that take

       Judy was invented and implemented by Hewlett-Packard.

       Judy(3X),   Judy1(3X),	 JudyL(3X),    JudyL_funcs(3X),	   JudySL(3X),
       the  Judy website, http://www.hp.com/go/judy/, for more information and
       Application Notes.


List of man pages available for HP-UX

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net