[TagList]
ActiveGroup=XML

[Group List]         
0=Apache             
1=Array              
2=Aspell             
3=Arbit.Prec. Math   
4=Calendar 
5=Compression  
6=ClibPDF      
7=Date&Time          
8=Directory&File
9=FDF    
10=Encryption        
11=Hash 
12=HTTP  
13=HyperWave            
14=Icap              
15=Image             
16=IMAP              
17=LDAP              
18=Math              
19=Mail & Miscel.  
20=MySQL  
21=Network           
22=NIS 
23=ODBC
24=Oracle 8
25=PDF              
26=Perl RegEx   
27=PHP Options&Info  
28=Progrm.Exec       
29=Reg. Expressions  
30=Semaphore         
31=Session           
32=SNMP              
33=String            
34=URL               
35=Variable          
36=Vmailmgr          
36=WDDX              
37=XML 



[Tag Group - Apache]
0="apache_lookup_uri (); :UEDS:class apache_lookup_uri(string filename);"
1="apache_note (); :UEDS:string apache_note(string note_name, string [note_value]);"
2="getallheaders (); :UEDS:array getallheaders(void);"
3="virtual (); :UEDS:int virtual(string filename);"   

[Tag Group - Array] 
0="array_push (); :UEDS:int array_push(array array, mixed var, [...]);"             
1="array_pop (); :UEDS:mixed array_pop(array array);"                               
2="array_unshift (); :UEDS:int array_unshift(array array, mixed var, [...]);"       
3="array_shift (); :UEDS:mixed array_shift(array array);"                           
4="array_slice (); :UEDS:array array_slice(array array, int offset, int [length] );" 
5="array_splice (); :UEDS:array array_splice(array input, int offset, int [length] , array [replacement]);"
6="array_merge (); :UEDS:array array_merge(array array1, array array2, [ ...] );"     
7="array_keys (); :UEDS:array array_keys(array input);"                               
8="array_values (); :UEDS:array array_values(array input);"                           
9="array_walk (); :UEDS:int array_walk(array arr, string func, mixed userdata);"
10="sort(array array);:UEDS: sort(array array);"                                      
11="asort (); :UEDS:void asort(array array);"                                         
12="compact (); :UEDS:array compact(string varname | array varnames, [...]);"         
13="count (); :UEDS:int count(mixed var);"                                            
14="current (); :UEDS:mixed current(array array);"   
15="each (); :UEDS:array each(array array);"         
16="end (); :UEDS:end(array array);"                 
17="extract (); :UEDS:void extract(array var_array, int [extract_type], string [prefix]);"
18="in_array (); :UEDS:bool in_array(mixed needle, array haystack);"   
19="key (); :UEDS:mixed key(array array);"     
20="ksort (); :UEDS:int ksort(array array);"    
21="list (); :UEDS:void list(...);"   
22="next (); :UEDS:mixed next(array array);"    
23="pos (); :UEDS:mixed pos(array array);"      
24="prev (); :UEDS:mixed prev(array array);"    
25="range (); :UEDS:array range(int low, int high);"   
26="reset (); :UEDS:mixed reset(array array);"         
27="rsort (); :UEDS:void rsort(array array);"          
28="shuffle (); :UEDS:void shuffle(array array);"      
29="sizeof (); :UEDS:int sizeof(array array);"         
30="sort (); :UEDS:void sort(array array);"            
31="uasort (); :UEDS:void uasort(array array, function cmp_function);"  
32="uksort (); :UEDS:void uksort(array array, function cmp_function);"   
33="usort (); :UEDS:void usort(array array, function cmp_function);"     

[Tag Group - Aspell]        
0="aspell_new (); :UEDS:int aspell_new(string master, string personal);" 
1="aspell_check (); :UEDS:boolean aspell_check(int dictionary_link, string word);"    
2="aspell_check-raw (); :UEDS:boolean aspell_check_raw(int dictionary_link, string word);"  
3="aspell_suggest (); :UEDS:array aspell_suggest(int dictionary_link, string word);"  

[Tag Group - Arbit.Prec. Math]
0="bcadd (); :UEDS:string bcadd(string left operand, string right operand, int [scale]);" 
1="bccomp (); :UEDS:int bccomp(string left operand, string right operand, int [scale]);"  
2="bcdiv (); :UEDS:string bcdiv(string left operand, string right operand, int [scale]);" 
3="bcmod (); :UEDS:string bcmod(string left operand, string modulus);"  
4="bcmul (); :UEDS:string bcmul(string left operand, string right operand, int [scale]);" 
5="bcpow (); :UEDS:string bcpow(string x, string y, int [scale]);"
6="bcscale (); :UEDS:string bcscale(int scale);"
7="bcsqrt (); :UEDS:string bcsqrt(string operand, int scale);"    
8="bcsub (); :UEDS:string bcsub(string left operand, string right operand, int [scale]);"       

[Tag Group - Calendar]
0="JDToGregorian (); :UEDS:string jdtogregorian(int julianday);"  
1="GregorianToJD (); :UEDS:int gregoriantojd(int month, int day, int year);"   
2="JDToJulian (); :UEDS:string jdtojulian(int julianday);"        
3="JulianToJD (); :UEDS:int juliantojd(int month, int day, int year);"         
4="JDToJewish (); :UEDS:string jdtojewish(int julianday);"        
5="JewishToJD (); :UEDS:int jewishtojd(int month, int day, int year);"         
6="JDToFrench (); :UEDS:string jdtofrench(int month, int day, int year);"      
7="FrenchToJD (); :UEDS:int frenchtojd(int month, int day, int year);"         
8="JDMonthName (); :UEDS:string jdmonthname(int julianday, int mode);"         
9="JDDayOfWeek (); :UEDS:mixed jddayofweek(int julianday, int mode);"          
10="easter_date (); :UEDS:int easter_date(int year);"       
11="easter_days (); :UEDS:int easter_days(int year);"       


[Tag Group - Compression]
0="gzclose (); :UEDS:int gzclose(int zp);"
1="gzeof (); :UEDS:int gzeof(int zp);"    
2="gzfile (); :UEDS:array gzfile(string filename);"    
3="gzgetc (); :UEDS:string gzgetc(int zp);"            
4="gzgets (); :UEDS:string gzgets(int zp, int length);"
5="gzgetss (); :UEDS:string gzgetss(int zp, int length);"   
6="gzopen (); :UEDS:int gzopen(string filename, string mode);"           
7="gzopen (); :UEDS:int gzopen(string filename, string mode);"
8="gzpassthru (); :UEDS:int gzpassthru(int zp);"       
9="gzputs (); :UEDS:int gzputs(int zp, string str, int [length]);"       
10="gzread (); :UEDS:string gzread(int zp, int length);"    
11="gzrewind (); :UEDS:int gzrewind(int zp);"          
12="gzseek (); :UEDS:int gzseek(int zp, int offset);"  
13="gztell (); :UEDS:int gztell(int zp);" 
14="readgzfile (); :UEDS:int readgzfile(string filename);"  
15="gzwrite();:UEDS:intgzwrite(intzp,stringstring,int[length]);" 

[Tag Group - ClibPDF]
0="cpdf_set_creator (); :UEDS:void cpdf_set_creator(string creator);"
1="cpdf_set_title (); :UEDS:void cpdf_set_title(string title);"
2="cpdf_set_subject (); :UEDS:void cpdf_set_subject(string subject);"
3="cpdf_set_keywords (); :UEDS:void cpdf_set_keywords(string keywords);"
4="cpdf_open (); :UEDS:int cpdf_open(int compression, string filename);"
5="cpdf_close (); :UEDS:void cpdf_close(int pdf document);"
6="cpdf_page_init (); :UEDS:void cpdf_page_init(int pdf document, int page number, int orientation, double height, double width, double unit);"
7="cpdf_finalize_page (); :UEDS:void cpdf_finalize_page(int pdf document, int page number);"
8="cpdf_finalize (); :UEDS:void cpdf_finalize(int pdf document);"
9="cpdf_output_buffer (); :UEDS:void cpdf_output_buffer(int pdf document);"
10="cpdf_save_to_file (); :UEDS:void cpdf_save_to_file(int pdf document, string filename);"
11="cpdf_set_current_page (); :UEDS:void cpdf_set_current_page(int pdf document, int page number);"
12="cpdf_begin_text (); :UEDS:void cpdf_begin_text(int pdf document);"
13="cpdf_end_text (); :UEDS:void cpdf_end_text(int pdf document);"
14="cpdf_show (); :UEDS:void cpdf_show(int pdf document, string text);"
15="cpdf_show_xy (); :UEDS:void cpdf_show_xy(int pdf document, string text, double x-koor, double y-koor, int mode);"
16="cpdf_text (); :UEDS:void cpdf_text(int pdf document, string text, double x-koor, double y-koor, int mode, double orientation, int alignmode);"
17="cpdf_set_font (); :UEDS:void cpdf_set_font(int pdf document, string font name, double size, int encoding);"
18="cpdf_set_leading (); :UEDS:void cpdf_set leading(int pdf document, double distance);"
19="cpdf_set_text_rendering (); :UEDS:void cpdf_set_text_rendering(int pdf document, int mode);"
20="cpdf_set_horiz_scaling (); :UEDS:void cpdf_set_horiz_scaling(int pdf document, double scale);"
21="cpdf_set_text_rise (); :UEDS:void cpdf_set_text_rise(int pdf document, double value);"
22="cpdf_set_text_matrix (); :UEDS:void cpdf_set_text_matrix(int pdf document, array matrix);"
23="cpdf_set_text_pos (); :UEDS:void cpdf_set_text_pos(int pdf document, double x-koor, double y-koor, int mode);"
24="cpdf_set_char_spacing (); :UEDS:void cpdf_set_char_spacing(int pdf document, double space);"
25="cpdf_set_word_spacing (); :UEDS:void cpdf_set_word_spacing(int pdf document, double space);"
26="cpdf_continue_text (); :UEDS:void cpdf_continue_text(int pdf document, string text);"
27="cpdf_stringwidth (); :UEDS:double cpdf_stringwidth(int pdf document, string text);"
28="cpdf_save (); :UEDS:void cpdf_save(int pdf document);"
29="cpdf_restore (); :UEDS:void cpdf_restore(int pdf document);"
30="cpdf_translate (); :UEDS:void cpdf_translate(int pdf document, double x-koor, double y-koor, int mode);"
31="cpdf_scale (); :UEDS:void cpdf_scale(int pdf document, double x-scale, double y-scale);"
32="cpdf_rotate (); :UEDS:void cpdf_rotate(int pdf document, double angle);"
33="cpdf_setflat (); :UEDS:void cpdf_setflat(int pdf document, double value);"
34="cpdf_setlinejoin (); :UEDS:void cpdf_setlinejoin(int pdf document, long value);"
35="cpdf_setlinecap (); :UEDS:void cpdf_setlinecap(int pdf document, int value);"
36="cpdf_setmiterlimit (); :UEDS:void cpdf_setmiterlimit(int pdf document, double value);"
37="cpdf_setlinewidth (); :UEDS:void cpdf_setlinewidth(int pdf document, double width);"
38="cpdf_setdash (); :UEDS:void cpdf_setdash(int pdf document, double white, double black);"
39="cpdf_moveto (); :UEDS:void cpdf_moveto(int pdf document, double x-koor, double y-koor, int mode);"
40="cpdf_rmoveto (); :UEDS:void cpdf_rmoveto(int pdf document, double x-koor, double y-koor, int mode);"
41="cpdf_curveto (); :UEDS:void cpdf_curveto(int pdf document, double x1, double y1, double x2, double y2, double x3, double y3, int mode);"
42="cpdf_lineto (); :UEDS:void cpdf_lineto(int pdf document, double x-koor, double y-koor, int mode);"
43="cpdf_rlineto (); :UEDS:void cpdf_rlineto(int pdf document, double x-koor, double y-koor, int mode);"
44="cpdf_circle (); :UEDS:void cpdf_circle(int pdf document, double x-koor, double y-koor, double radius, int mode);"
45="cpdf_arc (); :UEDS:void cpdf_arc(int pdf document, double x-koor, double y-koor, double radius, double start, double end, int mode);"
46="cpdf_rect (); :UEDS:void cpdf_rect(int pdf document, double x-koor, double y-koor, double width, double height, int mode);"
47="cpdf_closepath (); :UEDS:void cpdf_closepath(int pdf document);"
48="cpdf_stroke (); :UEDS:void cpdf_stroke(int pdf document);"
49="cpdf_closepath_stroke (); :UEDS:void cpdf_closepath_stroke(int pdf document);"
50="cpdf_fill (); :UEDS:void cpdf_fill(int pdf document);"
51="cpdf_fill_stroke (); :UEDS:void cpdf_fill_stroke(int pdf document);"
52="cpdf_closepath_fill_stroke (); :UEDS:void cpdf_closepath_fill_stroke(int pdf document);"
53="cpdf_clip (); :UEDS:void cpdf_clip(int pdf document);"
54="cpdf_setgray_fill (); :UEDS:void cpdf_setgray_fill(int pdf document, double value);"
55="cpdf_setgray_stroke (); :UEDS:void cpdf_setgray_stroke(int pdf document, double gray value);"
56="cpdf_setgray (); :UEDS:void cpdf_setgray(int pdf document, double gray value);"
57="cpdf_setrgbcolor_fill (); :UEDS:void cpdf_setrgbcolor_fill(int pdf document, double red value, double green value, double blue value);"
58="cpdf_setrgbcolor_stroke (); :UEDS:void cpdf_setrgbcolor_stroke(int pdf document, double red value, double green value, double blue value);"
59="cpdf_setrgbcolor (); :UEDS:void cpdf_setrgbcolor(int pdf document, double red value, double green value, double blue value);"
60="cpdf_add_outline (); :UEDS:void cpdf_add_outline(int pdf document, string text);"
61="cpdf_set_page_animation (); :UEDS:void cpdf_set_page_animation(int pdf document, int transition, double duration);"
62="cpdf_import_jpeg (); :UEDS:int cpdf_open_jpeg(int pdf document, string file name, double x-koor, double y-koor, double angle, double width, double height, double x-scale, double y-scale, int mode);"
63="cpdf_place_inline_image (); :UEDS:void cpdf_place_inline_image(int pdf document, int image, double x-koor, double y-koor, double angle, double width, double height, int mode);"
64="cpdf_add_annotation (); :UEDS:void cpdf_add_annotation(int pdf document, double llx, double lly, double urx, double ury, string title, string content, int mode);"

[Tag Group - Date&Time]
0="checkdate (); :UEDS:int checkdate(int month, int day, int year);"     
1="date (); :UEDS:string date(string format, int [timestamp] );"  
2="strftime (); :UEDS:string strftime(string format, int timestamp);"       
3="gmstrftime (); :UEDS:string gmstrftime(string format, int timestamp);"   
4="getdate (); :UEDS:array getdate(int timestamp);"     
5="gettimeofday (); :UEDS:array gettimeofday(void);"    
6="gmdate (); :UEDS:string gmdate(string format, int timestamp);" 
7="mktime (); :UEDS:int mktime(int hour, int minute, int second, int month, int day, int year, int [is_dst]);" 
8="gmmktime (); :UEDS:int gmmktime(int hour, int minute, int second, int month, int day, int year, int [is_dst]);"       
9="time (); :UEDS:int time(void);"  
10="microtime (); :UEDS:string microtime(void);"   


[Tag Group - Directory&File]
0="chdir (); :UEDS:int chdir(string directory);"
1="dir (); :UEDS:new dir(string directory);"
2="closedir (); :UEDS:void closedir(int dir_handle);"
3="opendir (); :UEDS:int opendir(string path);"
4="readdir (); :UEDS:string readdir(int dir_handle);"
5="rewinddir (); :UEDS:void rewinddir(int dir_handle);"
6="basename (); :UEDS:string basename(string path);"   
7="chgrp (); :UEDS:int chgrp(string filename, mixed group);"     
8="chmod (); :UEDS:int chmod(string filename, int mode);"        
9="chown (); :UEDS:int chown(string filename, mixed user);"      
10="clearstatcache (); :UEDS:void clearstatcache(void);"
11="copy (); :UEDS:int copy(string source, string dest);"         
12="delete (); :UEDS:void delete(string file);"         
13="dirname (); :UEDS:string dirname(string path);"     
14="diskfreespace (); :UEDS:float diskfreespace(string directory);"         
15="fclose (); :UEDS:int fclose(int fp);"     
16="feof (); :UEDS:int feof(int fp);"         
17="fgetc (); :UEDS:string fgetc(int fp);"    
18="fgetcsv (); :UEDS:array fgetcsv(int fp, int length, string [delimiter]);"         
19="fgets (); :UEDS:string fgets(int fp, int length);"  
20="fgetss (); :UEDS:string fgetss(int fp, int length);"
21="file (); :UEDS:array file(string filename);"        
22="file_exists (); :UEDS:int file_exists(string filename);"      
23="fileatime (); :UEDS:int fileatime(string filename);"
24="filectime (); :UEDS:int filectime(string filename);"
25="filegroup (); :UEDS:int filegroup(string filename);"
26="fileinode (); :UEDS:int fileinode(string filename);"    
27="filemtime (); :UEDS:int filemtime(string filename);"
28="fileowner (); :UEDS:int fileowner(string filename);"
29="fileperms (); :UEDS:int fileperms(string filename);"
30="filesize (); :UEDS:int filesize(string filename);"  
31="filetype (); :UEDS:string filetype(string filename);"         
32="flock (); :UEDS:bool flock(int fp, int operation);" 
33="fopen (); :UEDS:int fopen(string filename, string mode);"     
34="fpassthru (); :UEDS:int fpassthru(int fp);"         
35="fputs (); :UEDS:int fputs(int fp, string str, int [length]);" 
36="fread (); :UEDS:string fread(int fp, int length);"  
37="fseek (); :UEDS:int fseek(int fp, int offset);"     
38="ftell (); :UEDS:int ftell(int fp);"       
39="fwrite (); :UEDS:int fwrite(int fp, string string, int [length]);"      
40="set_file_buffer (); :UEDS:int fwrite(int fp, int buffer);"    
41="is_dir (); :UEDS:bool is_dir(string filename);"     
42="is_executable (); :UEDS:bool is_executable(string filename);" 
43="is_file (); :UEDS:bool is_file(string filename);"   
44="is_link (); :UEDS:bool is_link(string filename);"   
45="is_readable (); :UEDS:bool is_readable(string filename);"     
46="is_writeable (); :UEDS:bool is_writeable(string filename);"   
47="link (); :UEDS:int link(string target, string link);"         
48="linkinfo (); :UEDS:int linkinfo(string path);"      
49="mkdir (); :UEDS:int mkdir(string pathname, int mode);"        
50="pclose (); :UEDS:int pclose(int fp);"     
51="popen (); :UEDS:int popen(string command, string mode);"      
52="readfile (); :UEDS:int readfile(string filename);"       
53="readlink (); :UEDS:string readlink(string path);"        
54="rename (); :UEDS:int rename(string oldname, string newname);"      
55="rewind (); :UEDS:int rewind(int fp);"
56="rmdir (); :UEDS:int rmdir(string dirname);"    
57="stat (); :UEDS:array stat(string filename);"   
58="lstat (); :UEDS:array lstat(string filename);" 
59="symlink (); :UEDS:int symlink(string target, string link);"        
60="tempnam (); :UEDS:string tempnam(string dir, string prefix);"      
61="touch (); :UEDS:int touch(string filename, int time);"   
62="umask (); :UEDS:int umask(int mask);"   
63="unlink (); :UEDS:int unlink(string filename);"     

[Tag Group - FDF]  
0="fdf_open (); :UEDS:int fdf_open(string filename);"
1="fdf_close (); :UEDS:void fdf_close(int fdf_document);"
2="fdf_create (); :UEDS:int fdf_create(void );"
3="fdf_save (); :UEDS:int fdf_save(string filename);"
4="fdf_get_value (); :UEDS:string fdf_get_value(int fdf_document, string fieldname);"
5="fdf_set_value (); :UEDS:void fdf_set_value(int fdf_document, string fieldname, string value, int isName);"
6="fdf_next_field_name (); :UEDS:string fdf_next_field_name(int fdf_document, string fieldname);"
7="fdf_set_ap (); :UEDS:void fdf_set_ap(int fdf_document, string field_name, int face, string filename, int page_number);"
8="fdf_set_status (); :UEDS:void fdf_set_status(int fdf_document, string status);"
9="fdf_get_status (); :UEDS:string fdf_get_status(int fdf_document);"
10="fdf_set_file (); :UEDS:void fdf_set_file(int fdf_document, string filename);"
11="fdf_get_file (); :UEDS:string fdf_get_file(int fdf_document);"

[Tag Group - Encryption]    
0="mcrypt_get_cipher_name (); :UEDS:string mcrypt_get_cipher_name(int cipher);"         
1="mcrypt_get_block_size (); :UEDS:int mcrypt_get_block_size(int cipher);"        
2="mcrypt_get_key_size (); :UEDS:int mcrypt_get_key_size(int cipher);"  
3="mcrypt_create_iv (); :UEDS:string mcrypt_create_iv(int size, int source);"     
4="mcrypt_cbc (); :UEDS:int mcrypt_cbc(int cipher, string key, string data, int mode, string [iv]);"  
5="mcrypt_cfb (); :UEDS:int mcrypt_cfb(int cipher, string key, string data, int mode, string iv);"    
6="mcrypt_ecb (); :UEDS:int mcrypt_ecb(int cipher, string key, string data, int mode);"     
7="mcrypt_ofb (); :UEDS:int mcrypt_ofb(int cipher, string key, string data, int mode, string iv);"    


[Tag Group - Hash]       
0="mhash_get_hash_name (); :UEDS:string mhash_get_hash_name(int hash);"    
1="mhash_get_block_size (); :UEDS:int mhash_get_block_size(int hash);"     
2="mhash_count (); :UEDS:int mhash_count(void );"      
3="mhash (); :UEDS:string mhash(int hash, string data);"         

[Tag Group - HTTP]
0="header (); :UEDS:int header(string string);"
1="setcookie (); :UEDS:int setcookie(string name, string value, int expire, string path, string domain, int secure);"

[Tag Group - HyperWave]
0="hw_Children (); :UEDS:array hw_children(int connection, int objectID);"  
1="hw_ChildrenObj (); :UEDS:array hw_childrenobj(int connection, int objectID);"      
2="hw_Close (); :UEDS:int hw_close(int connection);"   
3="hw_Connect (); :UEDS:int hw_connect(string host, int port, string username, string password);"         
4="hw_Cp (); :UEDS:int hw_cp(int connection, array object_id_array, int destination id);"       
5="hw_Deleteobject (); :UEDS:int hw_deleteobject(int connection, int object_to_delete);"        
6="hw_DocByAnchor (); :UEDS:int hw_docbyanchor(int connection, int anchorID);"        
7="hw_DocByAnchorObj (); :UEDS:string hw_docbyanchorobj(int connection, int anchorID);"         
8="hw_DocumentAttributes (); :UEDS:string hw_documentattributes(int hw_document);"    
9="hw_DocumentBodyTag (); :UEDS:string hw_documentbodytag(int hw_document);"
10="hw_DocumentContent (); :UEDS:string hw_documentcontent(int hw_document);"
11="hw_DocumentSetContent (); :UEDS:string hw_documentsetcontent(int hw_document, string content);"        
12="hw_DocumentSize (); :UEDS:int hw_documentsize(int hw_document);"         
13="hw_ErrorMsg (); :UEDS:string hw_errormsg(int connection);"     
14="hw_EditText (); :UEDS:int hw_edittext(int connection, int hw_document);" 
15="hw_Error (); :UEDS:int hw_error(int connection);"    
16="hw_Free_Document (); :UEDS:int hw_free_document(int hw_document);"       
17="hw_GetParents (); :UEDS:array hw_getparentsobj(int connection, int objectID);" 
18="hw_GetParentsObj (); :UEDS:array hw_getparentsobj(int connection, int objectID);" 
19="hw_GetChildColl (); :UEDS:array hw_getchildcoll(int connection, int objectID);"  
20="hw_GetChildCollObj (); :UEDS:array hw_getchildcollobj(int connection, int objectID);"
21="hw_GetRemote (); :UEDS:int hw_getremote(int connection, int objectID);"           
22="hw_GetRemoteChildren (); :UEDS:int hw_getremotechildren(int connection, string object record);"        
23="hw_GetSrcByDestObj (); :UEDS:array hw_getsrcbydestobj(int connection, int objectID);"
24="hw_GetObject (); :UEDS:array hw_getobject(int connection, [int|array] objectID, string query);"
25="hw_GetAndLock (); :UEDS:string hw_getandlock(int connection, int objectID);"      
26="hw_GetText (); :UEDS:int hw_gettext(int connection, int objectID, mixed [rootID/prefix] );"
27="hw_GetObjectByQuery (); :UEDS:array hw_getobjectbyquery(int connection, string query, int max_hits);"  
28="hw_GetObjectByQueryObj (); :UEDS:array hw_getobjectbyqueryobj(int connection, string query, int max_hits);"          
29="hw_GetObjectByQueryColl (); :UEDS:array hw_getobjectbyquerycoll(int connection, int objectID, string query, int max_hits);"           
30="hw_GetObjectByQueryCollObj (); :UEDS:array hw_getobjectbyquerycollobj(int connection, int objectID, string query, int max_hits);"
31="hw_GetChildDocColl (); :UEDS:array hw_getchilddoccoll(int connection, int objectID);" 
32="hw_GetChildDocCollObj (); :UEDS:array hw_getchilddoccollobj(int connection, int objectID);" 
33="hw_GetAnchors (); :UEDS:array hw_getanchors(int connection, int objectID);"       
34="hw_GetAnchorsObj (); :UEDS:array hw_getanchorsobj(int connection, int objectID);" 
35="hw_Mv (); :UEDS:int hw_mv(int connection, array object id array, int source id, int destination id);"
36="hw_Identify (); :UEDS:int hw_identify(string username, string password);"         
37="hw_InCollections (); :UEDS:array hw_incollections(int connection, array object_id_array, array collection_id_array, int return_collections);" 
38="hw_Info (); :UEDS:string hw_info(int connection);" 
39="hw_InsColl (); :UEDS:int hw_inscoll(int connection, int objectID, array object_array);"); 
40="hw_insdoc(); :UEDS:int hw_insdoc(int connection, int parentID, string object_record, string text);"
41="hw_InsertDocument (); :UEDS:int hw_insertdocument(int connection, int parent_id, int hw_document);"
42="hw_InsertObject (); :UEDS:int hw_insertobject(int connection, string object rec, string parameter);"
43="hw_Modifyobject (); :UEDS:int hw_modifyobject(int connection, int object_to_change, array remove, array add, int mode);"        
44="hw_New_Document (); :UEDS:int hw_new_document(string object_record, string document_data, int document_size);"
45="hw_Objrec2Array (); :UEDS:array hw_objrec2array(string object_record);"           
46="hw_Objrec2Array - convert attributes from object record to object array(); :UEDS:hw_OutputDocument "
47="hw_OutputDocument (); :UEDS:int hw_outputdocument(int hw_document);" 
48="hw_pConnect (); :UEDS:int hw_pconnect(string host, int port, string username, string password);"
49="hw_PipeDocument (); :UEDS:int hw_pipedocument(int connection, int objectID);"     
50="hw_Root (); :UEDS:int hw_root();"
51="hw_Unlock (); :UEDS:int hw_unlock(int connection, int objectID);"    
52="hw_Who (); :UEDS:int hw_who(int connection);"
53="hw_Username (); :UEDS:string hw_getusername(int connection);"        


[Tag Group - Icap] 
0="icap_open (); :UEDS:stream icap_open(stringcalendar, stringusername, stringpassword, stringoptions);"          
1="icap_close (); :UEDS:int icap_close(int icap_stream, int flags);"
2="icap_fetch_event (); :UEDS:objecticap_fetch_event(streamicap_stream, idevent id, optionsoptions);"
3="icap_list_events (); :UEDS:array icap_list_events(stream icap_stream, datetime begin_date, datetime end_date);"
4="icap_store_event (); :UEDS:int icap_store_event(int icap_stream, object event);"
5="icap_delete_event (); :UEDS:int icap_delete_event(int uid);"
6="icap_snooze (); :UEDS:int icap_snooze(int uid);"
7="icap_list_alarms (); :UEDS:array icap_list_alarms(stream icap_stream, datetime alarm_date);"  

[Tag Group - Image]
0="GetImageSize (); :UEDS:array getimagesize(string filename, array [imageinfo]);"
1="ImageArc (); :UEDS:int imagearc(int im, int cx, int cy, int w, int h, int s, int e, int col);"
2="ImageChar (); :UEDS:int imagechar(int im, int font, int x, int y, string c, int col);"
3="ImageCharUp (); :UEDS:int imagecharup(int im, int font, int x, int y, string c, int col);"
4="ImageColorAllocate (); :UEDS:int imagecolorallocate(int im, int red, int green, int blue);"
5="ImageColorAt (); :UEDS:int imagecolorat(int im, int x, int y);"
6="ImageColorClosest (); :UEDS:int imagecolorclosest(int im, int red, int green, int blue);" 
7="ImageColorExact (); :UEDS:int imagecolorexact(int im, int red, int green, int blue);"   
8="ImageColorResolve (); :UEDS:int imagecolorresolve(int im, int red, int green, int blue);" 
9="ImageColorSet (); :UEDS:bool imagecolorset(int im, int index, int red, int green, int blue);" 
10="ImageColorsForIndex (); :UEDS:array imagecolorsforindex(int im, int index);"
11="ImageColorsTotal (); :UEDS:int imagecolorstotal(int im);"
12="ImageColorTransparent (); :UEDS:int imagecolortransparent(int im, int [col]);"
13="ImageCopyResized (); :UEDS:int imagecopyresized(int dst_im, int src_im, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH);"
14="ImageCreate (); :UEDS:int imagecreate(int x_size, int y_size);"
15="ImageCreateFromGif (); :UEDS:int imagecreatefromgif(string filename);"
16="ImageDashedLine (); :UEDS:int imagedashedline(int im, int x1, int y1, int x2, int y2, int col);"
17="ImageDestroy (); :UEDS:int imagedestroy(int im);"
18="ImageFill (); :UEDS:int imagefill(int im, int x, int y, int col);"
19="ImageFilledPolygon (); :UEDS:int imagefilledpolygon(int im, array points, int num_points, int col);"
20="ImageFilledRectangle (); :UEDS:int imagefilledrectangle(int im, int x1, int y1, int x2, int y2, int col);"
21="ImageFillToBorder (); :UEDS:int imagefilltoborder(int im, int x, int y, int border, int col);"            
22="ImageFontHeight (); :UEDS:int imagefontheight(int font);"
23="ImageFontWidth (); :UEDS:int imagefontwidth(int font);"  
24="ImageGif (); :UEDS:int imagegif(int im, string filename);"
25="ImageInterlace (); :UEDS:int imageinterlace(int im, int [interlace]);"
26="ImageLine (); :UEDS:int imageline(int im, int x1, int y1, int x2, int y2, int col);"
27="ImageLoadFont (); :UEDS:int imageloadfont(string file);" 
28="ImagePolygon (); :UEDS:int imagepolygon(int im, array points, int num_points, int col);"
29="ImagePSBBox (); :UEDS:array imagepsbbox(string text, int font, int size, int space, int width, float angle);"      
30="ImagePSEncodeFont (); :UEDS:int imagepsencodefont(string encodingfile);"            
31="ImagePSFreeFont (); :UEDS:void imagepsfreefont(int fontindex);"       
32="ImagePSLoadFont (); :UEDS:int imagepsloadfont(string filename);"      
33="ImageRectangle (); :UEDS:int imagerectangle(int im, int x1, int y1, int x2, int y2, int col);"            
34="ImageSetPixel (); :UEDS:int imagesetpixel(int im, int x, int y, int col);"          
35="ImageString (); :UEDS:int imagestring(int im, int font, int x, int y, string s, int col);"
36="ImageStringUp (); :UEDS:int imagestringup(int im, int font, int x, int y, string s, int col);"            
37="ImageSX (); :UEDS:int imagesx(int im);"
38="ImageSY (); :UEDS:int imagesy(int im);"
39="ImageTTFBBox (); :UEDS:array ImageTTFBBox(int size, int angle, string fontfile, string text);"
40="ImageTTFText (); :UEDS:array ImageTTFText(int im, int size, int angle, int x, int y, int col, string fontfile, string text);"

[Tag Group - IMAP]
0="array imap_fetchstructure(int imap_stream, int msg_number);(); :UEDS:id, lines, bytes, ifparameters" 
1="imap_8bit (); :UEDS:string imap_8bit(string string);"     
2="imap_alerts (); :UEDS:array imap_alerts(void );"      
3="imap_append (); :UEDS:int imap_append(int imap_stream, string mbox, string message, stringflags);" 
4="imap_base64 (); :UEDS:string imap_base64(string text);"     
5="imap_binary (); :UEDS:string imap_binary(string string);"   
6="imap_body (); :UEDS:string imap_body(int imap_stream, int msg_number, int flags);"
7="imap_check (); :UEDS:array imap_check(int imap_stream);"    
8="imap_clearflag_full (); :UEDS:string imap_clearflag_full(int stream, string sequence, string flag, string options);"
9="imap_close (); :UEDS:int imap_close(int imap_stream, int flags);"  
10="imap_createmailbox (); :UEDS:int imap_createmailbox(int imap_stream, string mbox);" 
11="imap_delete (); :UEDS:int imap_delete(int imap_stream, int msg_number);"  
12="imap_deletemailbox (); :UEDS:int imap_deletemailbox(int imap_stream, string mbox);" 
13="imap_errors (); :UEDS:array imap_errors(void );"  
14="imap_expunge (); :UEDS:int imap_expunge(int imap_stream);"  
15="imap_fetchbody (); :UEDS:string imap_fetchbody(int imap_stream, int msg_number, string part_number, flags flags);"  
16="imap_fetchheader (); :UEDS:stringimap_fetchheader(int imap_stream, int msgno, int flags);" 
17="imap_fetchstructure (); :UEDS:array imap_fetchstructure(int imap_stream, int msg_number);" 
18="imap_getmailboxes (); :UEDS:array imap_getmailboxes(int imap_stream, string ref, string pat);" 
19="imap_getsubscribed (); :UEDS:array imap_getsubscribed(int imap_stream, string ref, string pattern);"  
20="imap_header (); :UEDS:object imap_header(int imap_stream, int msg_number, int fromlength, int subjectlength, int defaulthost);"
21="imap_headers (); :UEDS:array imap_headers(int imap_stream);"
22="imap_last_error (); :UEDS:string imap_last_error(void );"   
23="imap_listmailbox (); :UEDS:array imap_listmailbox(int imap_stream, string ref, string pat);"   
24="imap_listsubscribed (); :UEDS:array imap_listsubscribed(int imap_stream, string ref, string pattern);"
25="imap_mailboxmsginfo (); :UEDS:array imap_mailboxmsginfo(int imap_stream);"
26="imap_mail_copy (); :UEDS:int imap_mail_copy(int imap_stream, string msglist, string mbox, int flags);"
27="imap_mail_move (); :UEDS:int imap_mail_move(int imap_stream, string msglist, string mbox);"
28="imap_msgno (); :UEDS:int imap_msgno(int imap_stream, int uid);"
29="imap_num_msg (); :UEDS:int imap_num_msg(int stream_id);"
30="imap_num_recent (); :UEDS:int imap_num_recent(int imap_stream);"   
31="imap_open (); :UEDS:int imap_open(string mailbox, string username, string password, int flags);"   
32="imap_ping (); :UEDS:int imap_ping(int imap_stream);"  
33="imap_qprint (); :UEDS:string imap_qprint(string string);"   
34="imap_renamemailbox (); :UEDS:int imap_renamemailbox(int imap_stream, string old_mbox, string new_mbox);"  
35="imap_reopen (); :UEDS:int imap_reopen(string imap_stream, string mailbox, string [flags]);"
36="imap_rfc822_parse_adrlist (); :UEDS:string imap_rfc822_parse_adrlist(string address, string default_host);"   
37="imap_rfc822_write_address (); :UEDS:string imap_rfc822_write_address(string mailbox, string host, string personal);"
38="imap_scanmailbox (); :UEDS:array imap_scanmailbox(int imap_stream, string string);" 
39="imap_search (); :UEDS:array imap_search(int imap_stream, string criteria, int flags);"  
40="imap_setflag_full (); :UEDS:string imap_setflag_full(int stream, string sequence, string flag, string options);"
41="imap_sort (); :UEDS:string imap_sort(int stream, int criteria, int reverse, int options);" 
42="imap_status (); :UEDS:object imap_status(int imap_stream, string mailbox, int options);"
43="imap_subscribe (); :UEDS:int imap_subscribe(int imap_stream, string mbox);"   
44="imap_uid (); :UEDS:int imap_uid(int imap_stream, int msgno);"  
45="imap_undelete (); :UEDS:int imap_undelete(int imap_stream, int msg_number);"  
46="imap_unsubscribe (); :UEDS:int imap_unsubscribe(int imap_stream, string mbox);"   



[Tag Group - LDAP]
0="ldap_add (); :UEDS:int ldap_add(int link_identifier, string dn, array entry);" 
1="ldap_mod_add (); :UEDS:int ldap_mod_add(int link_identifier, string dn, array entry);"
2="ldap_mod_del (); :UEDS:int ldap_mod_del(int link_identifier, string dn, array entry);"
3="ldap_mod_replace (); :UEDS:int ldap_mod_replace(int link_identifier, string dn, array entry);"
4="ldap_bind (); :UEDS:int ldap_bind(int link_identifier, string [bind_rdn], string [bind_password]);"
5="ldap_close (); :UEDS:int ldap_close(int link_identifier);"   
6="ldap_connect (); :UEDS:int ldap_connect(string [hostname], int [port]);"
7="ldap_count_entries (); :UEDS:int ldap_count_entries(int link_identifier, int result_identifier);"  
8="ldap_delete (); :UEDS:int ldap_delete(int link_identifier, string dn);" 
9="ldap_dn2ufn (); :UEDS:string ldap_dn2ufn(string dn);"  
10="ldap_explode_dn (); :UEDS:array ldap_explode_dn(string dn, int with_attrib);"
11="ldap_first_attribute (); :UEDS:string ldap_first_attribute(int link_identifier, int result_entry_identifier, int ber_identifier);" 
12="ldap_first_entry (); :UEDS:int ldap_first_entry(int link_identifier, int result_identifier);" 
13="ldap_free_result (); :UEDS:int ldap_free_result(int result_identifier);" 
14="ldap_get_attributes (); :UEDS:array ldap_get_attributes(int link_identifier, int result_entry_identifier);"
15="ldap_get_dn (); :UEDS:string ldap_get_dn(int link_identifier, int result_entry_identifier);"  
16="ldap_get_entries (); :UEDS:array ldap_get_entries(int link_identifier, int result_identifier);"
17="ldap_get_values (); :UEDS:array ldap_get_values(int link_identifier, int result_entry_identifier, string attribute);"
18="ldap_list (); :UEDS:int ldap_list(int link_identifier, string base_dn, string filter, array [attributes]);"
19="ldap_modify (); :UEDS:int ldap_modify(int link_identifier, string dn, array entry);"  
20="ldap_next_attribute (); :UEDS:string ldap_next_attribute(int link_identifier, int result_entry_identifier, int ber_identifier);" 
21="ldap_next_entry (); :UEDS:int ldap_next_entry(int link_identifier, int result_entry_identifier);"  
22="ldap_read (); :UEDS:int ldap_read(int link_identifier, string base_dn, string filter, array [attributes]);"
23="ldap_search (); :UEDS:int ldap_search(int link_identifier, string base_dn, string filter, array [attributes]);"
24="ldap_unbind (); :UEDS:int ldap_unbind(int link_identifier);" 


[Tag Group - Math]
0="Abs (); :UEDS:mixed abs(mixed number);" 
1="Acos (); :UEDS:float acos(float arg);"
2="Asin (); :UEDS:float asin(float arg);"
3="Atan (); :UEDS:float atan(float arg);"
4="Atan2 (); :UEDS:float atan2(float y, float x);"   
5="base_convert (); :UEDS:strin base_convert(string number, int frombase, int tobase);"
6="BinDec (); :UEDS:int bindec(string binary_string);" 
7="Ceil (); :UEDS:int ceil(float number);" 
8="Cos (); :UEDS:float cos(float arg);"  
9="DecBin (); :UEDS:string decbin(int number);"
10="DecHex (); :UEDS:string dechex(int number);"
11="DecOct (); :UEDS:string decoct(int number);"
12="Exp (); :UEDS:float exp(float arg);"  
13="Floor (); :UEDS:int floor(float number);"   
14="getrandmax (); :UEDS:int getrandmax(void );"
15="HexDec (); :UEDS:int hexdec(string hex_string);"  
16="Log (); :UEDS:float log(float arg);"  
17="Log10 (); :UEDS:float log10(float arg);"
18="max (); :UEDS:mixed max(mixed arg1, mixed arg2, mixed argn);" 
19="min (); :UEDS:mixed min(mixed arg1, mixed arg2, mixed argn);" 
20="mt_rand (); :UEDS:int mt_rand([int min], [int max]);"   
21="mt_srand (); :UEDS:void mt_srand(int seed);"
22="mt_getrandmax (); :UEDS:int mt_getrandmax(void );"
23="number_format (); :UEDS:string number_format(float number, int decimals, string dec_point, string thousands_sep);"
24="OctDec (); :UEDS:int octdec(string octal_string);"
25="pi (); :UEDS:double pi(void );" 
26="pow (); :UEDS:float pow(float base, float exp);"  
27="rand (); :UEDS:int rand([int min], [int max]);"   
28="round (); :UEDS:double round(double val);"  
29="Sin (); :UEDS:float sin(float arg);"  
30="Sqrt (); :UEDS:float sqrt(float arg);"
31="srand (); :UEDS:void srand(int seed);"
32="Tan (); :UEDS:float tan(float arg);"  

[Tag Group - Mail & Miscel.]
0="connection_aborted (); :UEDS:int connection_aborted(void );"
1="connection_aborted - Return true if client disconnected(); :UEDS:connection_status "
2="connection_status (); :UEDS:int connection_status(void );"  
3="connection_status - Returns connection status bitfield(); :UEDS:connection_timeout "
4="connection_timeout (); :UEDS:int connection_timeout(void );"6="connection_timeout - Return true if script timed out(); :UEDS:eval " 
5="die (); :UEDS:void die(string message);"
6="eval (); :UEDS:void eval(string code_str);"   
7="exit (); :UEDS:void exit(void);"
8="function_exists (); :UEDS:int function_exists(string function_name);"
9="ignore_user_abort (); :UEDS:int ignore_user_abort(int [setting]);"
10="ignore_user_abort - Set whether a client disconnect should abort script execution(); :UEDS:iptcparse "
11="iptcparse (); :UEDS:array iptcparse(string iptcblock);"
12="leak (); :UEDS:void leak(int bytes);"
13="mail (); :UEDS:bool mail(string to, string subject, string message, string [additional_headers]);"   
14="pack (); :UEDS:string pack(string format, mixed [args]...);"
15="register_shutdown_function (); :UEDS:int register_shutdown_function(string func);"
16="serialize (); :UEDS:string serialize(mixed value);"
17="sleep (); :UEDS:void sleep(int seconds);"
18="unpack (); :UEDS:array unpack(string format, string data);"
19="unserialize (); :UEDS:mixed unserialize(string str);"
20="uniqid (); :UEDS:int uniqid(string prefix);"
21="usleep (); :UEDS:void usleep(int micro_seconds);"   

[Tag Group - MySQL]
0="mysql_affected_rows (); :UEDS:int mysql_affected_rows(int [link_identifier] );"   
1="mysql_close (); :UEDS:int mysql_close(int [link_identifier] );"
2="mysql_connect (); :UEDS:int mysql_connect(string [hostname [:port] [:/path/to/socket] ] , string [username] , string [password] );"
3="mysql_create_db (); :UEDS:int mysql_create_db(string database name, int [link_identifier] );"
4="mysql_data_seek (); :UEDS:int mysql_data_seek(int result_identifier, int row_number);"  
5="mysql_db_query (); :UEDS:int mysql_db_query(string database, string query, int [link_identifier] );"
6="mysql_drop_db (); :UEDS:int mysql_drop_db(string database_name, int [link_identifier] );"
7="mysql_errno (); :UEDS:int mysql_errno(int [link_identifier] );"
8="mysql_error (); :UEDS:string mysql_error(int [link_identifier] );"
9="mysql_fetch_array (); :UEDS:array mysql_fetch_array(int result, int [result_type] );"   
10="mysql_fetch_field (); :UEDS:object mysql_fetch_field(int result, int [field_offset] );" 
11="mysql_fetch_lengths (); :UEDS:array mysql_fetch_lengths(int result);" 
12="mysql_fetch_object (); :UEDS:object mysql_fetch_object(int result, int [result_typ]);"  
13="mysql_fetch_row (); :UEDS:array mysql_fetch_row(int result);"
14="mysql_field_name (); :UEDS:string mysql_field_name(int result, int field_index);"
15="mysql_field_seek (); :UEDS:int mysql_field_seek(int result, int field_offset);"
16="mysql_field_table (); :UEDS:string mysql_field_table(int result, int field_offset);"
17="mysql_field_type (); :UEDS:string mysql_field_type(int result, int field_offset);"
18="mysql_field_flags (); :UEDS:string mysql_field_flags(int result, int field_offset);"
19="mysql_field_len (); :UEDS:int mysql_field_len(int result, int field_offset);" 
20="mysql_free_result (); :UEDS:int mysql_free_result(int result);"
21="mysql_insert_id (); :UEDS:int mysql_insert_id(int [link_identifier] );" 
22="mysql_list_fields (); :UEDS:int mysql_list_fields(string database_name, string table_name, int [link_identifier] );"
23="mysql_list_dbs (); :UEDS:int mysql_list_dbs(int [link_identifier] );" 
24="mysql_list_tables (); :UEDS:int mysql_list_tables(string database, int [link_identifier] );"
25="mysql_num_fields (); :UEDS:int mysql_num_fields(int result);"
26="mysql_num_rows (); :UEDS:int mysql_num_rows(int result);"
27="mysql_pconnect (); :UEDS:int mysql_pconnect(string [hostname [:port] [:/path/to/socket] ] , string [username] , string [password] );"
28="mysql_query (); :UEDS:int mysql_query(string query, int [link_identifier] );"
29="mysql_result (); :UEDS:int mysql_result(int result, int row, mixed [field] );"
30="mysql_select_db (); :UEDS:int mysql_select_db(string database_name, int [link_identifier] );"
31="mysql_tablename (); :UEDS:string mysql_tablename(int result, int i);" 

[Tag Group - Network]
0="fsockopen (); :UEDS:int fsockopen(string hostname, int port, int [errno], string [errstr], double [timeout]);"
1="pfsockopen (); :UEDS:int pfsockopen(string hostname, int port, int [errno], string [errstr], int [timeout]);"
2="set_socket_blocking (); :UEDS:int set_socket_blocking(int socket descriptor, int mode);"  
3="gethostbyaddr (); :UEDS:string gethostbyaddr(string ip_address);"
4="gethostbyname (); :UEDS:string gethostbyname(string hostname);"
5="gethostbynamel (); :UEDS:array gethostbynamel(string hostname);"
6="checkdnsrr (); :UEDS:int checkdnsrr(string host, string [type]);"
7="getmxrr (); :UEDS:int getmxrr(string hostname, array mxhosts, array [weight]);"
8="openlog (); :UEDS:int openlog(string ident, int option, int facility);"
9="syslog (); :UEDS:int syslog(int priority, string message);"
10="closelog (); :UEDS:int closelog(void);"
11="debugger_on (); :UEDS:int debugger_on(string address);"
12="debugger_off (); :UEDS:int debugger_off(void);"
13="debugger_off (); :UEDS:int debugger_off(void);" 

[Tag Group - NIS]
0="yp_get_default_domain (); :UEDS:int yp_get_default_domain(void );" 
1="yp_order (); :UEDS:int yp_order(string domain, string map);"
2="yp_master (); :UEDS:string yp_master(string domain, string map);"  
3="yp_match (); :UEDS:string yp_match(string domain, string map, string key);"   
4="yp_first (); :UEDS:string[] yp_first(string domain, string map);"  
5="yp_next (); :UEDS:string[] yp_next(string domain, string map, string key);"   
6="yp_errno (); :UEDS:int yp_errno();"
7="yp_err_string (); :UEDS:string yp_err_string(void );" 

[Tag Group - ODBC]
0="odbc_autocommit (); :UEDS:int odbc_autocommit(int connection_id, int [OnOff]);"
1="odbc_binmode (); :UEDS:int odbc_binmode(int result_id, int mode);"
2="odbc_close (); :UEDS:void odbc_close(int connection_id);"
3="odbc_close_all (); :UEDS:void odbc_close_all(void);"
4="odbc_commit (); :UEDS:int odbc_commit(int connection_id);"
5="odbc_connect (); :UEDS:int odbc_connect(string dsn, string user, string password, int [cursor_type]);"
6="odbc_cursor (); :UEDS:string odbc_cursor(int result_id);"
7="odbc_do (); :UEDS:string odbc_do(int conn_id, string query);"
8="odbc_exec (); :UEDS:int odbc_exec(int connection_id, string query_string);"
9="odbc_execute (); :UEDS:int odbc_execute(int result_id, array [parameters_array]);"
10="odbc_fetch_into (); :UEDS:int odbc_fetch_into(int result_id, int [rownumber], array result_array);"
11="odbc_fetch_row (); :UEDS:int odbc_fetch_row(int result_id, int [row_number]);"
12="odbc_field_name (); :UEDS:string odbc_fieldname(int result_id, int field_number);"
13="odbc_field_type (); :UEDS:string odbc_field_type(int result_id, int field_number);"
14="odbc_field_len (); :UEDS:int odbc_field_len(int result_id, int field_number);"
15="odbc_free_result (); :UEDS:int odbc_free_result(int result_id);"
16="odbc_longreadlen (); :UEDS:int odbc_longreadlen(int result_id, int length);"
17="odbc_num_fields (); :UEDS:int odbc_num_fields(int result_id);"
18="odbc_pconnect (); :UEDS:int odbc_pconnect(string dsn, string user, string password, int [cursor_type]);"
19="odbc_prepare (); :UEDS:int odbc_prepare(int connection_id, string query_string);"
20="odbc_num_rows (); :UEDS:int odbc_num_rows(int result_id);"
21="odbc_result (); :UEDS:string odbc_result(int result_id, mixed field);"
22="odbc_result_all (); :UEDS:int odbc_result_all(int result_id, string [format]);"
23="odbc_rollback (); :UEDS:int odbc_rollback(int connection_id);"
24="odbc_setoption (); :UEDS:int odbc_setoption(int id, int function, int option, int param);"

[Tag Group - Oracle 8]
0="OCIBindByName (); :UEDS:int OCIBindByName(int stmt, string ph_name, mixed &variable, intlength, int [type]);"
1="OCIColumnIsNULL (); :UEDS:int OCIColumnIsNULL(int stmt, mixed column);"
2="OCIColumnName (); :UEDS:string OCIColumnName(int stmt, int col);"
3="OCIColumnSize (); :UEDS:int OCIColumnSize(int stmt, mixed column);"
4="OCIColumnType (); :UEDS:mixed OCIColumnName(int stmt, int col);"
5="OCICommit (); :UEDS:int OCICommit(int connection);"
6="OCIDefineByName (); :UEDS:int OCIDefineByName(int stmt, string Column-Name, mixed &variable, int [type]);" 
7="OCIError (); :UEDS:int OCIError(int [stmt|conn]);"
8="OCIExecute (); :UEDS:int OCIExecute(int statement, int [mode]);"
9="OCIFetch (); :UEDS:int OCIFetch(int statement);"
10="OCIFetchInto (); :UEDS:int OCIFetchInto(int stmt, array &result, int [mode]);" 
11="OCIFetchStatement (); :UEDS:int OCIFetchStatement(int stmt, array &variable);" 
12="OCIFreeCursor (); :UEDS:int OCIFreeCursor(int stmt);"
13="OCIFreeStatement (); :UEDS:int OCIFreeStatement(int stmt);"
14="OCIInternalDebug (); :UEDS:void OCIInternalDebug(int onoff);"
15="OCILogOff (); :UEDS:int OCILogOff(int connection);"
16="OCILogon (); :UEDS:int OCILogon(string username, string password, string [ORACLE_SID]);" 
17="OCINewCursor (); :UEDS:int OCINewCursor(int conn);"
18="OCINewDescriptor (); :UEDS:string OCINewDescriptor(int connection, int [type]);"
19="OCINLogon (); :UEDS:int OCINLogon(int conn);" 
20="OCINumCols (); :UEDS:int OCINumCols(int stmt);" 
21="OCIParse (); :UEDS:int OCIParse(int conn, strint query);"
22="OCIPLogon (); :UEDS:int OCIPLogon(int conn);" 
23="OCIResult (); :UEDS:int OCIResult(int statement, mixed column);"
24="OCIRollback (); :UEDS:int OCIRollback(int connection);"
25="OCIRowCount (); :UEDS:int OCIRowCount(int statement);" 
26="OCIServerVersion (); :UEDS:string OCIServerVersion(int conn);" 
27="OCIStatementType (); :UEDS:string OCIStatementType(int stmt);" 

[Tag Group - PDF]
0="PDF_get_info (); :UEDS:info pdf_get_info(string filename);"
1="PDF_set_info_creator (); :UEDS:void pdf_set_info_creator(info info, string creator);"
2="PDF_set_info_title (); :UEDS:void pdf_set_info_title(info info, string title);"
3="PDF_set_info_subject (); :UEDS:void pdf_set_info_subject(info info, string subject);"
4="PDF_set_info_keywords (); :UEDS:void pdf_set_info_keywords(info info, string keywords);"
5="PDF_set_info_author (); :UEDS:void pdf_set_info_author(info info, string author);"
6="PDF_open (); :UEDS:int pdf_open(int file, int info);"
7="PDF_close (); :UEDS:void pdf_close(int pdf document);"
8="PDF_begin_page (); :UEDS:void pdf_begin_page(int pdf document, double height, double width);"
9="PDF_end_page (); :UEDS:void pdf_end_page(int pdf document);"
10="PDF_show (); :UEDS:void pdf_show(int pdf document, string text);"
11="PDF_show_xy (); :UEDS:void pdf_show_xy(int pdf document, string text, double x-koor, double y-koor);"
12="PDF_set_font (); :UEDS:void pdf_set_font(int pdf document, string font name, double size, int encoding);"
13="PDF_set_leading (); :UEDS:void pdf_set leading(int pdf document, double distance);"
14="PDF_set_text_rendering (); :UEDS:void pdf_set_text_rendering(int pdf document, int mode);"
15="PDF_set_horiz_scaling (); :UEDS:void pdf_set_horiz_scaling(int pdf document, double scale);"
16="PDF_set_text_rise (); :UEDS:void pdf_set_text_rise(int pdf document, double value);"
17="PDF_set_text_matrix (); :UEDS:void pdf_set_text_matrix(int pdf document, array matrix);"
18="PDF_set_text_pos (); :UEDS:void pdf_set_text_pos(int pdf document, double x-koor, double y-koor);"
19="PDF_set_char_spacing (); :UEDS:void pdf_set_char_spacing(int pdf document, double space);"
20="PDF_set_word_spacing (); :UEDS:void pdf_set_word_spacing(int pdf document, double space);"
21="PDF_continue_text (); :UEDS:void pdf_continue_text(int pdf document, string text);"
22="PDF_stringwidth (); :UEDS:double pdf_stringwidth(int pdf document, string text);"
23="PDF_save (); :UEDS:void pdf_save(int pdf document);"
24="PDF_restore (); :UEDS:void pdf_restore(int pdf document);"
25="PDF_translate (); :UEDS:void pdf_translate(int pdf document, double x-koor, double y-koor);"
26="PDF_scale (); :UEDS:void pdf_scale(int pdf document, double x-scale, double y-scale);"
27="PDF_rotate (); :UEDS:void pdf_rotate(int pdf document, double angle);"
28="PDF_setflat (); :UEDS:void pdf_setflat(int pdf document, double value);"
29="PDF_setlinejoin (); :UEDS:void pdf_setlinejoin(int pdf document, long value);"
30="PDF_setlinecap (); :UEDS:void pdf_setlinecap(int pdf document, int value);"
31="PDF_setmiterlimit (); :UEDS:void pdf_setmiterlimit(int pdf document, double value);"
32="PDF_setlinewidth (); :UEDS:void pdf_setlinewidth(int pdf document, double width);"
33="PDF_setdash (); :UEDS:void pdf_setdash(int pdf document, double white, double black);"
34="PDF_moveto (); :UEDS:void pdf_moveto(int pdf document, double x-koor, double y-koor);"
35="PDF_curveto (); :UEDS:void pdf_curveto(int pdf document, double x1, double y1, double x2, double y2, double x3, double y3);"
36="PDF_lineto (); :UEDS:void pdf_lineto(int pdf document, double x-koor, double y-koor);"
37="PDF_circle (); :UEDS:void pdf_circle(int pdf document, double x-koor, double y-koor, double radius);"
38="PDF_arc (); :UEDS:void pdf_arc(int pdf document, double x-koor, double y-koor, double radius, double start, double end);"
39="PDF_rect (); :UEDS:void pdf_rect(int pdf document, double x-koor, double y-koor, double width, double height);"
40="PDF_closepath (); :UEDS:void pdf_closepath(int pdf document);"
41="PDF_stroke (); :UEDS:void pdf_stroke(int pdf document);"
42="PDF_closepath_stroke (); :UEDS:void pdf_closepath_stroke(int pdf document);"
43="PDF_fill (); :UEDS:void pdf_fill(int pdf document);"
44="PDF_fill_stroke (); :UEDS:void pdf_fill_stroke(int pdf document);"
45="PDF_closepath_fill_stroke (); :UEDS:void pdf_closepath_fill_stroke(int pdf document);"
46="PDF_endpath (); :UEDS:void pdf_endpath(int pdf document);"
47="PDF_clip (); :UEDS:void pdf_clip(int pdf document);"
48="PDF_setgray_fill (); :UEDS:void pdf_setgray_fill(int pdf document, double value);"
49="PDF_setgray_stroke (); :UEDS:void pdf_setgray_stroke(int pdf document, double gray value);"
50="PDF_setgray (); :UEDS:void pdf_setgray(int pdf document, double gray value);"
51="PDF_setrgbcolor_fill (); :UEDS:void pdf_setrgbcolor_fill(int pdf document, double red value, double green value, double blue value);"
52="PDF_setrgbcolor_stroke (); :UEDS:void pdf_setrgbcolor_stroke(int pdf document, double red value, double green value, double blue value);"
53="PDF_setrgbcolor (); :UEDS:void pdf_setrgbcolor(int pdf document, double red value, double green value, double blue value);"
54="PDF_add_outline (); :UEDS:void pdf_add_outline(int pdf document, string text);"
55="PDF_set_transition (); :UEDS:void pdf_set_transition(int pdf document, int transition);"
56="PDF_set_duration (); :UEDS:void pdf_set_duration(int pdf document, double duration);"
57="PDF_open_gif (); :UEDS:int pdf_open_gif(int pdf document, string filename);"
58="PDF_open_memory_image (); :UEDS:int pdf_open_memory_image(int pdf document, string int image);"
59="PDF_open_jpeg (); :UEDS:int pdf_open_jpeg(int pdf document, string filename);"
60="PDF_close_image (); :UEDS:void pdf_close_image(int image);"
61="PDF_place_image (); :UEDS:void pdf_place_image(int pdf document, int image, double x-koor, double y-koor, double scale);"
62="PDF_put_image (); :UEDS:void pdf_put_image(int pdf document, int image);"
63="PDF_execute_image (); :UEDS:void pdf_execute_image(int pdf document, int image, double x-coor, double y-coor, double scale);"
64="PDF_add_annotation (); :UEDS:void pdf_add_annotation(int pdf document, double llx, double lly, double urx, double ury, string title, string content);"

[Tag Group - PHP Options&Info]
0="dl (); :UEDS:int dl(string library);"
1="error_log (); :UEDS:int error_log(string message, int message_type, string [destination], string [extra_headers]);"
2="error_reporting (); :UEDS:int error_reporting(int [level]);"
3="getenv (); :UEDS:string getenv(string varname);"  
4="get_cfg_var (); :UEDS:string get_cfg_var(string varname);"
5="get_current_user (); :UEDS:string get_current_user(void);"
6="get_magic_quotes_gpc (); :UEDS:long get_magic_quotes_gpc(void);"
7="get_magic_quotes_runtime (); :UEDS:long get_magic_quotes_runtime(void);"
8="getlastmod (); :UEDS:int getlastmod(void);"
9="getmyinode (); :UEDS:int getmyinode(void);"
10="getmypid (); :UEDS:int getmypid(void);"
11="getmyuid (); :UEDS:int getmyuid(void);"
12="getrusage (); :UEDS:array getrusage(int [who]);"  
13="phpinfo (); :UEDS:int phpinfo(void);"  
14="phpversion (); :UEDS:string phpversion(void);" 
15="extension_loaded (); :UEDS:bool extension_loaded(string name);"
16="putenv (); :UEDS:void putenv(string setting);" 17="set_magic_quotes_runtime (); :UEDS:long set_magic_quotes_runtime(int new_setting);"
18="set_time_limit (); :UEDS:void set_time_limit(int seconds);"

[Tag Group - Perl RegEx]
0="preg_match (); :UEDS:int preg_match(string pattern, string subject, array [matches]);"  
1="preg_match_all (); :UEDS:int preg_match_all(string pattern, string subject, array matches, int [order]);"
2="preg_replace (); :UEDS:mixed preg_replace(mixed pattern, mixed replacement, mixed subject);"
3="preg_split (); :UEDS:array preg_split(string pattern, string subject, int [limit]);" 
4="preg_quote (); :UEDS:string preg_quote(string str);"
5="preg_grep (); :UEDS:array preg_grep(string pattern, array input);"   



[Tag Group - Progrm.Exec]
0="escapeshellcmd (); :UEDS:string escapeshellcmd(string command);" 
1="exec (); :UEDS:string exec(string command, string [array], int [return_var]);"  
2="system (); :UEDS:string system(string command, int [return_var]);"  
3="passthru (); :UEDS:string passthru(string command, int [return_var]);" 

[Tag Group - Reg. Expressions]
0="ereg (); :UEDS:int ereg(string pattern, string string, array [regs]);"  
1="ereg_replace (); :UEDS:string ereg_replace(string pattern, string replacement, string string);" 
2="eregi (); :UEDS:int eregi(string pattern, string string, array [regs]);"
3="eregi_replace (); :UEDS:string eregi_replace(string pattern, string replacement, string string);"  
4="split (); :UEDS:array split(string pattern, string string, int [limit]);"  
5="sql_regcase (); :UEDS:string sql_regcase(string string);"

[Tag Group - Semaphore]
0="sem_get (); :UEDS:int sem_get(int key, int [max_acquire] , int [perm] );"  
1="sem_acquire (); :UEDS:int sem_acquire(int sem_identifier);" 
2="sem_release (); :UEDS:int sem_release(int sem_identifier);" 
3="shm_attach (); :UEDS:int shm_attach(int key, int [memsize], int [perm]);" 
4="shm_detach (); :UEDS:int shm_detach(int shm_identifier);"
5="shm_remove (); :UEDS:int shm_remove(int shm_identifier);"
6="shm_put_var (); :UEDS:int shm_put_var(int shm_identifier, int variable_key, mixed variable);"
7="shm_get_var (); :UEDS:mixed shm_get_var(int id, int variable_key);"  
8="shm_remove_var (); :UEDS:int shm_remove_var(int id, int variable_key);"

[Tag Group - Session]  
0="session_start (); :UEDS:bool session_start(void);"  
1="session_destroy (); :UEDS:bool session_destroy(void);" 
2="session_name (); :UEDS:string session_name(string [name]);"  
3="session_module_name (); :UEDS:string session_module_name(string [module]);" 
4="session_save_path (); :UEDS:string session_save_path(string [path]);" 
5="session_id (); :UEDS:string session_id(string [id]);"  
6="session_register (); :UEDS:bool session_register(string name);" 
7="session_unregister (); :UEDS:bool session_unregister(string name);"
8="session_is_registered (); :UEDS:bool session_is_registered(string name);"
9="session_decode (); :UEDS:bool session_decode(string data);"
10="session_encode (); :UEDS:bool session_encode(void);"

[Tag Group - SNMP]
0="snmpget (); :UEDS:string snmpget(string hostname, string community, string object_id, int [timeout], int [retries]);" 
1="snmpset (); :UEDS:string snmpget(string hostname, string community, string object_id, string type, mixed value, int [timeout], int [retries]);"  
2="snmpwalk (); :UEDS:array snmpwalk(string hostname, string community, string object_id, int [timeout] , int [retries] );" 
3="snmpwalkoid (); :UEDS:array snmpwalkoid(string hostname, string community, string object_id, int [timeout] , int [retries] );" 
4="snmp_get_quick_print (); :UEDS:boolean snmp_get_quick_print(void );" 5="snmp_set_quick_print (); :UEDS:void snmp_set_quick_print(boolean quick_print);"



[Tag Group - String]
0="AddSlashes (); :UEDS:string addslashes(string str);"  
1="bin2hex (); :UEDS:string bin2hex(string str);"  
2="Chop (); :UEDS:string chop(string str);"  
3="Chr (); :UEDS:string chr(int ascii);"  
4="chunk_split (); :UEDS:string chunk_split(string string, int [chunklen] , string [end] );"  
5="convert_cyr_string (); :UEDS:string convert_cyr_string(string str, string from, string to);"  
6="crypt (); :UEDS:string crypt(string str, string [salt]);" 
7="echo (); :UEDS:echo(string arg1, string [argn]...);"  
8="explode (); :UEDS:array explode(string separator, string string);" 
9="flush (); :UEDS:void flush(void);"  
10="get_meta_tags (); :UEDS:array get_meta_tags(string filename, int [use_include_path]);"  
11="htmlspecialchars (); :UEDS:string htmlspecialchars(string string);"
12="htmlentities (); :UEDS:string htmlentities(string string);"  
13="implode (); :UEDS:string implode(string glue, array pieces);"
14="join (); :UEDS:string join(string glue, array pieces);"
15="ltrim (); :UEDS:string ltrim(string str);"
16="md5 (); :UEDS:string md5(string str);" 
17="nl2br (); :UEDS:string nl2br(string string);"
18="Ord (); :UEDS:int ord(string string);" 
19="parse_str (); :UEDS:void parse_str(string str);"
20="print (); :UEDS:print(string arg);" 
21="printf (); :UEDS:int printf(string format, mixed [args]...);"
22="quoted_printable_decode (); :UEDS:string quoted_printable_decode(string str);" "
23="QuoteMeta (); :UEDS:string quotemeta(string str);" 
24="rawurldecode (); :UEDS:string rawurldecode(string str);"  
25="rawurlencode (); :UEDS:string rawurlencode(string str);"  
26="setlocale (); :UEDS:string setlocale(string category, string locale);"
27="similar_text (); :UEDS:int similar_text(string first, string second, double [percent]);"
28="soundex (); :UEDS:string soundex(string str);"  
29="sprintf (); :UEDS:sprintf(string format, mixed [args]...);"  
30="strchr (); :UEDS:string strchr(string haystack, string needle);"
31="strcmp (); :UEDS:int strcmp(string str1, string str2);"
32="strcspn (); :UEDS:int strcspn(string str1, string str2);" 
33="strip_tags (); :UEDS:string strip_tags(string str);"  
34="StripSlashes (); :UEDS:string stripslashes(string str);"  
35="strlen (); :UEDS:int strlen(string str);" 
36="strrpos (); :UEDS:int strrpos(string haystack, char needle);"
37="strpos (); :UEDS:int strpos(string haystack, string needle, int [offset]);" 
38="strrchr (); :UEDS:string strrchr(string haystack, string needle);" 
39="strrev (); :UEDS:string strrev(string string);" 
40="strspn (); :UEDS:int strspn(string str1, string str2);"
41="strstr (); :UEDS:string strstr(string haystack, string needle);"
42="strtok (); :UEDS:string strtok(string arg1, string arg2);"
43="strtolower (); :UEDS:string strtolower(string str);"  
44="strtoupper (); :UEDS:string strtoupper(string string);"
45="str_replace (); :UEDS:string str_replace(string needle, string str, string haystack);"  
46="strtr (); :UEDS:string strtr(string str, string from, string to);" 
47="substr (); :UEDS:string substr(string string, int start, int [length]);" 
48="trim (); :UEDS:string trim(string str);"  
49="ucfirst (); :UEDS:string ucfirst(string str);"  
50="ucwords (); :UEDS:string ucwords(string str);"  

[Tag Group - URL]
0="parse_url (); :UEDS:array parse_url(string url);" 
1="urldecode (); :UEDS:string urldecode(string str);"
2="urlencode (); :UEDS:string urlencode(string str);"
3="base64_encode (); :UEDS:string base64_encode(string data);"
4="base64_decode (); :UEDS:string base64_decode(string encoded_data);" 

[Tag Group - Variable]
0="gettype (); :UEDS:string gettype(mixed var);" 
1="intval (); :UEDS:int intval(mixed var, int [base]);"
2="doubleval (); :UEDS:double doubleval(mixed var);"
3="empty (); :UEDS:int empty(mixed var);"  
4="is_array (); :UEDS:int is_array(mixed var);"  
5="is_double (); :UEDS:int is_double(mixed var);"
6="is_float (); :UEDS:int is_float(mixed var);"  
7="is_int (); :UEDS:int is_int(mixed var);"
8="is_integer (); :UEDS:int is_integer(mixed var);" 
9="is_long (); :UEDS:int is_long(mixed var);" 
10="is_object (); :UEDS:int is_object(mixed var);"
11="is_real (); :UEDS:int is_real(mixed var);" 
12="is_string (); :UEDS:int is_string(mixed var);"
13="isset (); :UEDS:int isset(mixed var);"  
14="settype (); :UEDS:int settype(string var, string type);"  
15="strval (); :UEDS:string strval(mixed var);"
16="unset (); :UEDS:int unset(mixed var);"  

[Tag Group - Vmailmgr]
0="vm_adduser (); :UEDS:int vm_adduser(string vdomain, string basepwd, string newusername, string newuserpassword);" 
1="vm_addalias (); :UEDS:int vm_addalias(string vdomain, string basepwd, string username, string alias);"
2="vm_passwd (); :UEDS:int vm_passwd(string vdomain, string username, string password, string newpassword);"
3="vm_delalias (); :UEDS:int vm_delalias(string vdomain, string basepwd, string alias);"  
4="vm_deluser (); :UEDS:int vm_deluser(string vdomain, string username);"  

[Tag Group - WDDX]
0="wddx_serialize_value (); :UEDS:string wddx_serialize_value(mixed var, string [comment]);"  
1="wddx_serialize_vars (); :UEDS:string wddx_serialize_vars(string var_name | array var_names [, ... ] );" 
2="wddx_packet_start (); :UEDS:int wddx_packet_start(string [comment]);"  
3="wddx_packet_end (); :UEDS:int wddx_packet_end(int packet_id);"
4="wddx_add_vars (); :UEDS:wddx_add_vars(int packet_id, ...);"
5="wddx_deserialize (); :UEDS:mixed wddx_deserialize(string packet);"  


[Tag Group - XML]
0="xml_parser_create (); :UEDS:int xml_parser_create(string [encoding]);"  
1="xml_set_element_handler (); :UEDS:int xml_set_element_handler(int parser, string startElementHandler, string endElementHandler);"
2="xml_set_character_data_handler (); :UEDS:int xml_set_character_data_handler(int parser, string handler);"
3="xml_set_processing_instruction_handler (); :UEDS:int xml_set_processing_instruction_handler(int parser, string handler);"
4="xml_set_default_handler (); :UEDS:int xml_set_default_handler(int parser, string handler);"
5="xml_set_unparsed_entity_decl_handler (); :UEDS:int xml_set_unparsed_entity_decl_handler(int parser, string handler);"
6="xml_set_notation_decl_handler (); :UEDS:int xml_set_notation_decl_handler(int parser, string handler);"
7="xml_set_external_entity_ref_handler (); :UEDS:int xml_set_external_entity_ref_handler(int parser, string handler);"
8="xml_parse (); :UEDS:int xml_parse(int parser, string data, int [isFinal]);"
9="xml_get_error_code (); :UEDS:int xml_get_error_code(int parser);"
10="xml_error_string (); :UEDS:string xml_error_string(int code);"
11="xml_get_current_line_number (); :UEDS:int xml_get_current_line_number(int parser);"
12="xml_get_current_column_number (); :UEDS:int xml_get_current_column_number(int parser);"
13="xml_get_current_byte_index (); :UEDS:int xml_get_current_byte_in