JudySL - C library for creating and accessing a dynamic array, using a null-terminated string as an Index

       Judy was invented by Doug Baskins and implemented -Packard.

       A  JudySL  array  is  the  equivalent of a sorted set of strings, each associated with a Value (word).  A
       Value is addressed by an Index (key), which is a null-terminated character string of any length.   Memory
       to  support  the  array is allocated as index/value pairs are inserted, and released as index/value pairs
       are deleted.  This is a form of associative array, where array elements are also sorted lexicographically
       (case-sensitive) by indexes.  This could be thought of as

       void * JudySLArray["Toto, I don't think we're in Kansas any more"];

       A JudySL array is allocated with a NULL pointer

       Pvoid_t PJSLArray = (Pvoid_t) NULL;
       As with an ordinary array, there are no duplicate indexes (strings) in a JudySL array.

       Using the macros described here, rather than the JudySLfunctioncalls, the default error handling  sends
       a message to the standard error and terminates the program with exit(1).

       #include <stdio.h>
       #include <Judy.h>

       #define MAXLINE 1000000                 // max string (line) length

       uint8_t   Index[MAXLINE];               // string to insert

       int     // Usage:  JudySort < file_to_sort
       main()
       {
           Pvoid_t   PJArray = (PWord_t)NULL;  // Judy array.
           PWord_t   PValue;                   // Judy array element.
           Word_t    Bytes;                    // size of JudySL array.

           while (fgets(Index, MAXLINE, stdin) != (char *)NULL)
           {
               JSLI(PValue, PJArray, Index);   // store string into array
               if (PValue == PJERR)            // if out of memory?
               {                               // so do something
                   printf("Malloc failed -- get more ram\n");
                   exit(1);
               }
               ++(*PValue);                    // count instances of string
           }
           Index[0] = '\0';                    // start with smallest string.
           JSLF(PValue, PJArray, Index);       // get first string
           while (PValue != NULL)
           {
               while ((*PValue)--)             // print duplicates
                   printf("%s", Index);
               JSLN(PValue, PJArray, Index);   // get next string
           }
           JSLFA(Bytes, PJArray);              // free array

           fprintf(stderr, "The JudySL array used %lu bytes of memory\n", Bytes);
           return (0);
       }

       Delete the specified Index/Value pair (array element) from the JudySL array.

       Return Rc_int set to 1 if successful.  array and it was previously inserted.  Return Rc_int set to  0  if
       Index was not present.

       Search  (inclusive) for the first index present that is equal to or greater than the passed Index string.
       (Start with a null string to find the first index in the array.)  JSLF() is typically  used  to  begin  a
       sorted-order scan of the valid indexes in a JudySL array.

       uint8_t Index[MAXLINELEN];
       strcpy (Index, "");
       JSLF(PValue, PJSLArray, Index);

       Given  a  pointer  to a JudySL array (PJSLArray), free the entire array (much faster than using a JSLN(),
       JSLD() loop.)

       Return Rc_word set to the number of bytes freed and PJSLArray set to NULL.

       Get the pointer to Index's Value.

       Return PValue pointing to Index's Value.  Return PValue set to NULL if the Index was not present.

       Insert  an  Index string and Value in the JudySL array PJSLArray.  If the Index is successfully inserted,
       the Value is initialized to 0. If the Index was already present, the Value is not modified.

       Return PValue pointing to Index's Value.  Your program must use this pointer to  modify  the  Value,  for
       example:

       *PValue = 1234;

       Note:  JSLI()  and  JSLD  reorganize the JudySL array.  Therefore, pointers returned from previous JudySL
       calls become invalid and must be reacquired.

       Search  (inclusive)  for  the  last  index present that is equal to or less than the passed Index string.
       (Start with a maximum-valued string to look up the last index in the array, such as a  max-length  string
       of  0xff bytes.)  JSLL() is typically used to begin a reverse-sorted-order scan of the valid indexes in a
       JudySL array.

       Search  (exclusive)  for  the next index present that is greater than the passed Index string.  JSLN() is
       typically used to continue a sorted-order scan of the valid indexes in a JudySL array,  or  to  locate  a
       "neighbor" of a given index.

       Search (exclusive) for the previous index present that is less than the passed Index string.   JSLP()  is
       typically  used  to  continue  a  reverse-sorted-order scan of the valid indexes in a JudySL array, or to
       locate a "neighbor" of a given index.

ERRORS:See:Judy_3.htm#ERRORS

       The JudySL search functions allow you to search for indexes in the array.  You may search inclusively  or
       exclusively, in either forward or reverse directions.

       If  successful,  Index  is  returned  set  to the found index, and PValue is returned set to a pointer to
       Index's Value.  If  unsuccessful,  PValue  is  returned  set  to  NULL,  and  Index  contains  no  useful
       information.   PValue  must  be  tested  for  non-NULL  prior  to  using Index, since a search failure is
       possible.

       Note: To accomodate all possible returns, the Index buffer must be at  least  as  large  as  the  largest
       string stored in the array.

       JudySL - C library for creating and accessing a dynamic array, using a null-terminated string as an Index
       (associative array)

Judy(3), Judy1(3), JudyL(3), JudyHS(3),
       malloc(),
       the Judy website, http://judy.sourceforge.net, for further information and Application Notes.

                                                                                                       JudySL(3)

cc[flags]sourcefiles-lJudy#include<Judy.h>#defineMAXLINELEN1000000//definemaximumstringlengthWord_t*PValue;//JudySLarrayelementuint8_tIndex[MAXLINELEN];//stringintRc_int;//returnvalueWord_tRc_word;//fullwordreturnvaluePvoid_tPJSLArray=(Pvoid_t)NULL;//initializeJudySLarrayJSLI(PValue,PJSLArray,Index);//JudySLIns()JSLD(Rc_int,PJSLArray,Index);//JudySLDel()JSLG(PValue,PJSLArray,Index);//JudySLGet()JSLFA(Rc_word,PJSLArray);//JudySLFreeArray()JSLF(PValue,PJSLArray,Index);//JudySLFirst()JSLN(PValue,PJSLArray,Index);//JudySLNext()JSLL(PValue,PJSLArray,Index);//JudySLLast()JSLP(PValue,PJSLArray,Index);//JudySLPrev()