cURL.old

curl_global_init(libpath = "", flags = 3){      ; curl_global_init(long flags) 

    global

    ; http://curl.haxx.se/libcurl/c/curl_global_init.html

    /*
     * NAME curl_global_init()
     * <curl/curl.h>
     *
     * DESCRIPTION
     *
     * curl_global_init() should be invoked exactly once for each application that
     * uses libcurl and before any call of other libcurl functions.
     *
     * Note: This function is not thread-safe!
     *
     * PARAMETERS (long Flags)
	 * CURL_GLOBAL_SSL 1
	 * CURL_GLOBAL_WIN32 2
	 * CURL_GLOBAL_ALL (CURL_GLOBAL_SSL + CURL_GLOBAL_WIN32)
	 * CURL_GLOBAL_NOTHING 0
	 * CURL_GLOBAL_DEFAULT CURL_GLOBAL_ALL
     *
     * RETURN VALUE
     * If this function returns non-zero, something went wrong and you cannot use the other curl functions.
     */
     
	if !libpath
        libpath := "libcurl.dll"    ; Assume SetWorkingDir was called
    else if libpath not contains .dll
        libpath .= "\libcurl.dll"   ; Only dir was given
    
    ; Load library in to memory so we can read Strings with other functions
    hCurlModule := DllCall( "LoadLibrary", Str, libpath)
	if (!hCurlModule || ErrorLevel)
		return -1 ; Library not found
        
    ; Assigning Constants
    CURL_ERROR_SIZE                   := 256

    ; ************[CURL_VERSION]********
    CURL_VERSION_IPV6                 := 1    ; IPv6-enabled 
    CURL_VERSION_KERBEROS4            := 2    ; Kerberos auth is supported 
    CURL_VERSION_SSL                  := 3    ; SSL options are present 
    CURL_VERSION_LIBZ                 := 4    ; Libz features are present 
    CURL_VERSION_NTLM                 := 5    ; NTLM auth is supported 
    CURL_VERSION_GSSNEGOTIATE         := 6    ; Negotiate auth support 
    CURL_VERSION_DEBUG                := 7    ; Built with debug capabilities 
    CURL_VERSION_ASYNCHDNS            := 8    ; Asynchronous dns resolves 
    CURL_VERSION_SPNEGO               := 9    ; SPNEGO auth 
    CURL_VERSION_LARGEFILE            := 10   ; Supports files bigger than 2GB 
    CURL_VERSION_IDN                  := 11   ; International Domain Names support 
    CURL_VERSION_SSPI                 := 12   ; SSPI is supported 
    CURL_VERSION_CONV                 := 13   ; Character conversions supported 
    CURL_VERSION_CURLDEBUG            := 14   ; Debug memory tracking supported 

    ; ************[CURLFORM]************
    CURLFORM_COPYNAME                 := 1
    CURLFORM_PTRNAME                  := 2
    CURLFORM_NAMELENGTH               := 3
    CURLFORM_COPYCONTENTS             := 4
    CURLFORM_PTRCONTENTS              := 5
    CURLFORM_CONTENTSLENGTH           := 6
    CURLFORM_FILECONTENT              := 7
    CURLFORM_ARRAY                    := 8
    CURLFORM_FILE                     := 10
    CURLFORM_BUFFER                   := 11
    CURLFORM_BUFFERPTR                := 12
    CURLFORM_BUFFERLENGTH             := 13
    CURLFORM_CONTENTTYPE              := 14
    CURLFORM_CONTENTHEADER            := 15
    CURLFORM_FILENAME                 := 16
    CURLFORM_END                      := 17

    ; ************[CURLOPT]*************
    CURLOPTTYPE_LONG                  := 0
    CURLOPTTYPE_OBJECTPOINT           := 10000
    CURLOPTTYPE_FUNCTIONPOINT         := 20000
    CURLOPTTYPE_OFF_T                 := 30000
    
    CURLOPT_FILE                      := 10001 ; 1   + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_URL                       := 10002 ; 2   + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_PORT                      := 3     ; 3   + CURLOPTTYPE_LONG
    CURLOPT_PROXY                     := 10004 ; 4   + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_USERPWD                   := 10005 ; 5   + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_PROXYUSERPWD              := 10006 ; 6   + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_RANGE                     := 10007 ; 7   + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_INFILE                    := 10009 ; 9   + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_ERRORBUFFER               := 10010 ; 10  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_WRITEFUNCTION             := 20011 ; 11  + CURLOPTTYPE_FUNCTIONPOINT
    CURLOPT_READFUNCTION              := 20012 ; 12  + CURLOPTTYPE_FUNCTIONPOINT
    CURLOPT_TIMEOUT                   := 13    ; 13  + CURLOPTTYPE_LONG
    CURLOPT_INFILESIZE                := 14    ; 14  + CURLOPTTYPE_LONG
    CURLOPT_POSTFIELDS                := 10015 ; 15  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_REFERER                   := 10016 ; 16  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_FTPPORT                   := 10017 ; 17  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_USERAGENT                 := 10018 ; 18  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_LOW_SPEED_LIMIT           := 19    ; 19  + CURLOPTTYPE_LONG
    CURLOPT_LOW_SPEED_TIME            := 20    ; 20  + CURLOPTTYPE_LONG
    CURLOPT_RESUME_FROM               := 21    ; 21  + CURLOPTTYPE_LONG
    CURLOPT_COOKIE                    := 10022 ; 22  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_HTTPHEADER                := 10023 ; 23  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_HTTPPOST                  := 10024 ; 24  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_SSLCERT                   := 10025 ; 25  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_KEYPASSWD                 := 10026 ; 26  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_CRLF                      := 27    ; 27  + CURLOPTTYPE_LONG
    CURLOPT_QUOTE                     := 10028 ; 28  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_WRITEHEADER               := 10029 ; 29  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_COOKIEFILE                := 10031 ; 31  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_SSLVERSION                := 32    ; 32  + CURLOPTTYPE_LONG
    CURLOPT_TIMECONDITION             := 33    ; 33  + CURLOPTTYPE_LONG
    CURLOPT_TIMEVALUE                 := 34    ; 34  + CURLOPTTYPE_LONG
    CURLOPT_CUSTOMREQUEST             := 10036 ; 36  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_STDERR                    := 10037 ; 37  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_POSTQUOTE                 := 10039 ; 39  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_WRITEINFO                 := 10040 ; 40  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_VERBOSE                   := 41    ; 41  + CURLOPTTYPE_LONG
    CURLOPT_HEADER                    := 42    ; 42  + CURLOPTTYPE_LONG
    CURLOPT_NOPROGRESS                := 43    ; 43  + CURLOPTTYPE_LONG
    CURLOPT_NOBODY                    := 44    ; 44  + CURLOPTTYPE_LONG
    CURLOPT_FAILONERROR               := 45    ; 45  + CURLOPTTYPE_LONG
    CURLOPT_UPLOAD                    := 46    ; 46  + CURLOPTTYPE_LONG
    CURLOPT_POST                      := 47    ; 47  + CURLOPTTYPE_LONG
    CURLOPT_DIRLISTONLY               := 48    ; 48  + CURLOPTTYPE_LONG
    CURLOPT_APPEND                    := 50    ; 50  + CURLOPTTYPE_LONG
    CURLOPT_NETRC                     := 51    ; 51  + CURLOPTTYPE_LONG
    CURLOPT_FOLLOWLOCATION            := 52    ; 52  + CURLOPTTYPE_LONG
    CURLOPT_TRANSFERTEXT              := 53    ; 53  + CURLOPTTYPE_LONG
    CURLOPT_PUT                       := 54    ; 54  + CURLOPTTYPE_LONG
    CURLOPT_PROGRESSFUNCTION          := 20056 ; 56  + CURLOPTTYPE_FUNCTIONPOINT
    CURLOPT_PROGRESSDATA              := 10057 ; 57  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_AUTOREFERER               := 58    ; 58  + CURLOPTTYPE_LONG
    CURLOPT_PROXYPORT                 := 59    ; 59  + CURLOPTTYPE_LONG
    CURLOPT_POSTFIELDSIZE             := 60    ; 60  + CURLOPTTYPE_LONG
    CURLOPT_HTTPPROXYTUNNEL           := 61    ; 61  + CURLOPTTYPE_LONG
    CURLOPT_INTERFACE                 := 10062 ; 62  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_KRBLEVEL                  := 10063 ; 63  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_SSL_VERIFYPEER            := 64    ; 64  + CURLOPTTYPE_LONG
    CURLOPT_CAINFO                    := 10065 ; 65  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_MAXREDIRS                 := 68    ; 68  + CURLOPTTYPE_LONG
    CURLOPT_FILETIME                  := 69    ; 69  + CURLOPTTYPE_LONG
    CURLOPT_TELNETOPTIONS             := 10070 ; 70  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_MAXCONNECTS               := 71    ; 71  + CURLOPTTYPE_LONG
    CURLOPT_CLOSEPOLICY               := 72    ; 72  + CURLOPTTYPE_LONG
    CURLOPT_FRESH_CONNECT             := 74    ; 74  + CURLOPTTYPE_LONG
    CURLOPT_FORBID_REUSE              := 75    ; 75  + CURLOPTTYPE_LONG
    CURLOPT_RANDOM_FILE               := 10076 ; 76  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_EGDSOCKET                 := 10077 ; 77  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_CONNECTTIMEOUT            := 78    ; 78  + CURLOPTTYPE_LONG
    CURLOPT_HEADERFUNCTION            := 20079 ; 79  + CURLOPTTYPE_FUNCTIONPOINT
    CURLOPT_HTTPGET                   := 80    ; 80  + CURLOPTTYPE_LONG
    CURLOPT_SSL_VERIFYHOST            := 81    ; 81  + CURLOPTTYPE_LONG
    CURLOPT_COOKIEJAR                 := 10082 ; 82  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_SSL_CIPHER_LIST           := 10083 ; 83  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_HTTP_VERSION              := 84    ; 84  + CURLOPTTYPE_LONG
    CURLOPT_FTP_USE_EPSV              := 85    ; 85  + CURLOPTTYPE_LONG
    CURLOPT_SSLCERTTYPE               := 10086 ; 86  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_SSLKEY                    := 10087 ; 87  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_SSLKEYTYPE                := 10088 ; 88  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_SSLENGINE                 := 10089 ; 89  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_SSLENGINE_DEFAULT         := 90    ; 90  + CURLOPTTYPE_LONG
    CURLOPT_DNS_USE_GLOBAL_CACHE      := 91    ; 91  + CURLOPTTYPE_LONG
    CURLOPT_DNS_CACHE_TIMEOUT         := 92    ; 92  + CURLOPTTYPE_LONG
    CURLOPT_PREQUOTE                  := 10093 ; 93  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_DEBUGFUNCTION             := 20094 ; 94  + CURLOPTTYPE_FUNCTIONPOINT
    CURLOPT_DEBUGDATA                 := 10095 ; 95  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_COOKIESESSION             := 96    ; 96  + CURLOPTTYPE_LONG
    CURLOPT_CAPATH                    := 10097 ; 97  + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_BUFFERSIZE                := 98    ; 98  + CURLOPTTYPE_LONG
    CURLOPT_NOSIGNAL                  := 99    ; 99  + CURLOPTTYPE_LONG
    CURLOPT_SHARE                     := 10100 ; 100 + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_PROXYTYPE                 := 101   ; 101 + CURLOPTTYPE_LONG
    CURLOPT_ENCODING                  := 10102 ; 102 + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_PRIVATE                   := 10103 ; 103 + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_HTTP200ALIASES            := 10104 ; 104 + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_UNRESTRICTED_AUTH         := 105   ; 105 + CURLOPTTYPE_LONG
    CURLOPT_FTP_USE_EPRT              := 106   ; 106 + CURLOPTTYPE_LONG
    CURLOPT_HTTPAUTH                  := 107   ; 107 + CURLOPTTYPE_LONG
    CURLOPT_SSL_CTX_FUNCTION          := 20108 ; 108 + CURLOPTTYPE_FUNCTIONPOINT
    CURLOPT_SSL_CTX_DATA              := 10109 ; 109 + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_FTP_CREATE_MISSING_DIRS   := 110   ; 110 + CURLOPTTYPE_LONG
    CURLOPT_PROXYAUTH                 := 111   ; 111 + CURLOPTTYPE_LONG
    CURLOPT_FTP_RESPONSE_TIMEOUT      := 112   ; 112 + CURLOPTTYPE_LONG
    CURLOPT_IPRESOLVE                 := 113   ; 113 + CURLOPTTYPE_LONG
    CURLOPT_MAXFILESIZE               := 114   ; 114 + CURLOPTTYPE_LONG
    CURLOPT_INFILESIZE_LARGE          := 30115 ; 115 + CURLOPTTYPE_OFF_T
    CURLOPT_RESUME_FROM_LARGE         := 30116 ; 116 + CURLOPTTYPE_OFF_T
    CURLOPT_MAXFILESIZE_LARGE         := 30117 ; 117 + CURLOPTTYPE_OFF_T
    CURLOPT_NETRC_FILE                := 10118 ; 118 + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_USE_SSL                   := 119   ; 119 + CURLOPTTYPE_LONG
    CURLOPT_POSTFIELDSIZE_LARGE       := 30120 ; 120 + CURLOPTTYPE_OFF_T
    CURLOPT_TCP_NODELAY               := 121   ; 121 + CURLOPTTYPE_LONG
    CURLOPT_FTPSSLAUTH                := 129   ; 129 + CURLOPTTYPE_LONG
    CURLOPT_IOCTLFUNCTION             := 20130 ; 130 + CURLOPTTYPE_FUNCTIONPOINT
    CURLOPT_IOCTLDATA                 := 10131 ; 131 + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_FTP_ACCOUNT               := 10134 ; 134 + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_COOKIELIST                := 10135 ; 135 + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_IGNORE_CONTENT_LENGTH     := 136   ; 136 + CURLOPTTYPE_LONG
    CURLOPT_FTP_SKIP_PASV_IP          := 137   ; 137 + CURLOPTTYPE_LONG
    CURLOPT_FTP_FILEMETHOD            := 138   ; 138 + CURLOPTTYPE_LONG
    CURLOPT_LOCALPORT                 := 139   ; 139 + CURLOPTTYPE_LONG
    CURLOPT_LOCALPORTRANGE            := 140   ; 140 + CURLOPTTYPE_LONG
    CURLOPT_CONNECT_ONLY              := 141   ; 141 + CURLOPTTYPE_LONG
    CURLOPT_CONV_FROM_NETWORK_FUNCTION:= 20142 ; 142 + CURLOPTTYPE_FUNCTIONPOINT
    CURLOPT_CONV_TO_NETWORK_FUNCTION  := 20143 ; 143 + CURLOPTTYPE_FUNCTIONPOINT
    CURLOPT_CONV_FROM_UTF8_FUNCTION   := 20144 ; 144 + CURLOPTTYPE_FUNCTIONPOINT
    CURLOPT_MAX_SEND_SPEED_LARGE      := 30145 ; 145 + CURLOPTTYPE_OFF_T
    CURLOPT_MAX_RECV_SPEED_LARGE      := 30146 ; 146 + CURLOPTTYPE_OFF_T
    CURLOPT_FTP_ALTERNATIVE_TO_USER   := 10147 ; 147 + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_SOCKOPTFUNCTION           := 20148 ; 148 + CURLOPTTYPE_FUNCTIONPOINT
    CURLOPT_SOCKOPTDATA               := 10149 ; 149 + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_SSL_SESSIONID_CACHE       := 150   ; 150 + CURLOPTTYPE_LONG
    CURLOPT_SSH_AUTH_TYPES            := 151   ; 151 + CURLOPTTYPE_LONG
    CURLOPT_SSH_PUBLIC_KEYFILE        := 10152 ; 152 + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_SSH_PRIVATE_KEYFILE       := 10153 ; 153 + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_FTP_SSL_CCC               := 154   ; 154 + CURLOPTTYPE_LONG
    CURLOPT_TIMEOUT_MS                := 155   ; 155 + CURLOPTTYPE_LONG
    CURLOPT_CONNECTTIMEOUT_MS         := 156   ; 156 + CURLOPTTYPE_LONG
    CURLOPT_HTTP_TRANSFER_DECODING    := 157   ; 157 + CURLOPTTYPE_LONG
    CURLOPT_HTTP_CONTENT_DECODING     := 158   ; 158 + CURLOPTTYPE_LONG
    CURLOPT_NEW_FILE_PERMS            := 159   ; 159 + CURLOPTTYPE_LONG
    CURLOPT_NEW_DIRECTORY_PERMS       := 160   ; 160 + CURLOPTTYPE_LONG
    CURLOPT_POST301                   := 161   ; 161 + CURLOPTTYPE_LONG
    CURLOPT_SSH_HOST_PUBLIC_KEY_MD5   := 10162 ; 162 + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_OPENSOCKETFUNCTION        := 20163 ; 163 + CURLOPTTYPE_FUNCTIONPOINT
    CURLOPT_OPENSOCKETDATA            := 10164 ; 164 + CURLOPTTYPE_OBJECTPOINT
    CURLOPT_COPYPOSTFIELDS            := 10165 ; 165 + CURLOPTTYPE_OBJECTPOINT
    
    ; ************[CURLINFO]************
    CURLINFO_STRING                   := 0x100000
    CURLINFO_LONG                     := 0x200000
    CURLINFO_DOUBLE                   := 0x300000
    CURLINFO_SLIST                    := 0x400000

    CURLINFO_EFFECTIVE_URL            := 1048577 ; CURLINFO_STRING + 1
    CURLINFO_RESPONSE_CODE            := 2097154 ; CURLINFO_LONG   + 2
    CURLINFO_TOTAL_TIME               := 3145731 ; CURLINFO_DOUBLE + 3
    CURLINFO_NAMELOOKUP_TIME          := 3145732 ; CURLINFO_DOUBLE + 4
    CURLINFO_CONNECT_TIME             := 3145733 ; CURLINFO_DOUBLE + 5
    CURLINFO_PRETRANSFER_TIME         := 3145734 ; CURLINFO_DOUBLE + 6
    CURLINFO_SIZE_UPLOAD              := 3145735 ; CURLINFO_DOUBLE + 7
    CURLINFO_SIZE_DOWNLOAD            := 3145736 ; CURLINFO_DOUBLE + 8
    CURLINFO_SPEED_DOWNLOAD           := 3145737 ; CURLINFO_DOUBLE + 9
    CURLINFO_SPEED_UPLOAD             := 3145738 ; CURLINFO_DOUBLE + 10
    CURLINFO_HEADER_SIZE              := 2097163 ; CURLINFO_LONG  + 11
    CURLINFO_REQUEST_SIZE             := 2097164 ; CURLINFO_LONG  + 12
    CURLINFO_SSL_VERIFYRESULT         := 2097165 ; CURLINFO_LONG  + 13
    CURLINFO_FILETIME                 := 2097166 ; CURLINFO_LONG  + 14
    CURLINFO_CONTENT_LENGTH_DOWNLOAD  := 3145743 ; CURLINFO_DOUBLE + 15
    CURLINFO_CONTENT_LENGTH_UPLOAD    := 3145744 ; CURLINFO_DOUBLE + 16
    CURLINFO_STARTTRANSFER_TIME       := 3145745 ; CURLINFO_DOUBLE + 17
    CURLINFO_CONTENT_TYPE             := 1048594 ; CURLINFO_STRING + 18
    CURLINFO_REDIRECT_TIME            := 3145747 ; CURLINFO_DOUBLE + 19
    CURLINFO_REDIRECT_COUNT           := 2097172 ; CURLINFO_LONG   + 20
    CURLINFO_PRIVATE                  := 1048597 ; CURLINFO_STRING + 21
    CURLINFO_HTTP_CONNECTCODE         := 2097174 ; CURLINFO_LONG   + 22
    CURLINFO_HTTPAUTH_AVAIL           := 2097175 ; CURLINFO_LONG   + 23
    CURLINFO_PROXYAUTH_AVAIL          := 2097176 ; CURLINFO_LONG   + 24
    CURLINFO_OS_ERRNO                 := 2097177 ; CURLINFO_LONG   + 25
    CURLINFO_NUM_CONNECTS             := 2097178 ; CURLINFO_LONG   + 26
    CURLINFO_SSL_ENGINES              := 4194331 ; CURLINFO_SLIST  + 27
    CURLINFO_COOKIELIST               := 4194332 ; CURLINFO_SLIST  + 28
    CURLINFO_LASTSOCKET               := 2097181 ; CURLINFO_LONG   + 29
    CURLINFO_FTP_ENTRY_PATH           := 1048606 ; CURLINFO_STRING + 30
    
    ; ************[CURLPAUSE]***********
    CURLPAUSE_RECV                    := 1
    CURLPAUSE_SEND                    := 3
    CURLPAUSE_ALL                     := 4
    CURLPAUSE_CONT                    := 0
    
    ; ************[CURLE]***************
    CURLE_OK                          := 0
    CURLE_UNSUPPORTED_PROTOCOL        := 1
    CURLE_FAILED_INIT                 := 2
    CURLE_URL_MALFORMAT               := 3
    CURLE_OBSOLETE4                   := 4       ; NOT USED
    CURLE_COULDNT_RESOLVE_PROXY       := 5
    CURLE_COULDNT_RESOLVE_HOST        := 6
    CURLE_COULDNT_CONNECT             := 7
    CURLE_FTP_WEIRD_SERVER_REPLY      := 8
    CURLE_REMOTE_ACCESS_DENIED        := 9       
    /*
     * A service was denied by the server
     * due to lack of access - when login fails
     * this is not returned.
     */
    CURLE_OBSOLETE10                  := 10      ; NOT USED
    CURLE_FTP_WEIRD_PASS_REPLY        := 11
    CURLE_OBSOLETE12                  := 12      ; NOT USED
    CURLE_FTP_WEIRD_PASV_REPLY        := 13
    CURLE_FTP_WEIRD_227_FORMAT        := 14
    CURLE_FTP_CANT_GET_HOST           := 15
    CURLE_OBSOLETE16                  := 16      ; NOT USED
    CURLE_FTP_COULDNT_SET_TYPE        := 17
    CURLE_PARTIAL_FILE                := 18
    CURLE_FTP_COULDNT_RETR_FILE       := 19
    CURLE_OBSOLETE20                  := 20      ; NOT USED
    CURLE_QUOTE_ERROR                 := 21      ; quote command failure
    CURLE_HTTP_RETURNED_ERROR         := 22
    CURLE_WRITE_ERROR                 := 23
    CURLE_OBSOLETE24                  := 24      ; NOT USED
    CURLE_UPLOAD_FAILED               := 25      ; failed upload "command"
    CURLE_READ_ERROR                  := 26      ; couldn't open/read from file
    CURLE_OUT_OF_MEMORY               := 27
    /* 
    Note: CURLE_OUT_OF_MEMORY may 
    sometimes indicate a conversion error
    instead of a memory allocation error 
    if CURL_DOES_CONVERSIONS is defined
    */
    CURLE_OPERATION_TIMEDOUT          := 28      ; the timeout time was reached
    CURLE_OBSOLETE29                  := 29      ; NOT USED
    CURLE_FTP_PORT_FAILED             := 30      ; FTP PORT operation failed
    CURLE_FTP_COULDNT_USE_REST        := 31      ; the REST command failed 
    CURLE_OBSOLETE32                  := 32      ; NOT USED 
    CURLE_RANGE_ERROR                 := 33      ; RANGE "command" didn't work 
    CURLE_HTTP_POST_ERROR             := 34 
    CURLE_SSL_CONNECT_ERROR           := 35      ; wrong when connecting with SSL 
    CURLE_BAD_DOWNLOAD_RESUME         := 36      ; couldn't resume download 
    CURLE_FILE_COULDNT_READ_FILE      := 37 
    CURLE_LDAP_CANNOT_BIND            := 38 
    CURLE_LDAP_SEARCH_FAILED          := 39 
    CURLE_OBSOLETE40                  := 40      ; NOT USED 
    CURLE_FUNCTION_NOT_FOUND          := 41 
    CURLE_ABORTED_BY_CALLBACK         := 42 
    CURLE_BAD_FUNCTION_ARGUMENT       := 43 
    CURLE_OBSOLETE44                  := 44      ; NOT USED 
    CURLE_INTERFACE_FAILED            := 45      ; CURLOPT_INTERFACE failed 
    CURLE_OBSOLETE46                  := 46      ; NOT USED 
    CURLE_TOO_MANY_REDIRECTS          := 47      ; catch endless redirect loops 
    CURLE_UNKNOWN_TELNET_OPTION       := 48      ; User specified an unknown option 
    CURLE_TELNET_OPTION_SYNTAX        := 49      ; Malformed telnet option 
    CURLE_OBSOLETE50                  := 50      ; NOT USED 
    CURLE_PEER_FAILED_VERIFICATION    := 51      ; peer's certificate or fingerprint wasn't verified correctly
    CURLE_GOT_NOTHING                 := 52      ; when this is a specific error 
    CURLE_SSL_ENGINE_NOTFOUND         := 53      ; SSL crypto engine not found 
    CURLE_SSL_ENGINE_SETFAILED        := 54      ; can not set SSL crypto engine as
                                                 ; default 
    CURLE_SEND_ERROR                  := 55      ; failed sending network data 
    CURLE_RECV_ERROR                  := 56      ; failure in receiving network data 
    CURLE_OBSOLETE57                  := 57      ; NOT IN USE 
    CURLE_SSL_CERTPROBLEM             := 58      ; problem with the local certificate 
    CURLE_SSL_CIPHER                  := 59      ; couldn't use specified cipher 
    CURLE_SSL_CACERT                  := 60      ; problem with the CA cert (path?) 
    CURLE_BAD_CONTENT_ENCODING        := 61      ; Unrecognized transfer encoding 
    CURLE_LDAP_INVALID_URL            := 62      ; Invalid LDAP URL 
    CURLE_FILESIZE_EXCEEDED           := 63      ; Maximum file size exceeded 
    CURLE_USE_SSL_FAILED              := 64      ; Requested FTP SSL level failed 
    CURLE_SEND_FAIL_REWIND            := 65      ; Sending the data requires a rewind
                                                 ; that failed 
    CURLE_SSL_ENGINE_INITFAILED       := 66      ; failed to initialise ENGINE 
    CURLE_LOGIN_DENIED                := 67      ; user, password or similar was not
                                                 ; accepted and we failed to login 
    CURLE_TFTP_NOTFOUND               := 68      ; file not found on server 
    CURLE_TFTP_PERM                   := 69      ; permission problem on server 
    CURLE_REMOTE_DISK_FULL            := 70      ; out of disk space on server 
    CURLE_TFTP_ILLEGAL                := 71      ; Illegal TFTP operation 
    CURLE_TFTP_UNKNOWNID              := 72      ; Unknown transfer ID 
    CURLE_REMOTE_FILE_EXISTS          := 73      ; File already exists 
    CURLE_TFTP_NOSUCHUSER             := 74      ; No such user 
    CURLE_CONV_FAILED                 := 75      ; conversion failed 
    CURLE_CONV_REQD                   := 76      
    /*
    * caller must register conversion
    * callbacks using curl_easy_setopt options
    * CURLOPT_CONV_FROM_NETWORK_FUNCTION,
    * CURLOPT_CONV_TO_NETWORK_FUNCTION, and
    * CURLOPT_CONV_FROM_UTF8_FUNCTION
    */                                                 
    CURLE_SSL_CACERT_BADFILE          := 77      ; could not load CACERT file, missing or wrong format 
    CURLE_REMOTE_FILE_NOT_FOUND       := 78      ; remote file not found 
    CURLE_SSH                         := 79      
    /*
    * error from the SSH layer, somewhat
    * generic so the error message will be of
    * interest when this has happened 
    */

    CURLE_SSL_SHUTDOWN_FAILED         := 80      ; Failed to shut down the SSL connection 
    CURLE_AGAIN                       := 81      
    /*
    * socket is not ready for send/recv,
    * wait till it's ready and try again (Added
    * in 7.18.2) 
    */
    CURLE_SSL_CRL_BADFILE             := 82 
    /*    
    * could not load CRL file, 
    * missing or wrong format (Added in 7.19.0)
    */
    CURLE_SSL_ISSUER_ERROR            := 83      ; Issuer check failed.  (Added in 7.19.0) 
    CURLE_FTP_PRET_FAILED             := 84      ; a PRET command failed 
    CURLE_RTSP_CSEQ_ERROR             := 85      ; mismatch of RTSP CSeq numbers 
    CURLE_RTSP_SESSION_ERROR          := 86      ; mismatch of RTSP Session Identifiers 
    CURLE_FTP_BAD_FILE_LIST           := 87      ; unable to parse FTP file list 
    CURLE_CHUNK_FAILED                := 88      ; chunk callback reported error 
	   
	return CURLE_OK := DllCall("libcurl\curl_global_init", UInt, flags)
}
curl_global_cleanup(){                          ; curl_global_cleanup(void)
    
    global
    
    ; http://curl.haxx.se/libcurl/c/curl_global_cleanup.html
    
    /*
     * NAME curl_global_cleanup()
     * <curl/curl.h>
     *
     * DESCRIPTION
     *
     * curl_global_cleanup() should be invoked exactly once for each application
     * that uses libcurl
     *
     * PARAMETERS
     * NONE
     * 
     * RETURN VALUE
     * NONE
     */
    
    ; Clearing constants
    CURL_ERROR_SIZE                   :=

    ; ************[CURL_VERSION]********
    CURL_VERSION_IPV6                 :=
    CURL_VERSION_KERBEROS4            :=
    CURL_VERSION_SSL                  :=
    CURL_VERSION_LIBZ                 :=
    CURL_VERSION_NTLM                 :=
    CURL_VERSION_GSSNEGOTIATE         :=
    CURL_VERSION_DEBUG                :=
    CURL_VERSION_ASYNCHDNS            :=
    CURL_VERSION_SPNEGO               :=
    CURL_VERSION_LARGEFILE            :=
    CURL_VERSION_IDN                  :=
    CURL_VERSION_SSPI                 :=
    CURL_VERSION_CONV                 :=
    CURL_VERSION_CURLDEBUG            :=

    ; ************[CURLFORM]************
    CURLFORM_COPYNAME                 :=
    CURLFORM_PTRNAME                  :=
    CURLFORM_NAMELENGTH               :=
    CURLFORM_COPYCONTENTS             :=
    CURLFORM_PTRCONTENTS              :=
    CURLFORM_CONTENTSLENGTH           :=
    CURLFORM_FILECONTENT              :=
    CURLFORM_ARRAY                    :=
    CURLFORM_FILE                     :=
    CURLFORM_BUFFER                   :=
    CURLFORM_BUFFERPTR                :=
    CURLFORM_BUFFERLENGTH             :=
    CURLFORM_CONTENTTYPE              :=
    CURLFORM_CONTENTHEADER            :=
    CURLFORM_FILENAME                 :=
    CURLFORM_END                      :=

    ; ************[CURLOPT]************
    CURLOPTTYPE_LONG                  :=
    CURLOPTTYPE_OBJECTPOINT           :=
    CURLOPTTYPE_FUNCTIONPOINT         :=
    CURLOPTTYPE_OFF_T                 :=
    
    CURLOPT_FILE                      :=
    CURLOPT_URL                       :=
    CURLOPT_PORT                      :=
    CURLOPT_PROXY                     :=
    CURLOPT_USERPWD                   :=
    CURLOPT_PROXYUSERPWD              :=
    CURLOPT_RANGE                     :=
    CURLOPT_INFILE                    :=
    CURLOPT_ERRORBUFFER               :=
    CURLOPT_WRITEFUNCTION             :=
    CURLOPT_READFUNCTION              :=
    CURLOPT_TIMEOUT                   :=
    CURLOPT_INFILESIZE                :=
    CURLOPT_POSTFIELDS                :=
    CURLOPT_REFERER                   :=
    CURLOPT_FTPPORT                   :=
    CURLOPT_USERAGENT                 :=
    CURLOPT_LOW_SPEED_LIMIT           :=
    CURLOPT_LOW_SPEED_TIME            :=
    CURLOPT_RESUME_FROM               :=
    CURLOPT_COOKIE                    :=
    CURLOPT_HTTPHEADER                :=
    CURLOPT_HTTPPOST                  :=
    CURLOPT_SSLCERT                   :=
    CURLOPT_KEYPASSWD                 :=
    CURLOPT_CRLF                      :=
    CURLOPT_QUOTE                     :=
    CURLOPT_WRITEHEADER               :=
    CURLOPT_COOKIEFILE                :=
    CURLOPT_SSLVERSION                :=
    CURLOPT_TIMECONDITION             :=
    CURLOPT_TIMEVALUE                 :=
    CURLOPT_CUSTOMREQUEST             :=
    CURLOPT_STDERR                    :=
    CURLOPT_POSTQUOTE                 :=
    CURLOPT_WRITEINFO                 :=
    CURLOPT_VERBOSE                   :=
    CURLOPT_HEADER                    :=
    CURLOPT_NOPROGRESS                :=
    CURLOPT_NOBODY                    :=
    CURLOPT_FAILONERROR               :=
    CURLOPT_UPLOAD                    :=
    CURLOPT_POST                      :=
    CURLOPT_DIRLISTONLY               :=
    CURLOPT_APPEND                    :=
    CURLOPT_NETRC                     :=
    CURLOPT_FOLLOWLOCATION            :=
    CURLOPT_TRANSFERTEXT              :=
    CURLOPT_PUT                       :=
    CURLOPT_PROGRESSFUNCTION          :=
    CURLOPT_PROGRESSDATA              :=
    CURLOPT_AUTOREFERER               :=
    CURLOPT_PROXYPORT                 :=
    CURLOPT_POSTFIELDSIZE             :=
    CURLOPT_HTTPPROXYTUNNEL           :=
    CURLOPT_INTERFACE                 :=
    CURLOPT_KRBLEVEL                  :=
    CURLOPT_SSL_VERIFYPEER            :=
    CURLOPT_CAINFO                    :=
    CURLOPT_MAXREDIRS                 :=
    CURLOPT_FILETIME                  :=
    CURLOPT_TELNETOPTIONS             :=
    CURLOPT_MAXCONNECTS               :=
    CURLOPT_CLOSEPOLICY               :=
    CURLOPT_FRESH_CONNECT             :=
    CURLOPT_FORBID_REUSE              :=
    CURLOPT_RANDOM_FILE               :=
    CURLOPT_EGDSOCKET                 :=
    CURLOPT_CONNECTTIMEOUT            :=
    CURLOPT_HEADERFUNCTION            :=
    CURLOPT_HTTPGET                   :=
    CURLOPT_SSL_VERIFYHOST            :=
    CURLOPT_COOKIEJAR                 :=
    CURLOPT_SSL_CIPHER_LIST           :=
    CURLOPT_HTTP_VERSION              :=
    CURLOPT_FTP_USE_EPSV              :=
    CURLOPT_SSLCERTTYPE               :=
    CURLOPT_SSLKEY                    :=
    CURLOPT_SSLKEYTYPE                :=
    CURLOPT_SSLENGINE                 :=
    CURLOPT_SSLENGINE_DEFAULT         :=
    CURLOPT_DNS_USE_GLOBAL_CACHE      :=
    CURLOPT_DNS_CACHE_TIMEOUT         :=
    CURLOPT_PREQUOTE                  :=
    CURLOPT_DEBUGFUNCTION             :=
    CURLOPT_DEBUGDATA                 :=
    CURLOPT_COOKIESESSION             :=
    CURLOPT_CAPATH                    :=
    CURLOPT_BUFFERSIZE                :=
    CURLOPT_NOSIGNAL                  :=
    CURLOPT_SHARE                     :=
    CURLOPT_PROXYTYPE                 :=
    CURLOPT_ENCODING                  :=
    CURLOPT_PRIVATE                   :=
    CURLOPT_HTTP200ALIASES            :=
    CURLOPT_UNRESTRICTED_AUTH         :=
    CURLOPT_FTP_USE_EPRT              :=
    CURLOPT_HTTPAUTH                  :=
    CURLOPT_SSL_CTX_FUNCTION          :=
    CURLOPT_SSL_CTX_DATA              :=
    CURLOPT_FTP_CREATE_MISSING_DIRS   :=
    CURLOPT_PROXYAUTH                 :=
    CURLOPT_FTP_RESPONSE_TIMEOUT      :=
    CURLOPT_IPRESOLVE                 :=
    CURLOPT_MAXFILESIZE               :=
    CURLOPT_INFILESIZE_LARGE          :=
    CURLOPT_RESUME_FROM_LARGE         :=
    CURLOPT_MAXFILESIZE_LARGE         :=
    CURLOPT_NETRC_FILE                :=
    CURLOPT_USE_SSL                   :=
    CURLOPT_POSTFIELDSIZE_LARGE       :=
    CURLOPT_TCP_NODELAY               :=
    CURLOPT_FTPSSLAUTH                :=
    CURLOPT_IOCTLFUNCTION             :=
    CURLOPT_IOCTLDATA                 :=
    CURLOPT_FTP_ACCOUNT               :=
    CURLOPT_COOKIELIST                :=
    CURLOPT_IGNORE_CONTENT_LENGTH     :=
    CURLOPT_FTP_SKIP_PASV_IP          :=
    CURLOPT_FTP_FILEMETHOD            :=
    CURLOPT_LOCALPORT                 :=
    CURLOPT_LOCALPORTRANGE            :=
    CURLOPT_CONNECT_ONLY              :=
    CURLOPT_CONV_FROM_NETWORK_FUNCTION:=
    CURLOPT_CONV_TO_NETWORK_FUNCTION  :=
    CURLOPT_CONV_FROM_UTF8_FUNCTION   :=
    CURLOPT_MAX_SEND_SPEED_LARGE      :=
    CURLOPT_MAX_RECV_SPEED_LARGE      :=
    CURLOPT_FTP_ALTERNATIVE_TO_USER   :=
    CURLOPT_SOCKOPTFUNCTION           :=
    CURLOPT_SOCKOPTDATA               :=
    CURLOPT_SSL_SESSIONID_CACHE       :=
    CURLOPT_SSH_AUTH_TYPES            :=
    CURLOPT_SSH_PUBLIC_KEYFILE        :=
    CURLOPT_SSH_PRIVATE_KEYFILE       :=
    CURLOPT_FTP_SSL_CCC               :=
    CURLOPT_TIMEOUT_MS                :=
    CURLOPT_CONNECTTIMEOUT_MS         :=
    CURLOPT_HTTP_TRANSFER_DECODING    :=
    CURLOPT_HTTP_CONTENT_DECODING     :=
    CURLOPT_NEW_FILE_PERMS            :=
    CURLOPT_NEW_DIRECTORY_PERMS       :=
    CURLOPT_POST301                   :=
    CURLOPT_SSH_HOST_PUBLIC_KEY_MD5   :=
    CURLOPT_OPENSOCKETFUNCTION        :=
    CURLOPT_OPENSOCKETDATA            :=
    CURLOPT_COPYPOSTFIELDS            :=
    
    ; ************[CURLINFO]************
    CURLINFO_STRING                   :=
    CURLINFO_LONG                     :=
    CURLINFO_DOUBLE                   :=
    CURLINFO_SLIST                    :=

    CURLINFO_EFFECTIVE_URL            :=
    CURLINFO_RESPONSE_CODE            :=
    CURLINFO_TOTAL_TIME               :=
    CURLINFO_NAMELOOKUP_TIME          :=
    CURLINFO_CONNECT_TIME             :=
    CURLINFO_PRETRANSFER_TIME         :=
    CURLINFO_SIZE_UPLOAD              :=
    CURLINFO_SIZE_DOWNLOAD            :=
    CURLINFO_SPEED_DOWNLOAD           :=
    CURLINFO_SPEED_UPLOAD             :=
    CURLINFO_HEADER_SIZE              :=
    CURLINFO_REQUEST_SIZE             :=
    CURLINFO_SSL_VERIFYRESULT         :=
    CURLINFO_FILETIME                 :=
    CURLINFO_CONTENT_LENGTH_DOWNLOAD  :=
    CURLINFO_CONTENT_LENGTH_UPLOAD    :=
    CURLINFO_STARTTRANSFER_TIME       :=
    CURLINFO_CONTENT_TYPE             :=
    CURLINFO_REDIRECT_TIME            :=
    CURLINFO_REDIRECT_COUNT           :=
    CURLINFO_PRIVATE                  :=
    CURLINFO_HTTP_CONNECTCODE         :=
    CURLINFO_HTTPAUTH_AVAIL           :=
    CURLINFO_PROXYAUTH_AVAIL          :=
    CURLINFO_OS_ERRNO                 :=
    CURLINFO_NUM_CONNECTS             :=
    CURLINFO_SSL_ENGINES              :=
    CURLINFO_COOKIELIST               :=
    CURLINFO_LASTSOCKET               :=
    CURLINFO_FTP_ENTRY_PATH           :=
    
    ; ************[CURLPAUSE]***********
    CURLPAUSE_RECV                    :=
    CURLPAUSE_SEND                    :=
    CURLPAUSE_ALL                     :=
    CURLPAUSE_CONT                    :=
    
    ; ************[CURLE]***************
    CURLE_OK                          :=
    CURLE_UNSUPPORTED_PROTOCOL        :=
    CURLE_FAILED_INIT                 :=
    CURLE_URL_MALFORMAT               :=
    CURLE_OBSOLETE4                   :=
    CURLE_COULDNT_RESOLVE_PROXY       :=
    CURLE_COULDNT_RESOLVE_HOST        :=
    CURLE_COULDNT_CONNECT             :=
    CURLE_FTP_WEIRD_SERVER_REPLY      :=
    CURLE_REMOTE_ACCESS_DENIED        :=
    CURLE_OBSOLETE10                  :=
    CURLE_FTP_WEIRD_PASS_REPLY        :=
    CURLE_OBSOLETE12                  :=
    CURLE_FTP_WEIRD_PASV_REPLY        :=
    CURLE_FTP_WEIRD_227_FORMAT        :=
    CURLE_FTP_CANT_GET_HOST           :=
    CURLE_OBSOLETE16                  :=
    CURLE_FTP_COULDNT_SET_TYPE        :=
    CURLE_PARTIAL_FILE                :=
    CURLE_FTP_COULDNT_RETR_FILE       :=
    CURLE_OBSOLETE20                  :=
    CURLE_QUOTE_ERROR                 :=
    CURLE_HTTP_RETURNED_ERROR         :=
    CURLE_WRITE_ERROR                 :=
    CURLE_OBSOLETE24                  :=
    CURLE_UPLOAD_FAILED               :=
    CURLE_READ_ERROR                  :=
    CURLE_OUT_OF_MEMORY               :=
    CURLE_OPERATION_TIMEDOUT          :=
    CURLE_OBSOLETE29                  :=
    CURLE_FTP_PORT_FAILED             :=
    CURLE_FTP_COULDNT_USE_REST        :=
    CURLE_OBSOLETE32                  :=
    CURLE_RANGE_ERROR                 :=
    CURLE_HTTP_POST_ERROR             :=
    CURLE_SSL_CONNECT_ERROR           :=
    CURLE_BAD_DOWNLOAD_RESUME         :=
    CURLE_FILE_COULDNT_READ_FILE      :=
    CURLE_LDAP_CANNOT_BIND            :=
    CURLE_LDAP_SEARCH_FAILED          :=
    CURLE_OBSOLETE40                  :=
    CURLE_FUNCTION_NOT_FOUND          :=
    CURLE_ABORTED_BY_CALLBACK         :=
    CURLE_BAD_FUNCTION_ARGUMENT       :=
    CURLE_OBSOLETE44                  :=
    CURLE_INTERFACE_FAILED            :=
    CURLE_OBSOLETE46                  :=
    CURLE_TOO_MANY_REDIRECTS          :=
    CURLE_UNKNOWN_TELNET_OPTION       :=
    CURLE_TELNET_OPTION_SYNTAX        :=
    CURLE_OBSOLETE50                  :=
    CURLE_PEER_FAILED_VERIFICATION    :=
    CURLE_GOT_NOTHING                 :=
    CURLE_SSL_ENGINE_NOTFOUND         :=
    CURLE_SSL_ENGINE_SETFAILED        :=
    CURLE_SEND_ERROR                  :=
    CURLE_RECV_ERROR                  :=
    CURLE_OBSOLETE57                  :=
    CURLE_SSL_CERTPROBLEM             :=
    CURLE_SSL_CIPHER                  :=
    CURLE_SSL_CACERT                  :=
    CURLE_BAD_CONTENT_ENCODING        :=
    CURLE_LDAP_INVALID_URL            :=
    CURLE_FILESIZE_EXCEEDED           :=
    CURLE_USE_SSL_FAILED              :=
    CURLE_SEND_FAIL_REWIND            :=
    CURLE_SSL_ENGINE_INITFAILED       :=
    CURLE_LOGIN_DENIED                :=
    CURLE_TFTP_NOTFOUND               :=
    CURLE_TFTP_PERM                   :=
    CURLE_REMOTE_DISK_FULL            :=
    CURLE_TFTP_ILLEGAL                :=
    CURLE_TFTP_UNKNOWNID              :=
    CURLE_REMOTE_FILE_EXISTS          :=
    CURLE_TFTP_NOSUCHUSER             :=
    CURLE_CONV_FAILED                 :=
    CURLE_CONV_REQD                   :=                                              
    CURLE_SSL_CACERT_BADFILE          :=
    CURLE_REMOTE_FILE_NOT_FOUND       :=
    CURLE_SSH                         :=
    CURLE_SSL_SHUTDOWN_FAILED         :=
    CURLE_AGAIN                       :=
    CURLE_SSL_CRL_BADFILE             :=
    CURLE_SSL_ISSUER_ERROR            :=
    CURLE_FTP_PRET_FAILED             :=
    CURLE_RTSP_CSEQ_ERROR             :=
    CURLE_RTSP_SESSION_ERROR          :=
    CURLE_FTP_BAD_FILE_LIST           :=
    CURLE_CHUNK_FAILED                :=
    
    FileDelete, %a_temp%\stdout                 ; delete temporary file created by the ahk_debug function
    DllCall( "FreeLibrary", UInt, hCurlModule ) ; Unload Library
    return DllCall("libcurl\curl_global_cleanup")
}
curl_easy_init(){                               ; curl_easy_init()
    
    global
    
    ; http://curl.haxx.se/libcurl/c/curl_easy_init.html
    
    /*
     * NAME curl_easy_init()
     * <curl\easy.h>
     *
     * DESCRIPTION
     *
     * This function must be the first function to call, and it returns a CURL easy handle that you must use as 
     * input to other easy-functions. curl_easy_init initializes curl and this call MUST have a corresponding call 
     * to curl_easy_cleanup() when the operation is complete. 
     *
     * PARAMETERS
     * NONE
     *    
     * RETURN VALUE
     * Returns a CURL easy handle that you must use as input to other easy-functions.
     * If this function returns NULL, something went wrong and you cannot use the other curl functions.
     */

    return handle := DllCall("libcurl\curl_easy_init")
}
curl_easy_cleanup(handle){                      ; curl_easy_cleanup(CURL *handle)
    
    global 
    
    ; http://curl.haxx.se/libcurl/c/curl_easy_cleanup.html
    
    /*
     * NAME curl_easy_cleanup()
     * <curl\easy.h>
     *
     * DESCRIPTION
     *
     * This function must be the last function to call for an easy session. It is the opposite of the 
     * curl_easy_init() function and must be called with the same handle as input that the curl_easy_init call 
     * returned.
     *
     * PARAMETERS (CURL *handle)
     * handle
     * 
     * RETURN VALUE
     * NONE
     */
    
    if (dbfhnd)
        CloseFile(dbfhnd) ; close handle created to be used by the ahk_debug function
    return DllCall("libcurl\curl_easy_cleanup", UInt, handle)
}
curl_easy_setopt(handle, option, parameter){    ; curl_easy_setopt(CURL *handle, CURLOPT option, ...)
    
    ; http://curl.haxx.se/libcurl/c/curl_easy_setopt.html
    
    /*
     * NAME curl_easy_setopt()
     * <curl\easy.h>
     *
     * DESCRIPTION
     *
     * curl_easy_setopt() is used to tell libcurl how to behave. By using the appropriate options to 
     * curl_easy_setopt, you can change libcurl's behavior. All options are set with the option followed by a 
     * parameter. That parameter can be a long, a function pointer, an object pointer or a curl_off_t, depending 
     * on what the specific option expects. Read this manual carefully as bad input values may cause libcurl to 
     * behave badly! You can only set one option in each function call. A typical application uses many 
     * curl_easy_setopt() calls in the setup phase. 
     *
     * PARAMETERS (CURL *handle,CURLOPT, ...)
     * handle
     * CURLOPT
     * parameter
     * 
     * See URL above for a list of options and parameters.
     * 
     * RETURN VALUE
     * CURLE_OK (zero) means that the option was set properly, non-zero means an error occurred as <curl/curl.h> 
     * defines. See the libcurl-errors man page for the full list with descriptions.
     * 
     * If you try to set an option that libcurl doesn't know about, perhaps because the library is too old to 
     * support it or the option was removed in a recent version, this function will return CURLE_FAILED_INIT (2).
     */
    
    word := parameter                           ; this fixes a memory corruption problem with the dll call below.
    if parameter is integer
		return CURLE_OK := DllCall("libcurl\curl_easy_setopt", UInt, handle, UInt, option, UInt, parameter)
	else
		return CURLE_OK := DllCall("libcurl\curl_easy_setopt", UInt, handle, UInt, option, Str, word)
}
curl_easy_perform(handle){                      ; curl_easy_perform(CURL *handle)

    ; http://curl.haxx.se/libcurl/c/curl_easy_perform.html
    
    /*
     * NAME curl_easy_perform()
     * <curl\easy.h>
     *
     * DESCRIPTION
     *
     * This function is called after the init and all the curl_easy_setopt() calls are made, and will perform 
     * the transfer as described in the options. It must be called with the same handle as input as the     
     * curl_easy_init call returned. 
     *
     * PARAMETERS (CURL *handle)
     * handle
     * 
     * RETURN VALUE
     * CURLE_OK(zero) means everything was ok, non-zero means an error occurred as <curl/curl.h> defines. If the 
     * CURLOPT_ERRORBUFFER was set with curl_easy_setopt there will be a readable error message in the error buffer 
     * when non-zero is returned.
     */
    
    return CURLE_OK := DllCall("libcurl\curl_easy_perform", UInt, handle)
}
curl_easy_getinfo(handle, info, Byref val){     ; curl_easy_getinfo(CURL *handle, CURLINFO info, ... )

    global
    
    ; http://curl.haxx.se/libcurl/c/curl_easy_getinfo.html
    
    /*
     * NAME curl_easy_getinfo()
     * <curl\easy.h>
     *
     * DESCRIPTION
     *
     * Request internal information from the curl session with this function.  The
     * third argument MUST be a pointer to a the variable that will store the result.  The data
     * pointed to will be filled in accordingly and can be relied upon only if the
     * function returns CURLE_OK.  This function is intended to get used *AFTER* a
     * performed transfer, all results from this function are undefined until the
     * transfer is completed.
     *
     * PARAMETERS (CURL *handle, CURLINFO info, ... )
     * handle
     * CURLINFO
     * pointer
     * 
     * See List above for a list of options.
     * 
     * RETURN VALUE
     * If the operation was successful, CURLE_OK is returned. 
     * Otherwise an appropriate error code will be returned. 
     */
    
	infoType := GetInfoType(info)
	
	; Everything but double is 4 bytes.
    ; global value
	VarSetCapacity(val, infoType = 0x300000 ? 8 : 4) ; CURLINFO_DOUBLE
    
	if CURLE_OK := DllCall("libcurl\curl_easy_getinfo", UInt, handle, UInt, info, UInt, &val, Cdecl)
		return CURLE_OK

	if (info < 0x200000)                  ; CURLINFO_LONG
		val := DllCall("MulDiv", Int, NumGet(val), Int, 1, Int, 1, Str) ; STRING
	else if (info < 0x300000)             ; CURLINFO_DOUBLE
        val := NumGet(val)              ; LONG
    else if (info < 0x400000)             ; CURLINFO_SLIST
        val := NumGet(val, 0, "Double") ; DOUBLE
    else
        val := NumGet(Val)              ; SLIST
        
    return CURLE_OK
}
curl_easy_strerror(errorcode){                  ; curl_easy_strerror(CURLcode)
    
    ; http://curl.haxx.se/libcurl/c/curl_easy_strerror.html
    
    /*
     * NAME curl_easy_strerror()
     * <curl\curl.h>
     *
     * DESCRIPTION
     *
     * The curl_easy_strerror function may be used to turn a CURLcode value
     * into the equivalent human readable error string.  This is useful
     * for printing meaningful error messages.
     *
     * PARAMETERS (CURLcode)
     * CURLE
     * 
     * RETURN VALUE
     * A pointer to a zero terminated string. 
     */

	return DllCall("libcurl\curl_easy_strerror", UInt, ErrorCode, "Cdecl Str")
}
curl_easy_reset(handle){                        ; curl_easy_reset(CURL *handle)

    ; http://curl.haxx.se/libcurl/c/curl_easy_reset.html
    
    /*
     * NAME curl_easy_reset()
     * <curl\easy.h>
     *
     * DESCRIPTION
     *
     * Re-initializes a CURL handle to the default values. This puts back the
     * handle to the same state as it was in when it was just created.
     *
     * It does keep: live connections, the Session ID cache, the DNS cache and the
     * cookies.
     *
     * PARAMETERS (CURL *handle)
     * handle
     * 
     * RETURN VALUE
     * NONE
     */
     
	DllCall("libcurl\curl_easy_reset", UInt, handle)
}
curl_easy_escape(handle, url){                  ; curl_easy_escape(CURL *handle, *string, length)

    ; http://curl.haxx.se/libcurl/c/curl_easy_escape.html
    
    /*
     * NAME curl_easy_escape()
     * <curl\curl.h>
     *
     * DESCRIPTION
     *
     * Escapes URL strings (converts all letters consider illegal in URLs to their
     * %XX versions). This function returns a new allocated string or NULL if an error occurred.
     *
     * PARAMETERS (CURL *handle, *string, length)
     * handle
     * string
     * length
     *
     * RETURN VALUE
     * A pointer to a zero terminated string or NULL if it failed. 
     */
     
	return DllCall("libcurl\curl_easy_escape", UInt, handle, Str, url, UInt, StrLen(url))
}
curl_easy_unescape(handle, url){                ; curl_easy_unescape(CURL *handle, *string, length, *outlength)
	
    ; http://curl.haxx.se/libcurl/c/curl_easy_unescape.html
    
    /*
     * NAME curl_easy_unescape()
     * <curl\curl.h>
     *
     * DESCRIPTION
     *
     * Unescapes URL encoding in strings (converts all %XX codes to their 8bit
     * versions). This function returns a new allocated string or NULL if an error occurred.
     * Conversion Note: On non-ASCII platforms the ASCII %XX codes are
     * converted into the host encoding.
     *
     * PARAMETERS (CURL *handle, *string, length, *outlength)
     * handle
     * string
     * length
     * outlength
     *
     * RETURN VALUE
     * A pointer to a zero terminated string or NULL if it failed.
     */
     
	return DllCall("libcurl\curl_easy_unescape", UInt, handle, Str, url, UInt, 0, UInt, 0, Str)
}
curl_easy_duphandle(handle = ""){               ; curl_easy_duphandle(CURL *handle)

    ; http://curl.haxx.se/libcurl/c/curl_easy_duphandle.html
    
   /*
     * NAME curl_easy_duphandle()
     * <curl\easy.h>
     * 
     * DESCRIPTION
     *
     * Creates a new curl session handle with the same options set for the handle
     * passed in. Duplicating a handle could only be a matter of cloning data and
     * options, internal state info and things like persistant connections cannot
     * be transfered. It is useful in multithreaded applications when you can run
     * curl_easy_duphandle() for each new thread to avoid a series of identical
     * curl_easy_setopt() invokes in every thread.
     *
     * PARAMETERS (CURL *handle)
     * handle
     *
     * RETURN VALUE
     * If this function returns NULL, something went wrong and no valid handle was 
     * returned. 
     */

    if !handle
            return "Error: Valid handle required"
    return handle := DllCall("libcurl\curl_easy_duphandle", UInt, handle)
}
curl_easy_send(handle, req, reqlen, Byref n){   ; curl_easy_send(CURL *handle, *buffer, buflen, *n)

    ; http://curl.haxx.se/libcurl/c/curl_easy_send.html
    
    /*
     * NAME curl_easy_send()
     *
     * DESCRIPTION
     *
     * Sends data over the connected socket. Use after successful
     * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
     *
     * PARAMETERS (CURL *curl, *buffer, buflen, *iolen)
     * handle
     * buffer
     * buflen
     * n
     *
     * RETURN VALUE
     * On success, returns CURLE_OK and stores the number of bytes actually sent 
     * into *n. Note that this may very well be less than the amount you wanted 
     * to send. On failure, returns the appropriate error code. 
     */
     
    VarSetCapacity(n, reqlen + 1)
    CURLE_OK := DllCall("libcurl\curl_easy_send", UInt, handle, Str, req, UInt, reqlen, UInt, &n)
    n := numget(n)
    return CURLE_OK

}
curl_easy_recv(handle, Byref req, reqlen, Byref n){ ; curl_easy_send(CURL *handle, *buffer, buflen, *n)

    ; http://curl.haxx.se/libcurl/c/curl_easy_recv.html
    
    /*
     * NAME curl_easy_recv()
     *
     * DESCRIPTION
     *
     * Receives data from the connected socket. Use after successful
     * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
     *
     * PARAMETERS (CURL *curl, *buffer, buflen, *iolen)
     * handle
     * buffer
     * buflen
     * n
     *
     * RETURN VALUE
     *
     * On success, returns CURLE_OK, stores the received data into buffer, 
     * and the number of bytes it actually read into *n.
     *
     * On failure, returns the appropriate error code.
     * 
     * If there is no data to read, the function returns CURLE_AGAIN. 
     * Use your operating system facilities to wait until the data is ready, and retry. 
     */
     
    VarSetCapacity(n, reqlen + 1)
    VarSetCapacity(req, reqlen + 1)
    CURLE_OK := DllCall("libcurl\curl_easy_recv", UInt, handle, UInt, &req, UInt, reqlen, UInt, &n)
    n := numget(n)
    return CURLE_OK
}
curl_version(){                                 ; curl_version(void)

    ; http://curl.haxx.se/libcurl/c/curl_version.html
    
    /*
     * NAME curl_version()
     * <curl\curl.h>
     *
     * DESCRIPTION
     *
     * Returns a static ascii string of the libcurl version.
     *
     * PARAMETERS
     * NONE
     * 
     * RETURN VALUE
     * A pointer to a zero terminated string. 
     */
     
	return DllCall("libcurl\curl_version", Str)
}
curl_version_info(vtype){                       ; curl_version_info(CURLversion)    

    global
    
    ; http://curl.haxx.se/libcurl/c/curl_version_info.html
    
    /*
     * NAME curl_version_info()
     * <curl\curl.h>
     *
     * DESCRIPTION
     *
     * This function returns a pointer to a static copy of the version info
     * struct. See above.
     *
     * PARAMETERS (CURLversion)
     * vtype
     *
     * RETURN VALUE
     * A pointer to a curl_version_info_data struct. 
     */
     
     return DllCall("libcurl\curl_version_info", UInt, vtype)
}
curl_free(str){                                 ; curl_free(void *p)

    ; http://curl.haxx.se/libcurl/c/curl_free.html
    
    /*
     * NAME curl_free()
     * <curl\curl.h>
     *
     * DESCRIPTION
     *
     * Provided for de-allocation in the same translation unit that did the
     * allocation. Added in libcurl 7.10
     *
     * PARAMETERS (void *p)
     * p
     *
     * RETURN VALUE
     * NONE
     */

	DllCall("libcurl\curl_free", UInt, pstr, Cdecl)	
	return trans := DllCall("MulDiv", Int, pstr, Int, 1, Int, 1, Str)
}
curl_slist_append(ByRef plist, str){            ; curl_slist_append(STRUCT *list, *string)
    
    ; http://curl.haxx.se/libcurl/c/curl_slist_append.html
    
    /*
     * NAME curl_slist_append()
     * <curl\curl.h>
     *
     * DESCRIPTION
     *
     * Appends a string to a linked list. If no list exists, it will be created
     * first. Returns the new list, after appending.
     * 
     * PARAMETERS (STRUCT *list, *string)
     * list
     * string
     *
     * RETURN VALUE
     * A NULL pointer is returned if anything went wrong, 
     * otherwise the new list pointer is returned. 
     */
     
	if !plist
		plist = 0

	return DllCall("libcurl\curl_slist_append", UInt, plist, UInt, &str, Cdecl)
}
curl_slist_free_all(ByRef plist){               ; curl_slist_free_all(STRUCT *list)
	    
    ; http://curl.haxx.se/libcurl/c/curl_slist_free_all.html
    
    /*
     * NAME curl_slist_free_all()
     * <curl\curl.h>
     *
     * DESCRIPTION
     *
     * free a previously built curl_slist.
     *
     * PARAMETERS (STRUCT *list)
     * list
     *
     * RETURN VALUE
     * Nothing. 
     */

	return DllCall("libcurl\curl_slist_free_all", UInt, plist, Cdecl)
}
curl_formfree(fpost){                           ; curl_formfree(STRUCT *form)

    ; http://curl.haxx.se/libcurl/c/curl_formfree.html

    /*
     * NAME curl_formfree()
     * <curl\curl.h>
     *
     * DESCRIPTION
     *
     * Free a multipart formpost previously built with curl_formadd().
     *
     * PARAMETERS (STRUCT *form)
     * form
     *
     * RETURN VALUE
     * NONE
     */

	return DllCall("libcurl\curl_formfree", UInt, &fpost, Cdecl)
}
curl_getdate(datestr){                          ; curl_getdate(*p, *unused)

    ; http://curl.haxx.se/libcurl/c/curl_getdate.html

    /*
     * NAME curl_getdate()
     * <curl/curl.h>
     *
     * DESCRIPTION
     *
     * Returns the time, in seconds since 1 Jan 1970 of the time string given in
     * the first argument. The time argument in the second parameter is unused
     * and should be set to NULL.
     *
     * PARAMETERS (*p, *unused)
     * p
     * 
     * RETURN VALUE
     * This function returns -1 when it fails to parse the date string. Otherwise it 
     * returns the number of seconds as described. 
     
     * If the year is larger than 2037 on systems with 32 bit time_t, 
     * this function will return 0x7fffffff (since that is the largest possible signed 32 bit number).
     * Having a 64 bit time_t is not a guarantee that dates beyond 
     * 03:14:07 UTC, January 19, 2038 will work fine. On systems with a 64 bit time_t 
     * but with a crippled mktime(), curl_getdate will return -1 in this case.     
     */

    return DllCall("libcurl\curl_getdate", Str, datestr)
}

; Internal Functions

GetInfoType(info)
{
    /*
     * Used internally by the curl_easy_getinfo() function
     */
     
	if (info < 0x200000) ; CURLINFO_LONG
		return 0x100000 ; CURLINFO_STRING
	else if (info < 0x300000) ; CURLINFO_DOUBLE
		return 0x200000 ; CURLINFO_LONG
	else if (info < 0x400000) ; CURLINFO_SLIST
        return 0x300000 ; CURLINFO_DOUBLE
	else
        return 0x400000 ; CURLINFO_SLIST
}

; end of Internal Functions

; Taken from FileHelper.ahk by Sean
; http://www.autohotkey.com/forum/topic19608.html

CreateFile(sFile, nCreate = 3, nAccess = 0x1F01FF, nShare = 7, bFolder = False){

    /*
     * CREATE_NEW    = 1
     * CREATE_ALWAYS = 2
     * OPEN_EXISTING = 3
     * OPEN_ALWAYS   = 4
     *
     * GENERIC_READ    = 0x80000000
     * GENERIC_WRITE   = 0x40000000
     * GENERIC_EXECUTE = 0x20000000
     * GENERIC_ALL     = 0x10000000
     *
     * FILE_SHARE_READ   = 1
     * FILE_SHARE_WRITE  = 2
     * FILE_SHARE_DELETE = 4
     */
     
    return DllCall("CreateFile", Uint, &sFile, UInt, nAccess, UInt, nShare, UInt, 0, UInt, nCreate, UInt
                               , bFolder ? 0x02000000 : 0, UInt, 0)
}
CloseFile(Handle){

    return DllCall("CloseHandle", Uint, Handle)
}

; end of FileHelper

ahk_write(ptr, size, nmemb, userdata){
    
    global fhnd
    
    /*
     * This function writes the received data to a file
     * you must use fhnd := CreateFile(path, 2) to create a file since this function
     * uses the fhnd variable which should contain a pointer to the file to be written to.
     * 
     * You can of course write your own function and register it instead like:
     * ahk_write := registercallback("ahk_write", "C F")
	 * curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, ahk_write)
     * 
     * make sure you read the documentation for easy_setopt for information about creating the functions
     * this function is not affected by CURLOPT_VERBOSE and will only write the response of the url
     * you just queried.
     */
     
	DllCall("WriteFile", UInt, fhnd, UInt, ptr, UInt, size*nmemb
					   , UIntP, size, UInt, 0)
	return size
}
ahk_debug(curl, infotype, buff, size, pointer){

	global stdout, dbfhnd
    
    /*
     * This function is similar to ahk_write but you can access the info through the 
     * variable "stdout" which is set by this function.
     * 
     * This function should be used when using the CURLOPT_VERBOSE option which sends
     * more information than the normal curl call, i personally prefer this function
     * most times when i dont need a file to write to.
     * 
     * Similarly to ahk_write, you can write your own function, make sure you register it like:
     * ahk_debug := registercallback("ahk_debug", "C F")
	 * curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, ahk_debug) ; register function
     *
     * Again make sure you read the documentation on easy_setopt to know how to create the function
     * 
     * Note that the file handle created here is closed when doing easy_cleanup, so make
     * sure you do it.
     */
    
    if !FileExist(a_temp . "\stdout")
        dbfhnd := CreateFile(a_temp . "\stdout", 2) ; create file to be used by the ahk_debug function
    DllCall("WriteFile", UInt, dbfhnd, UInt, buff, UInt, size
					   , UIntP, dboutsize, UInt, 0)
    FileRead, stdout, %a_temp%\stdout   ; Read temporary file to stdout so we can use the var later on
    return 0
}

; Need fix
curl_easy_pause(handle, option){                ; curl_easy_pause(CURL *handle, bitmask)
    
    ; http://curl.haxx.se/libcurl/c/curl_easy_pause.html
    ; -- > needs fix
    /*
     * NAME curl_easy_pause()
     * <curl\curl.h>
     *
     * DESCRIPTION
     *
     * The curl_easy_pause function pauses or unpauses transfers. Select the new
     * state by setting the bitmask, use the convenience defines below.
     *
     * PARAMETERS (CURL *handle, bitmask)
     * handle
     * CURLPAUSE_RECV 1
     * CURLPAUSE_SEND 3
     * CURLPAUSE_ALL  4
     * CURLPAUSE_CONT 0
     *
     * RETURN VALUE
     * CURLE_OK (zero) means that the option was set properly, and a non-zero return 
     * code means something wrong occurred after the new state was set. 
     * See the libcurl-errors(3) man page for the full list with descriptions. 
     */

    return CURLE_OK := DllCall("libcurl\curl_easy_pause", UInt, handle, Uint, option)
}
curl_formadd(Byref fpost, Byref lpost, params){ ; curl_formadd(STRUCT **httppost, STRUCT **post_last, ...)

    global
    
    ; http://curl.haxx.se/libcurl/c/curl_formadd.html

    /*
     * NAME curl_formadd()
     * <curl\curl.h>
     *
     * DESCRIPTION
     *
     * Pretty advanced function for building multi-part formposts. Each invoke
     * adds one part that together construct a full post. Then use the
     * CURLOPT_HTTPPOST option to send it off to libcurl.
     *
     * PARAMETERS (STRUCT **firstpost, STRUCT **lastpost, ...)
     * firstpost
     * lastpost
     * params
     *
     * RETURN VALUE
     * CURLE_OK(zero) means everything was ok, non-zero means an error occurred 
     * corresponding to a CURL_FORMADD_* constant defined in <curl/curl.h>
     */
    
    if (!fpost || !lpost)   
	{
        VarSetCapacity(fpost, 52, 0)
        VarSetCapacity(lpost, 52, 0)
	}
    else
    {
        ; getting the current info
        next := NumGet(fpost, 0, "UInt")
        name := NumGet(fpost, 4, "UInt")
        namelength := NumGet(fpost, 8, "Int")
        contents := NumGet(fpost, 12, "UInt")
        contentslength := NumGet(fpost, 16, "Int")
        buffer := NumGet(fpost, 20, "UInt")
        bufferlength := NumGet(fpost, 24, "Int")
        contenttype := NumGet(fpost, 28, "UInt")
        contentheader := NumGet(fpost, 32, "UInt")
        more := NumGet(fpost, 36, "UInt")
        flags := NumGet(fpost, 40, "Int")
        showfilename := NumGet(fpost, 44, "UInt")
        userp := NumGet(fpost, 48, "UInt")
        
        ; filling the struct
        NumPut(&next, fpost, 0, "UInt")
        NumPut(name, fpost, 4, "UInt")
        NumPut(namelength, fpost, 8, "Int")
        NumPut(contents, fpost, 12, "UInt")
        NumPut(contentslength, fpost, 16, "Int")
        NumPut(buffer, fpost, 20, "UInt")
        NumPut(bufferlength, fpost, 24, "Int")
        NumPut(contenttype, fpost, 28, "UInt")
        NumPut(&contentheader, fpost, 32, "UInt")
        NumPut(&more, fpost, 36, "UInt")
        NumPut(flags, fpost, 40, "Int")
        NumPut(showfilename, fpost, 44, "UInt")
        NumPut(userp, fpost, 48, "UInt")
    }
        
    Loop, parse, params, `, 
    {
        if mod(a_index, 2) = 1
            Fopt%a_index%:=regexreplace(a_loopfield,"\s", "") ; saving CURLFORM options found in params
        if mod(a_index, 2) = 0
            Fval%a_index%:=regexreplace(a_loopfield,"\s", "") ; saving CURLFROM values found in params
    }
    
    return CURLE_OK:=DllCall("libcurl\curl_formadd", UInt, &fpost, UInt, &lpost, UInt, %Fopt1%, Str, Fval2
                                                                               , UInt, %Fopt3%, Str, Fval4
                                                                               , UInt, %Fopt5%, Str, Fval6
                                                                               , UInt, %Fopt7%, Str, Fval8
                                                                               , UInt, %Fopt9%, Str, Fval10)
}

; Not used
; MergeDouble( l, h )
; {
	; VarSetCapacity( Value, 8, 0 )
	; NumPut( l, Value, 0 ), NumPut( h, Value, 4 )
	; return NumGet( Value, 0, "Double" )
; }
; GetOptionType( Option )
; {
	; global
	; if ( Option < 10000 ) ; CURLOPTTYPE_OBJECTPOINT
		; return 0 ; CURLOPTTYPE_LONG
	; else
	; {
		; if ( Option < 20000 ) ; CURLOPTTYPE_FUNCTIONPOINT
			; return 10000 ; CURLOPTTYPE_OBJECTPOINT
		; else
		; {
			; if ( Option < 30000 ) ; CURLOPTTYPE_OFF_T
				; return 20000 ; CURLOPTTYPE_FUNCTIONPOINT
			; else
				; return 30000 ; CURLOPTTYPE_OFF_T
		; }
	; }
; }