@ohos-ports/curlconverter 4.12.0-beta.0

package/src/generators/c.ts

@@ -0,0 +1,1371 @@
+import { Word, eq, mergeWords } from "../shell/Word.js";
+import { parse, getFirst, COMMON_SUPPORTED_ARGS } from "../parse.js";
+import type { Request, Warnings } from "../parse.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+
+  "disallow-username-in-url",
+  "path-as-is",
+
+  "alt-svc",
+
+  "unix-socket",
+  "abstract-unix-socket",
+
+  "compressed",
+  "no-compressed",
+  "verbose",
+  "no-verbose",
+
+  "proxy",
+  "proxy-user",
+  "proxytunnel",
+  "noproxy",
+  "preproxy",
+  "proxy-anyauth",
+  "proxy-basic",
+  "proxy-digest",
+  "proxy-negotiate",
+  "proxy-ntlm",
+  "proxy-ca-native",
+  "proxy-cacert",
+  "proxy-capath",
+  "proxy-cert-type",
+  "proxy-cert",
+  "proxy-ciphers",
+  "proxy-crlfile",
+  "proxy-header",
+  "proxy-http2",
+  "proxy-insecure",
+  "proxy-key",
+  "proxy-key-type",
+  "proxy-pass",
+  "proxy-pinnedpubkey",
+  "proxy-service-name",
+  "proxy-ssl-allow-beast",
+  "proxy-ssl-auto-client-cert",
+  "proxy-tls13-ciphers",
+  "proxy-tlsuser",
+  "proxy-tlspassword",
+  "proxy-tlsauthtype",
+  "proxy-tlsv1",
+  "socks4",
+  "socks4a",
+  "socks5",
+  "socks5-hostname",
+  "socks5-basic",
+  "socks5-gssapi",
+  "socks5-gssapi-nec",
+  "socks5-gssapi-service",
+
+  "haproxy-clientip",
+  "haproxy-protocol",
+
+  "interface",
+
+  "netrc",
+  "netrc-file",
+  "netrc-optional",
+
+  // "anyauth",
+  // "no-anyauth",
+  "digest",
+  "no-digest",
+  "negotiate",
+  "no-negotiate",
+  "service-name",
+  "ntlm",
+  "no-ntlm",
+  "ntlm-wb",
+  "no-ntlm-wb",
+  "aws-sigv4",
+  "delegation",
+  "oauth2-bearer",
+
+  "ipv4",
+  "ipv6",
+
+  "local-port",
+
+  "ftp-skip-pasv-ip",
+
+  "sasl-authzid",
+  "sasl-ir",
+  "tr-encoding",
+
+  "tcp-fastopen",
+
+  // Not parsed properly
+  // "proto",
+  // "proto-redir",
+  "proto-default",
+
+  "ignore-content-length",
+  "no-ignore-content-length",
+
+  "remote-time",
+  // "time-cond",
+
+  // requires that the underlying libcurl was built to support c-ares
+  // "dns-interface",
+  // "dns-ipv4-addr",
+  // "dns-ipv6-addr",
+  // "dns-servers",
+
+  // No effect
+  // "dump-header",
+  // "include",
+  // "engine",
+
+  // Adds a If-None-Match header
+  // "etag-compare",
+  // "etag-save", // No effect
+
+  "fail",
+  // "fail-with-body",
+  // "fail-early",
+
+  "continue-at",
+
+  "speed-limit",
+  "speed-time",
+  "limit-rate",
+  "max-filesize",
+
+  "http0.9",
+  "http1.0",
+  "http1.1",
+  "http2",
+  "http2-prior-knowledge",
+  "http3",
+  "http3-only",
+
+  "cookie-jar",
+  "junk-session-cookies",
+
+  "crlf",
+  "no-crlf",
+  "use-ascii",
+
+  // "write-out",
+
+  "pass",
+  "cacert",
+  "capath",
+  "crlfile",
+  "pinnedpubkey",
+  "curves",
+  "cert",
+  "cert-status",
+  "cert-type",
+  "key",
+  "key-type",
+  "ca-native",
+  "ssl-allow-beast",
+  "ciphers",
+  "tls13-ciphers",
+  "tlsuser",
+  "tlspassword",
+  "tlsauthtype",
+  "ssl",
+  "ssl-auto-client-cert",
+  "ssl-no-revoke",
+  "ssl-reqd",
+  "ssl-revoke-best-effort",
+
+  // "sslv2",  // ignored
+  // "sslv3",  // ignored
+  "tlsv1",
+  "tlsv1.0",
+  "tlsv1.1",
+  "tlsv1.2",
+  "tlsv1.3",
+  "tls-max",
+
+  // "false-start",
+  "hsts",
+  "alpn",
+  "no-alpn",
+
+  "form",
+  "form-string",
+  "form-escape",
+  "no-form-escape",
+
+  "doh-url",
+  "doh-cert-status",
+  // "doh-insecure",  // has no effect
+
+  "location",
+  "no-location",
+  "location-trusted",
+  "no-location-trusted",
+  "max-redirs",
+  "post301",
+  "post302",
+  "post303",
+
+  "max-time",
+  "connect-timeout",
+  "expect100-timeout",
+  "happy-eyeballs-timeout-ms",
+
+  "resolve",
+  "connect-to",
+
+  "keepalive",
+  "no-keepalive",
+  "keepalive-time",
+
+  "insecure",
+  "no-insecure",
+]);
+
+const regexEscape = /"|\\|\p{C}|[^ \P{Z}]/gu;
+export function reprStr(s: string): string {
+  return (
+    '"' +
+    s.replace(regexEscape, (c: string): string => {
+      switch (c) {
+        case "\x07":
+          return "\\a";
+        case "\b":
+          return "\\b";
+        case "\f":
+          return "\\f";
+        case "\n":
+          return "\\n";
+        case "\r":
+          return "\\r";
+        case "\t":
+          return "\\t";
+        case "\v":
+          return "\\v";
+        case "\\":
+          return "\\\\";
+        case '"':
+          return '\\"';
+      }
+      const hex = (c.codePointAt(0) as number).toString(16);
+      if (hex.length <= 2) {
+        return "\\x" + hex.padStart(2, "0");
+      }
+      if (hex.length <= 4) {
+        return "\\u" + hex.padStart(4, "0");
+      }
+      return "\\U" + hex.padStart(8, "0");
+    }) +
+    '"'
+  );
+}
+
+export function repr(word: Word, imports: Set<string>): string {
+  const reprs = [];
+  for (const t of word.tokens) {
+    if (typeof t === "string") {
+      reprs.push(reprStr(t));
+    } else if (t.type === "variable") {
+      reprs.push("getenv(" + reprStr(t.value) + ")");
+      imports.add("stdlib.h");
+    } else if (t.type === "command") {
+      // TODO: read the FILE contents
+      reprs.push("popen(" + reprStr(t.value) + ', "r")');
+      imports.add("stdio.h");
+    }
+  }
+
+  // TODO: C can't concatenate strings
+  return reprs.join(" + ");
+}
+
+export function atof1000(word: Word, imports: Set<string>): string {
+  if (word.isString()) {
+    // TODO: check it's actually a valid float
+    const asFloat = parseFloat(word.toString());
+    if (!Number.isNaN(asFloat)) {
+      return Math.floor(asFloat * 1000) + "L";
+    }
+  }
+  return "(long)(atof(" + repr(word, imports) + ") * 1000)";
+}
+
+export function atoi(word: Word, imports: Set<string>): string {
+  if (word.isString()) {
+    // TODO: check it's actually a valid int
+    return word.toString();
+  }
+  return "atoi(" + repr(word, imports) + ")";
+}
+export function atol(word: Word, imports: Set<string>): string {
+  if (word.isString()) {
+    // TODO: check it's actually a valid int
+    return word.toString() + "L";
+  }
+  return "atol(" + repr(word, imports) + ")";
+}
+
+const AUTH_TO_VAR = {
+  basic: "CURLAUTH_BASIC",
+  negotiate: "CURLAUTH_NEGOTIATE",
+  // technically what --libcurl generates but older
+  // negotiate: "CURLAUTH_GSSNEGOTIATE",
+  digest: "CURLAUTH_DIGEST",
+  ntlm: "CURLAUTH_NTLM",
+  "ntlm-wb": "CURLAUTH_NTLM_WB",
+  bearer: "CURLAUTH_BEARER",
+  "aws-sigv4": "CURLAUTH_AWS_SIGV4",
+  none: "CURLAUTH_NONE",
+};
+
+function requestToC(
+  request: Request,
+  warnings: Warnings = [],
+  imports: Set<string>,
+): string {
+  let preamble = "";
+  preamble += "int main(int argc, char *argv[])\n";
+  preamble += "{\n";
+  preamble += "  CURLcode ret;\n";
+  preamble += "  CURL *hnd;\n";
+
+  let vars = "";
+
+  let code = "";
+  code += "  hnd = curl_easy_init();\n";
+
+  let cleanup = "";
+  cleanup += "  curl_easy_cleanup(hnd);\n";
+  cleanup += "  hnd = NULL;\n";
+
+  if (request.tcpFastopen) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_TCP_FASTOPEN, 1L);\n";
+  }
+  const bufferSize = request.limitRate
+    ? atol(request.limitRate, imports) // TODO: parse
+    : "102400L";
+  code += "  curl_easy_setopt(hnd, CURLOPT_BUFFERSIZE, " + bufferSize + ");\n";
+
+  if (request.localPort) {
+    const [start, end] = request.localPort;
+
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_LOCALPORT, " +
+      atol(start, imports) +
+      ");\n";
+    let range = "1L";
+    if (end) {
+      range = atol(end, imports) + "-" + atol(start, imports);
+    }
+    code += "  curl_easy_setopt(hnd, CURLOPT_LOCALPORTRANGE, " + range + ");\n";
+  }
+
+  // TODO: if it doesn't have a query string from --data, it's better to
+  // do originalUrl because it doesn't need to have the http[s]://
+  const url = request.urls[0].url;
+  code += "  curl_easy_setopt(hnd, CURLOPT_URL, " + repr(url, imports) + ");\n";
+
+  code += "  curl_easy_setopt(hnd, CURLOPT_NOPROGRESS, 1L);\n";
+
+  if (request.oauth2Bearer) {
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_XOAUTH2_BEARER, " +
+      repr(request.oauth2Bearer, imports) +
+      ");\n";
+  }
+
+  if (request.proxy) {
+    const proxy = repr(request.proxy, imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_PROXY, " + proxy + ");\n";
+  }
+  if (request.proxyType) {
+    if (request.proxyType === "http2") {
+      code += "  curl_easy_setopt(hnd, CURLOPT_PROXYTYPE, 3L);\n";
+    } else if (request.proxyType === "http1") {
+      code +=
+        "  curl_easy_setopt(hnd, CURLOPT_PROXYTYPE, (long)CURLPROXY_HTTP_1_0);\n";
+    } else if (request.proxyType === "socks4") {
+      code +=
+        "  curl_easy_setopt(hnd, CURLOPT_PROXYTYPE, (long)CURLPROXY_SOCKS4);\n";
+    } else if (request.proxyType === "socks4a") {
+      code +=
+        "  curl_easy_setopt(hnd, CURLOPT_PROXYTYPE, (long)CURLPROXY_SOCKS4A);\n";
+    } else if (request.proxyType === "socks5") {
+      code +=
+        "  curl_easy_setopt(hnd, CURLOPT_PROXYTYPE, (long)CURLPROXY_SOCKS5);\n";
+    } else if (request.proxyType === "socks5-hostname") {
+      code +=
+        "  curl_easy_setopt(hnd, CURLOPT_PROXYTYPE, (long)CURLPROXY_SOCKS5_HOSTNAME);\n";
+    }
+  }
+  if (request.proxyAuth) {
+    const proxyUserpwd = repr(request.proxyAuth, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_PROXYUSERPWD, " + proxyUserpwd + ");\n";
+  }
+  if (request.proxytunnel) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_HTTPPROXYTUNNEL, 1L);\n";
+  }
+  if (request.proxyAuth) {
+    const proxyAuth = AUTH_TO_VAR[request.proxyAuthType];
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_PROXYAUTH, (long)" + proxyAuth + ");\n";
+  }
+
+  if (request.preproxy) {
+    const preproxy = repr(request.preproxy, imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_PRE_PROXY, " + preproxy + ");\n";
+  }
+  if (request.noproxy) {
+    const noproxy = repr(request.noproxy, imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_NOPROXY, " + noproxy + ");\n";
+  }
+  if (request.fail) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_FAILONERROR, 1L);\n";
+  }
+  if (request.netrc) {
+    const netrc = {
+      optional: "CURL_NETRC_OPTIONAL",
+      required: "CURL_NETRC_REQUIRED",
+      ignored: "CURL_NETRC_IGNORED",
+    }[request.netrc || "ignored"];
+    code += "  curl_easy_setopt(hnd, CURLOPT_NETRC, (long)" + netrc + ");\n";
+  }
+  if (request.netrcFile) {
+    const netrcFile = repr(request.netrcFile, imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_NETRC_FILE, " + netrcFile + ");\n";
+  }
+
+  if (request.useAscii) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_TRANSFERTEXT, 1L);\n";
+  }
+
+  if (request.urls[0].auth) {
+    const [username, password] = request.urls[0].auth;
+    const userpwd = repr(mergeWords(username, ":", password), imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_USERPWD, " + userpwd + ");\n";
+  }
+
+  if (request.timeout) {
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_TIMEOUT_MS, " +
+      atof1000(request.timeout, imports) +
+      ");\n";
+  }
+
+  if (request.urls[0].uploadFile) {
+    // TODO
+  } else if (request.multipartUploads) {
+    preamble += "  curl_mime *mime1;\n";
+    preamble += "  curl_mimepart *part1;\n";
+
+    vars += "  mime1 = NULL;\n";
+
+    code += "  mime1 = curl_mime_init(hnd);\n";
+
+    for (const m of request.multipartUploads) {
+      code += "  part1 = curl_mime_addpart(mime1);\n";
+      if ("contentFile" in m && m.contentFile) {
+        code +=
+          "  curl_mime_filedata(part1, " +
+          repr(m.contentFile, imports) +
+          ");\n";
+      } else if ("content" in m && m.content) {
+        code +=
+          "  curl_mime_data(part1, " +
+          repr(m.content, imports) +
+          ", CURL_ZERO_TERMINATED);\n";
+      }
+      if ("encoder" in m && m.encoder) {
+        code +=
+          "  curl_mime_encoder(part1, " + repr(m.encoder, imports) + ");\n";
+      }
+      if (
+        "filename" in m &&
+        m.filename &&
+        !("contentFile" in m && m.contentFile && eq(m.filename, m.contentFile))
+      ) {
+        code +=
+          "  curl_mime_filename(part1, " + repr(m.filename, imports) + ");\n";
+      } else if (!m.filename && "contentFile" in m && m.contentFile) {
+        code += "  curl_mime_filename(part1, NULL);\n";
+      }
+      code += "  curl_mime_name(part1, " + repr(m.name, imports) + ");\n";
+      if ("contentType" in m && m.contentType) {
+        code +=
+          "  curl_mime_type(part1, " + repr(m.contentType, imports) + ");\n";
+      }
+      if ("headers" in m && m.headers) {
+        warnings.push([
+          "multipart-headers",
+          "multipart headers are not supported: " +
+            m.headers.map((h) => h.toString()).join(", "),
+        ]);
+      }
+      if ("headerFiles" in m && m.headerFiles) {
+        warnings.push([
+          "multipart-headers",
+          "multipart header files are not supported: " +
+            m.headerFiles.map((h) => h.toString()).join(", "),
+        ]);
+      }
+    }
+
+    code += "  curl_easy_setopt(hnd, CURLOPT_MIMEPOST, mime1);\n";
+
+    cleanup += "  curl_mime_free(mime1);\n";
+    cleanup += "  mime1 = NULL;\n";
+  } else if (request.data) {
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, " +
+      repr(request.data, imports) +
+      ");\n";
+    // this isn't correct if .data reads files
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_POSTFIELDSIZE_LARGE, (curl_off_t)" +
+      request.data.length.toString() +
+      ");\n";
+  }
+  if (request.formEscape) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_MIME_OPTIONS, 1L);\n";
+  }
+
+  if (request.urls[0].auth) {
+    const curlAuth = AUTH_TO_VAR[request.authType];
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_HTTPAUTH, (long)" + curlAuth + ");\n";
+  }
+
+  const headerLines = [];
+  for (const [headerName, headerValue] of request.headers) {
+    const h = headerName.toLowerCase();
+    if (eq(h, "user-agent") || eq(h, "referer")) {
+      continue;
+    }
+    if (headerValue === null) {
+      headerLines.push(
+        "  headers = curl_slist_append(headers, " +
+          repr(mergeWords(headerName, ":"), imports) +
+          ");\n",
+      );
+    } else if (eq(headerValue, "")) {
+      headerLines.push(
+        "  headers = curl_slist_append(headers, " +
+          repr(mergeWords(headerName, ";"), imports) +
+          ");\n",
+      );
+    } else {
+      headerLines.push(
+        "  headers = curl_slist_append(headers, " +
+          repr(mergeWords(headerName, ": ", headerValue), imports) +
+          ");\n",
+      );
+    }
+  }
+  if (headerLines.length) {
+    preamble += "  struct curl_slist *headers;\n";
+
+    vars += "  headers = NULL;\n";
+    vars += headerLines.join("");
+
+    code += "  curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);\n";
+
+    cleanup += "  curl_slist_free_all(headers);\n";
+    cleanup += "  headers = NULL;\n";
+  }
+  const referer = request.headers.get("referer");
+  if (referer) {
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_REFERER, " +
+      repr(referer, imports) +
+      ");\n";
+    // TODO: only if passed with --referer and not -H
+  }
+  const userAgent = request.headers.get("user-agent");
+  if (userAgent) {
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_USERAGENT, " +
+      repr(userAgent, imports) +
+      ");\n";
+  } else if (userAgent === undefined) {
+    // TODO: needs to be kept up-to-date with VERSION in cli.ts
+    code += '  curl_easy_setopt(hnd, CURLOPT_USERAGENT, "curl/8.2.1");\n';
+  }
+
+  if (request.followRedirects) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_FOLLOWLOCATION, 1L);\n";
+    if (request.followRedirectsTrusted) {
+      code += "  curl_easy_setopt(hnd, CURLOPT_UNRESTRICTED_AUTH, 1L);\n";
+    }
+  }
+
+  if (request.awsSigV4) {
+    const awsSig = repr(request.awsSigV4, imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_AWS_SIGV4, " + awsSig + ");\n";
+  }
+
+  if (request.refererAuto) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_AUTOREFERER, 1L);\n";
+  }
+
+  if (request.proxyHeaders.length) {
+    // TODO: camelCase snake_case orjustoneword?
+    preamble += "  struct curl_slist *proxy_headers;\n";
+
+    if (vars) {
+      vars += "\n";
+    }
+    vars += "  proxy_headers = NULL;\n";
+    for (const [headerName, headerValue] of request.proxyHeaders) {
+      if (headerValue === null) {
+        vars +=
+          "  proxy_headers = curl_slist_append(proxy_headers, " +
+          repr(mergeWords(headerName, ":"), imports) +
+          ");\n";
+      } else if (eq(headerValue, "")) {
+        vars +=
+          "  proxy_headers = curl_slist_append(proxy_headers, " +
+          repr(mergeWords(headerName, ";"), imports) +
+          ");\n";
+      } else {
+        vars +=
+          "  proxy_headers = curl_slist_append(proxy_headers, " +
+          repr(mergeWords(headerName, ": ", headerValue), imports) +
+          ");\n";
+      }
+    }
+
+    code += "  curl_easy_setopt(hnd, CURLOPT_PROXYHEADER, proxy_headers);\n";
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_HEADEROPT, (long)CURLHEADER_SEPARATE);\n";
+
+    cleanup += "  curl_slist_free_all(proxy_headers);\n";
+    cleanup += "  proxy_headers = NULL;\n";
+  }
+
+  const maxRedirs = request.maxRedirects || new Word("50");
+  code +=
+    "  curl_easy_setopt(hnd, CURLOPT_MAXREDIRS, " +
+    atol(maxRedirs, imports) +
+    ");\n";
+
+  let httpVersion = "CURL_HTTP_VERSION_2TLS";
+  if (request.httpVersion) {
+    httpVersion = {
+      "1.0": "CURL_HTTP_VERSION_1_0",
+      "1.1": "CURL_HTTP_VERSION_1_1",
+      "2": "CURL_HTTP_VERSION_2_0",
+      "2-prior-knowledge": "CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE",
+      "3": "CURL_HTTP_VERSION_3",
+      "3-only": "CURL_HTTP_VERSION_3ONLY",
+    }[request.httpVersion];
+  }
+  code +=
+    "  curl_easy_setopt(hnd, CURLOPT_HTTP_VERSION, (long)" +
+    httpVersion +
+    ");\n";
+  if (request.http0_9) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_HTTP09_ALLOWED, 1L);\n";
+  }
+
+  if (request.post301 || request.post302 || request.post303) {
+    const postRedir = [];
+    if (request.post301) {
+      postRedir.push("CURL_REDIR_POST_301");
+    }
+    if (request.post302) {
+      postRedir.push("CURL_REDIR_POST_302");
+    }
+    if (request.post303) {
+      postRedir.push("CURL_REDIR_POST_303");
+    }
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_POSTREDIR, " +
+      postRedir.join(" | ") +
+      ");\n";
+  }
+
+  if (request.compressed) {
+    code += '  curl_easy_setopt(hnd, CURLOPT_ACCEPT_ENCODING, "");\n';
+  }
+
+  if (request.transferEncoding) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_TRANSFER_ENCODING, 1L);\n";
+  }
+
+  if (request.speedLimit || request.speedTime) {
+    const speedLimit = atol(request.speedLimit || new Word("1"), imports);
+    const speedTime = atol(request.speedTime || new Word("30"), imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_LOW_SPEED_LIMIT, " + speedLimit + ");\n";
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_LOW_SPEED_TIME, " + speedTime + ");\n";
+  }
+  if (request.limitRate) {
+    // TODO: parse
+    const limitRate = repr(request.limitRate, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_MAX_SEND_SPEED_LARGE, (curl_off_t)" +
+      limitRate +
+      ");\n";
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_MAX_RECV_SPEED_LARGE, (curl_off_t)" +
+      limitRate +
+      ");\n";
+  }
+
+  if (request.continueAt) {
+    if (!eq(request.continueAt, "-")) {
+      const continueAt = atoi(request.continueAt, imports);
+      code +=
+        "  curl_easy_setopt(hnd, CURLOPT_RESUME_FROM_LARGE, (curl_off_t)" +
+        continueAt +
+        ");\n";
+    }
+  }
+
+  if (request.pass) {
+    const pass = repr(request.pass, imports);
+    // TODO: --cert can also set this
+    code += "  curl_easy_setopt(hnd, CURLOPT_KEYPASSWD, " + pass + ");\n";
+  }
+  if (request.proxyPass) {
+    // TODO: --proxy-cert can also set this
+    const proxyPass = repr(request.proxyPass, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_PROXY_KEYPASSWD, " + proxyPass + ");\n";
+  }
+
+  if (request.cacert) {
+    const cacert = repr(request.cacert, imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_CAINFO, " + cacert + ");\n";
+  }
+  if (request.proxyCacert) {
+    const proxyCacert = repr(request.proxyCacert, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_PROXY_CAINFO, " + proxyCacert + ");\n";
+  }
+
+  if (request.capath || request.proxyCapath) {
+    if (request.capath) {
+      const capath = repr(request.capath, imports);
+      code += "  curl_easy_setopt(hnd, CURLOPT_CAPATH, " + capath + ");\n";
+      const proxyCapath = repr(request.proxyCapath || request.capath, imports);
+      code +=
+        "  curl_easy_setopt(hnd, CURLOPT_PROXY_CAPATH, " + proxyCapath + ");\n";
+    } else if (request.proxyCapath) {
+      // placate type checker
+      const proxyCapath = repr(request.proxyCapath, imports);
+      code +=
+        "  curl_easy_setopt(hnd, CURLOPT_PROXY_CAPATH, " + proxyCapath + ");\n";
+    }
+  }
+
+  if (request.crlfile || request.proxyCrlfile) {
+    if (request.crlfile) {
+      const crlfile = repr(request.crlfile, imports);
+      code += "  curl_easy_setopt(hnd, CURLOPT_CRLFILE, " + crlfile + ");\n";
+      const proxyCrlfile = repr(
+        request.proxyCrlfile || request.crlfile,
+        imports,
+      );
+      code +=
+        "  curl_easy_setopt(hnd, CURLOPT_PROXY_CRLFILE, " +
+        proxyCrlfile +
+        ");\n";
+    } else if (request.proxyCrlfile) {
+      // placate type checker
+      const proxyCrlfile = repr(request.proxyCrlfile, imports);
+      code +=
+        "  curl_easy_setopt(hnd, CURLOPT_PROXY_CRLFILE, " +
+        proxyCrlfile +
+        ");\n";
+    }
+  }
+  if (request.pinnedpubkey) {
+    const pinnedpubkey = repr(request.pinnedpubkey, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_PINNEDPUBLICKEY, " +
+      pinnedpubkey +
+      ");\n";
+  }
+  // TODO: --proxy-pinnedpubkey ?
+  if (request.curves) {
+    const curves = repr(request.curves, imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_SSL_EC_CURVES, " + curves + ");\n";
+  }
+  if (request.cert) {
+    const [cert, pass] = request.cert;
+    if (pass) {
+      code +=
+        "  curl_easy_setopt(hnd, CURLOPT_KEYPASSWD, " +
+        repr(pass, imports) +
+        ");\n";
+    }
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_SSLCERT, " +
+      repr(cert, imports) +
+      ");\n";
+  }
+  if (request.proxyCert) {
+    // TODO: split
+    const proxyCert = repr(request.proxyCert, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_PROXY_SSLCERT, " + proxyCert + ");\n";
+  }
+  if (request.certType) {
+    const certType = repr(request.certType, imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_SSLCERTTYPE, " + certType + ");\n";
+  }
+  if (request.proxyCertType) {
+    const proxyCertType = repr(request.proxyCertType, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_PROXY_SSLCERTTYPE, " +
+      proxyCertType +
+      ");\n";
+  }
+  if (request.key) {
+    const key = repr(request.key, imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_SSLKEY, " + key + ");\n";
+  }
+  if (request.proxyKey) {
+    const proxyKey = repr(request.proxyKey, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_PROXY_SSLKEY, " + proxyKey + ");\n";
+  }
+  if (request.keyType) {
+    const keyType = repr(request.keyType, imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_SSLKEYTYPE, " + keyType + ");\n";
+  }
+  if (request.proxyKeyType) {
+    const proxyKeyType = repr(request.proxyKeyType, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_PROXY_SSLKEYTYPE, " +
+      proxyKeyType +
+      ");\n";
+  }
+
+  if (request.insecure) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYPEER, 0L);\n";
+    code += "  curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYHOST, 0L);\n";
+  }
+  if (request.proxyInsecure) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_PROXY_SSL_VERIFYPEER, 0L);\n";
+    code += "  curl_easy_setopt(hnd, CURLOPT_PROXY_SSL_VERIFYHOST, 0L);\n";
+  }
+  if (request.certStatus) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYSTATUS, 1L);\n";
+  }
+  if (request.dohCertStatus) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_DOH_SSL_VERIFYSTATUS, 1L);\n";
+  }
+
+  let tlsVersion = null;
+  if (request.tlsVersion) {
+    tlsVersion = {
+      "1": "CURL_SSLVERSION_TLSv1",
+      "1.0": "CURL_SSLVERSION_TLSv1_0",
+      "1.1": "CURL_SSLVERSION_TLSv1_1",
+      "1.2": "CURL_SSLVERSION_TLSv1_2",
+      "1.3": "CURL_SSLVERSION_TLSv1_3",
+    }[request.tlsVersion];
+  }
+  let tlsMax = null;
+  if (request.tlsMax) {
+    if (request.tlsMax.isString()) {
+      const tlsMaxVal = request.tlsMax.toString();
+      switch (tlsMaxVal) {
+        case "1.0":
+          tlsMax = "CURL_SSLVERSION_MAX_TLSv1_0";
+          break;
+        case "1.1":
+          tlsMax = "CURL_SSLVERSION_MAX_TLSv1_1";
+          break;
+        case "1.2":
+          tlsMax = "CURL_SSLVERSION_MAX_TLSv1_2";
+          break;
+        case "1.3":
+          tlsMax = "CURL_SSLVERSION_MAX_TLSv1_3";
+          break;
+        case "default":
+          tlsMax = "CURL_SSLVERSION_MAX_DEFAULT";
+          break;
+        default:
+          warnings.push([
+            "tls-max",
+            "unknown value for --tls-max: " + JSON.stringify(tlsMaxVal),
+          ]);
+      }
+    } else {
+      warnings.push([
+        "tls-max",
+        "unparseable value for --tls-max: " +
+          JSON.stringify(request.tlsMax.toString()),
+      ]);
+    }
+  }
+  if (tlsVersion || tlsMax) {
+    if (!tlsVersion) {
+      // not really necessary since it's 0
+      tlsVersion = "CURL_SSLVERSION_DEFAULT";
+    }
+    code += "  curl_easy_setopt(hnd, CURLOPT_SSLVERSION, (long)";
+    if (tlsMax) {
+      code += "(" + tlsVersion + " | " + tlsMax + ")";
+    } else {
+      code += tlsVersion;
+    }
+    code += ");\n";
+  }
+  if (request.proxyTlsv1) {
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_PROXY_SSLVERSION, (long)CURL_SSLVERSION_TLSv1);\n";
+  }
+  if (
+    request.sslAllowBeast ||
+    request.sslNoRevoke ||
+    request.sslRevokeBestEffort ||
+    request.caNative ||
+    request.sslAutoClientCert
+  ) {
+    const sslOptions = [];
+    if (request.sslAllowBeast) {
+      sslOptions.push("CURLSSLOPT_ALLOW_BEAST");
+    }
+    if (request.sslNoRevoke) {
+      sslOptions.push("CURLSSLOPT_NO_REVOKE");
+    }
+    if (request.sslRevokeBestEffort) {
+      sslOptions.push("CURLSSLOPT_REVOKE_BEST_EFFORT");
+    }
+    if (request.caNative) {
+      sslOptions.push("CURLSSLOPT_NATIVE_CA");
+    }
+    if (request.sslAutoClientCert) {
+      sslOptions.push("CURLSSLOPT_AUTO_CLIENT_CERT");
+    }
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_SSL_OPTIONS, (long)" +
+      (sslOptions.length > 1 ? "(" : "") +
+      sslOptions.join(" | ") +
+      (sslOptions.length > 1 ? ")" : "") +
+      ");\n";
+  }
+
+  if (
+    request.proxySslAllowBeast ||
+    request.proxyCaNative ||
+    request.proxySslAutoClientCert
+  ) {
+    const sslOptions = [];
+    if (request.proxySslAllowBeast) {
+      sslOptions.push("CURLSSLOPT_ALLOW_BEAST");
+    }
+    if (request.proxyCaNative) {
+      sslOptions.push("CURLSSLOPT_NATIVE_CA");
+    }
+    if (request.proxySslAutoClientCert) {
+      sslOptions.push("CURLSSLOPT_AUTO_CLIENT_CERT");
+    }
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_PROXY_SSL_OPTIONS, (long)" +
+      sslOptions.join(" | (long)") +
+      ");\n";
+  }
+
+  if (request.pathAsIs) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_PATH_AS_IS, 1L);\n";
+  }
+
+  if (request.remoteTime) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_FILETIME, 1L);\n";
+  }
+
+  if (request.crlf) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_CRLF, 1L);\n";
+  }
+
+  if (request.cookieFiles) {
+    for (const cookieFile of request.cookieFiles) {
+      // TODO: why can curl set this more than once?
+      const cookieFile_ = repr(cookieFile, imports);
+      code +=
+        "  curl_easy_setopt(hnd, CURLOPT_COOKIEFILE, " + cookieFile_ + ");\n";
+    }
+  }
+  if (request.cookieJar) {
+    const cookieJar = repr(request.cookieJar, imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_COOKIEJAR, " + cookieJar + ");\n";
+  }
+  if (request.junkSessionCookies) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_COOKIESESSION, 1L);\n";
+  }
+
+  // TODO: this is more complicated.
+  // --head just sets CURLOPT_NOBODY and CURLOPT_FILETIME
+  // --upload-file just sets CURLOPT_UPLOAD and CURLOPT_INFILESIZE_LARGE
+  let expectedMethod = "GET";
+  if (request.data || request.multipartUploads) {
+    expectedMethod = "POST";
+  }
+  if (!eq(request.urls[0].method, expectedMethod)) {
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, " +
+      repr(request.urls[0].method, imports) +
+      ");\n";
+  }
+
+  if (request.interface) {
+    const interface_ = repr(request.interface, imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_INTERFACE, " + interface_ + ");\n";
+  }
+
+  if (request.krb) {
+    const krb = repr(request.krb, imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_KRBLEVEL, " + krb + ");\n";
+  }
+
+  if (request.connectTimeout) {
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_CONNECTTIMEOUT_MS, " +
+      atof1000(request.connectTimeout, imports) +
+      ");\n";
+  }
+
+  if (request.dohUrl) {
+    const dohUrl = repr(request.dohUrl, imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_DOH_URL, " + dohUrl + ");\n";
+  }
+
+  if (request.ciphers) {
+    const ciphers = repr(request.ciphers, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_SSL_CIPHER_LIST, " + ciphers + ");\n";
+  }
+  if (request.proxyCiphers) {
+    const proxyCiphers = repr(request.proxyCiphers, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_PROXY_SSL_CIPHER_LIST, " +
+      proxyCiphers +
+      ");\n";
+  }
+  if (request.tls13Ciphers) {
+    const tls13Ciphers = repr(request.tls13Ciphers, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_TLS13_CIPHERS, " + tls13Ciphers + ");\n";
+  }
+  if (request.proxyTls13Ciphers) {
+    const proxyTls13Ciphers = repr(request.proxyTls13Ciphers, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_PROXY_TLS13_CIPHERS, " +
+      proxyTls13Ciphers +
+      ");\n";
+  }
+
+  if (request.verbose) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_VERBOSE, 1L);\n";
+  }
+  if (request.maxFilesize) {
+    // TODO: parse
+    const maxFilesize = atol(request.maxFilesize, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_MAXFILESIZE_LARGE, (curl_off_t)" +
+      maxFilesize +
+      ");\n";
+  }
+
+  // TODO: these should be mutually exclusive
+  if (request.ipv6) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_IPRESOLVE, 2L);\n";
+  } else if (request.ipv4) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_IPRESOLVE, 1L);\n";
+  }
+
+  if (request.sslReqd || request.ssl) {
+    if (request.sslReqd) {
+      code +=
+        "  curl_easy_setopt(hnd, CURLOPT_USE_SSL, (long)CURLUSESSL_ALL);\n";
+    } else if (request.ssl) {
+      code +=
+        "  curl_easy_setopt(hnd, CURLOPT_USE_SSL, (long)CURLUSESSL_TRY);\n";
+    }
+  }
+
+  if (request.socks5GssapiNec) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_SOCKS5_GSSAPI_NEC, 1L);\n";
+  }
+
+  if (request.socks5Basic) {
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_SOCKS5_AUTH, (long)CURLAUTH_BASIC);\n";
+  } else if (request.socks5Gssapi) {
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_SOCKS5_AUTH, (long)CURLAUTH_GSSNEGOTIATE);\n";
+  }
+
+  if (request.socks5GssapiService) {
+    const socks5GssapiService = repr(request.socks5GssapiService, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_PROXY_SERVICE_NAME, " +
+      socks5GssapiService +
+      ");\n";
+  }
+
+  if (request.serviceName) {
+    const serviceName = repr(request.serviceName, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_SERVICE_NAME, " + serviceName + ");\n";
+  }
+  if (request.proxyServiceName) {
+    const proxyServiceName = repr(request.proxyServiceName, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_PROXY_SERVICE_NAME, " +
+      proxyServiceName +
+      ");\n";
+  }
+
+  // TODO: check
+  if (request.ignoreContentLength) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_IGNORE_CONTENT_LENGTH, 1L);\n";
+  }
+
+  if (request.ftpSkipPasvIp !== false) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_FTP_SKIP_PASV_IP, 1L);\n";
+  }
+  if (request.keepAlive !== false) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_TCP_KEEPALIVE, 1L);\n";
+    if (request.keepAliveTime) {
+      const keepAliveTime = atol(request.keepAliveTime, imports);
+      code +=
+        "  curl_easy_setopt(hnd, CURLOPT_TCP_KEEPIDLE, " +
+        keepAliveTime +
+        ");\n";
+      code +=
+        "  curl_easy_setopt(hnd, CURLOPT_TCP_KEEPINTVL, " +
+        keepAliveTime +
+        ");\n";
+    }
+  }
+
+  if (request.proto) {
+    // TODO: parse
+    const proto = repr(request.proto, imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_PROTOCOLS_STR, " + proto + ");\n";
+  }
+  if (request.protoRedir) {
+    // TODO: parse
+    const protoRedir = repr(request.protoRedir, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_REDIR_PROTOCOLS_STR, " +
+      protoRedir +
+      ");\n";
+  }
+
+  if (request.resolve) {
+    preamble += "  struct curl_slist *resolve;\n";
+
+    if (vars) {
+      vars += "\n";
+    }
+    vars += "  resolve = NULL;\n";
+    for (const line of request.resolve) {
+      vars +=
+        "  resolve = curl_slist_append(resolve, " +
+        repr(line, imports) +
+        ");\n";
+    }
+
+    code += "  curl_easy_setopt(hnd, CURLOPT_RESOLVE, resolve);\n";
+
+    cleanup += "  curl_slist_free_all(resolve);\n";
+    cleanup += "  resolve = NULL;\n";
+  }
+  if (request.connectTo) {
+    // TODO: camelCase snake_case orjustoneword?
+    preamble += "  struct curl_slist *connect_to;\n";
+
+    if (vars) {
+      vars += "\n";
+    }
+    vars += "  connect_to = NULL;\n";
+    for (const line of request.connectTo) {
+      vars +=
+        "  connect_to = curl_slist_append(connect_to, " +
+        repr(line, imports) +
+        ");\n";
+    }
+
+    code += "  curl_easy_setopt(hnd, CURLOPT_CONNECT_TO, connect_to);\n";
+
+    cleanup += "  curl_slist_free_all(connect_to);\n";
+    cleanup += "  connect_to = NULL;\n";
+  }
+
+  if (request.tlsuser) {
+    const tlsuser = repr(request.tlsuser, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_TLSAUTH_USERNAME, " + tlsuser + ");\n";
+  }
+  if (request.tlspassword) {
+    const tlspassword = repr(request.tlspassword, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_TLSAUTH_PASSWORD, " +
+      tlspassword +
+      ");\n";
+  }
+  if (request.tlsauthtype) {
+    const tlsauthtype = repr(request.tlsauthtype, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_TLSAUTH_TYPE, " + tlsauthtype + ");\n";
+  }
+
+  if (request.proxyTlsuser) {
+    const proxyTlsuser = repr(request.proxyTlsuser, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_PROXY_TLSAUTH_USERNAME, " +
+      proxyTlsuser +
+      ");\n";
+  }
+  if (request.proxyTlspassword) {
+    const proxyTlspassword = repr(request.proxyTlspassword, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_PROXY_TLSAUTH_PASSWORD, " +
+      proxyTlspassword +
+      ");\n";
+  }
+  if (request.proxyTlsauthtype) {
+    const proxyTlsauthtype = repr(request.proxyTlsauthtype, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_PROXY_TLSAUTH_TYPE, " +
+      proxyTlsauthtype +
+      ");\n";
+  }
+
+  if (request.delegation) {
+    if (eq(request.delegation, "always")) {
+      code += "  curl_easy_setopt(hnd, CURLOPT_GSSAPI_DELEGATION, 2L);\n";
+    } else if (eq(request.delegation, "policy")) {
+      code += "  curl_easy_setopt(hnd, CURLOPT_GSSAPI_DELEGATION, 1L);\n";
+    }
+  }
+
+  if (request.saslAuthzid) {
+    const zid = repr(request.saslAuthzid, imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_SASL_AUTHZID, " + zid + ");\n";
+  }
+  if (request.saslIr) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_SASL_IR, 1L);\n";
+  }
+
+  if (request.alpn === false) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_SSL_ENABLE_ALPN, 0L);\n";
+  }
+
+  if (request.unixSocket) {
+    const socket = repr(request.unixSocket, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_UNIX_SOCKET_PATH, " + socket + ");\n";
+  }
+  if (request.abstractUnixSocket) {
+    const socket = repr(request.abstractUnixSocket, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_ABSTRACT_UNIX_SOCKET, " +
+      socket +
+      ");\n";
+  }
+
+  if (request.protoDefault) {
+    const protoDefault = repr(request.protoDefault, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_DEFAULT_PROTOCOL, " +
+      protoDefault +
+      ");\n";
+  }
+
+  if (request.expect100Timeout) {
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_EXPECT_100_TIMEOUT_MS, " +
+      atof1000(request.expect100Timeout, imports) +
+      ");\n";
+  }
+  if (request.happyEyeballsTimeoutMs) {
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS, " +
+      atol(request.happyEyeballsTimeoutMs, imports) +
+      ");\n";
+  }
+
+  if (request.haproxyClientIp) {
+    const haproxyClientIp = repr(request.haproxyClientIp, imports);
+    code +=
+      "  curl_easy_setopt(hnd, CURLOPT_HAPROXY_CLIENT_IP, " +
+      haproxyClientIp +
+      ");\n";
+  }
+  if (request.haproxyProtocol) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_HAPROXYPROTOCOL, 1L);\n";
+  }
+
+  if (request.disallowUsernameInUrl) {
+    code += "  curl_easy_setopt(hnd, CURLOPT_DISALLOW_USERNAME_IN_URL, 1L);\n";
+  }
+
+  if (request.altSvc) {
+    const altSvc = repr(request.altSvc, imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_ALTSVC, " + altSvc + ");\n";
+  }
+
+  if (request.hsts) {
+    // TODO: warn that files aren't read?
+    const hsts = repr(request.hsts[request.hsts.length - 1], imports);
+    code += "  curl_easy_setopt(hnd, CURLOPT_HSTS, " + hsts + ");\n";
+  }
+
+  code += "\n";
+  code += "  ret = curl_easy_perform(hnd);\n";
+
+  let end = "";
+  end += "  return (int)ret;\n";
+  end += "}\n";
+
+  return (
+    preamble +
+    (vars ? "\n" + vars : "") +
+    "\n" +
+    code +
+    "\n" +
+    cleanup +
+    "\n" +
+    end
+  );
+}
+
+export function printImports(imps: Set<string>): string {
+  let s = "";
+  for (const imp of Array.from(imps).sort()) {
+    s += "#include <" + imp + ">\n";
+  }
+  return s;
+}
+
+export function _toC(requests: Request[], warnings: Warnings = []): string {
+  const imports = new Set<string>(["curl/curl.h"]);
+
+  const request = getFirst(requests, warnings, { cookieFiles: true });
+  const code = requestToC(request, warnings, imports);
+
+  return printImports(imports) + "\n" + code;
+}
+
+export function toCWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const c = _toC(requests, warnings);
+  return [c, warnings];
+}
+
+export function toC(curlCommand: string | string[]): string {
+  return toCWarn(curlCommand)[0];
+}