ctl -- C Template Library
  It contain some useful objects, functions, macros about some data
  structure. 

Compile:
  Type "make" and it will create "lib/libctl.a", "obj/$.o" where $
  means all the objects.
       By the way, you can type "make example" to compile a example
  file which name is "example.c",  and the results are "example", 
  which is an executive file. To run it, you will be shown a simple
  example about how to use the objects and functions in this project
  -- "C Template Library".

Target/goal:
  -utility:
     This object contain some useful functions,  constants and types.                                            
       Enums:                                              
         ErrorType    contain kinds of errors.             
                                                           
       Structures:                                         
                                                           
       Types:                                              
         uint         unsigned int                         
         pchar        char*                                
         ppchar       char**                               
         pvoid        void*                                
         ppvoid       void**                               
         cchar        const char                           
         pcchar       (const char)*                        
         ppcchar      (const char)**                       
         cvoid        const void                           
         pcvoid       (cosnt void)*                        
         ppcvoid      (const void)**                       
                                                           
      Type transform:                                      
        Char(), pChar(), ppChar()                          
        Void(), pVoid(), ppVoid()                          
        cChar(), pcChar(), ppcChar()                       
        cVoid(), pcVoid(), ppcVoid()                       
                                                           
      Functions:                                           
         ctl_malloc   like malloc(), but will exit on error
         ctl_realloc  like realloc(), but will exit on erro
         ctl_die      print some message and exit()        
         ctl_swap     swap two elements with given type    
                                                           

  -vector:
     This object is an array with dynamic table size.       
     methods:                                               
       init(addr of the vector, size per entry, size)       
          The vector's type depends on what user want to    
          store. For example: if you want an array for int, 
          you should  decleare like "int* v",  and call the 
          init() like this "init(&v,  sizeof(int), 5)", and 
          it will initalize an array with 5 elements.       
                                                            
       free(addr of the vector)                             
          Free the memory  the vector use. Yous should call 
          it when you don't need the container.             
                                                            
                                                            
       getSize(addr of the vector)                          
          Return the number of elements.                    
                                                            
       getEntrySize(addr of the vector)                     
          Return the size per entry, it dependent on what   
          type of data you store in the container.          
                                                            
       getEntry(addr of the vector, index)                  
          Return a const pointer which point to the entry   
          with the index you give.                          
                                                            
                                                            
       setSize(addr of the vector, new_size)                
          Resize the table to new_size. Note that it won't  
          initalize the newly element if you increase size. 
                                                            
       setEntry(addr of the vector, index, data)            
          Let the element with index you give be data.      
                                                            
                                                            
       addBack(addr of the vector, data)                    
          Add an element which contain data at the back of  
          the vector.                                       
                                                            
       delBack(addr of the vector)                          
          Remove the last element of the vector.            
                                                            
       addFront(addr of the vector, data)  !! UNFINISHED !! 
          Add an element which contain data at the front of 
          the vector.                                       
                                                            
       delFront(addr of the vector)        !! UNFINISHED !! 
          Remove the first element of the vector.           
                                                            
                                                            
       cat(addr of the v1, addr of the v2)                  
          Concatenate the vector2 to the back of vector1.   
                                                            
       copy(addr of the v1, addr of the v2)                 
          Let the contain in the v1 be the one in the v2    
                                                            
       replace(addr of the v1, a, b, addr of the v2, x, y)  
          If b == 0, it will insert v2[x ... x+y-1] into    
                                    the place between v[a]  
                                    and v[a-1]              
          If y >= 0, it will replace v1[a ... a+b-1]        
                                  to v2[x ... x+y-1]        
          If y <  0, it will replace v1[a ... a+b-1]        
                                  to v2[x-y-1 ... x] with   
                     reverse order.                         
                                                        
  -list:
     This object is a double link list.                     
     methods:                                               
       init(addr of the list, size per entry, list size)    
          The list's type depends on what user want to store
          . For example: if you want a list for int, you s- 
          hould declare like "int* v", and call the init()  
          like "init(&v, sizeof(int), 5)", which will creat 
          a double link list with 5 elements.               
                                                            
       free(addr of the list)                               
          Free the memory  the list use. You should call it 
          when you don't need the container.                
                                                            
                                                            
       getSize(addr of the list)                            
          Return the number of elements.                    
                                                            
       getEntrySize(addr of the list)                       
          Return the size per entry, it dependent on what   
          type of data you store in the container.          
                                                            
       getFront(addr of the list)                           
          Return a const pointer which point to the entry   
          at the head of the list.                          
                                                            
       getBack(addr of the list)                            
          Return a const pointer which point to the entry   
          at the end of the list.                           
                                                            
       getBegin(addr of the list)                           
          Return a pointer which point to the iterator at   
          the head of the list.                             
                                                            
       getEnd(addr of the list)                             
          Return a pointer which point to the iterator at   
          the end of the list (which cannot be modified).   
                                                            
                                                            
       setSize(addr of the list, new_size)                  
          Resize the lsit to new_size at the back of the    
          list. Note that it won't initalize the newly ele- 
          ments when you increase the size.                 
                                                            
       setFront(addr of the list, data)                     
          Let the first element be the data you given.      
                                                            
       setBack(addr of the list, data)                      
          Let the last element be the data you given.       
                                                            
                                                            
       addBack(addr of the list, data)                      
          Add an element which contain data at the back of  
          the list.                                         
                                                            
       delBack(addr of the list)                            
          Remove the last element of the list.              
                                                            
       addFront(addr of the vector, data)                   
          Add an element which contain data at the front of 
          the list.                                         
                                                            
       delFront(addr of the list)                           
          Remove the first element of the list.             
                                                            
                                                            
       rm(addr of the list, addr of the iter1, iter2)       
          Remove the part of iter1 ~ iter2 (include iter1   
          but not iter2)                                    
                                                            
       copy(addr of the list, addr of the iter1, iter2,     
            addr of the list2)                              
          Create a new list which contain the part of the   
          iter1 ~ iter2 (include iter1 but not iter2) and   
          saved it to list2.                                
                                                            
       move(addr of the list, addr of the iter1, iter2,     
            addr of the list2)                              
          Move the part iter1 ~ iter2 to list2.             
                                                            
       swap(addr of the l1, addr of the iter. i1, i2,       
            addr of the l2, addr of the iter. j1, j2)       
          Swap the part of l1 from i1 to i2.previous and    
          the part of l2 from j1 to j2.previous.            
                                                            
                                                            
       iterGetEntry(addr of the iteator)                    
          Return a const pointer which point to the data of 
          the iterator.                                     
                                                            
       iterGetNext(addr of the iterator)                    
          Return a pointer which point to the next iterator 
                                                            
       iterGetPrev(addr of the iterator)                    
          Return a pointer which point to the previous ite- 
          ator.                                             
                                                            
                                                            
       iterSetEntry(addr of the iterator, data)             
          Let the data which is stored in iterator be the   
          data you given.                                   
                                                            
       iterGoNext(addr of the iterator)                     
          Instead of return a pointer, it will change the   
          pointer you given.                                
                                                            
       iterGoPrev(addr of the iterator)                     
          Instead of return a pointer, it will change the   
          pointer you given.                                
                                                            
                                                            
       iterDel(addr of the iterator)                        
          Delete the iterator you given, returning a pointer
          to the next iterator                              
                                                            
       iterDelPrev(addr of the iterator)                    
          Delete the previous of the iterator you given.    
                                                            
       iterDelPrev(addr of the iterator)                    
          Delete the next of the iterator you given.        
                                                            
  -stack:
  -queue:
  -dequeue:
  -heap:
  -map:
  -hash:



                                                  --cathook, cat_leopard