npm - koffi - Versions diffs - 2.1.0-beta.3 → 2.1.0 - Mend

koffi 2.1.0-beta.3 → 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (250) hide show

package/doc/dist/html/types.html DELETED Viewed

@@ -1,1061 +0,0 @@
-<!doctype html>
-<html class="no-js" lang="en">
-  <head><meta charset="utf-8"/>
-    <meta name="viewport" content="width=device-width,initial-scale=1"/>
-    <meta name="color-scheme" content="light dark"><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
-<link rel="index" title="Index" href="genindex" /><link rel="search" title="Search" href="search" /><link rel="next" title="Functions" href="functions" /><link rel="prev" title="Quick start" href="start" />
-    <meta name="generator" content="sphinx-5.0.1, furo 2022.06.04.1"/>
-        <title>Data types - Koffi</title>
-      <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
-    <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?digest=40978830699223671f4072448e654b5958f38b89" />
-    <link rel="stylesheet" type="text/css" href="_static/styles/furo-extensions.css?digest=30d1aed668e5c3a91c3e3bf6a60b675221979f0e" />
-    <link rel="stylesheet" type="text/css" href="_static/custom.css" />
-<style>
-  body {
-    --color-code-background: #f8f8f8;
-  --color-code-foreground: black;
-  --color-brand-primary: #FF6600;
-  --color-brand-content: #FF6600;
-  }
-  @media not print {
-    body[data-theme="dark"] {
-      --color-code-background: #202020;
-  --color-code-foreground: #d0d0d0;
-  --color-brand-primary: #FF6600;
-  --color-brand-content: #FF6600;
-    }
-    @media (prefers-color-scheme: dark) {
-      body:not([data-theme="light"]) {
-        --color-code-background: #202020;
-  --color-code-foreground: #d0d0d0;
-  --color-brand-primary: #FF6600;
-  --color-brand-content: #FF6600;
-      }
-    }
-  }
-</style></head>
-  <body>
-    <script>
-      document.body.dataset.theme = localStorage.getItem("theme") || "auto";
-    </script>
-<svg xmlns="http://www.w3.org/2000/svg" style="display: none;">
-  <symbol id="svg-toc" viewBox="0 0 24 24">
-    <title>Contents</title>
-    <svg stroke="currentColor" fill="currentColor" stroke-width="0" viewBox="0 0 1024 1024">
-      <path d="M408 442h480c4.4 0 8-3.6 8-8v-56c0-4.4-3.6-8-8-8H408c-4.4 0-8 3.6-8 8v56c0 4.4 3.6 8 8 8zm-8 204c0 4.4 3.6 8 8 8h480c4.4 0 8-3.6 8-8v-56c0-4.4-3.6-8-8-8H408c-4.4 0-8 3.6-8 8v56zm504-486H120c-4.4 0-8 3.6-8 8v56c0 4.4 3.6 8 8 8h784c4.4 0 8-3.6 8-8v-56c0-4.4-3.6-8-8-8zm0 632H120c-4.4 0-8 3.6-8 8v56c0 4.4 3.6 8 8 8h784c4.4 0 8-3.6 8-8v-56c0-4.4-3.6-8-8-8zM115.4 518.9L271.7 642c5.8 4.6 14.4.5 14.4-6.9V388.9c0-7.4-8.5-11.5-14.4-6.9L115.4 505.1a8.74 8.74 0 0 0 0 13.8z"/>
-    </svg>
-  </symbol>
-  <symbol id="svg-menu" viewBox="0 0 24 24">
-    <title>Menu</title>
-    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor"
-      stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather-menu">
-      <line x1="3" y1="12" x2="21" y2="12"></line>
-      <line x1="3" y1="6" x2="21" y2="6"></line>
-      <line x1="3" y1="18" x2="21" y2="18"></line>
-    </svg>
-  </symbol>
-  <symbol id="svg-arrow-right" viewBox="0 0 24 24">
-    <title>Expand</title>
-    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor"
-      stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather-chevron-right">
-      <polyline points="9 18 15 12 9 6"></polyline>
-    </svg>
-  </symbol>
-  <symbol id="svg-sun" viewBox="0 0 24 24">
-    <title>Light mode</title>
-    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor"
-      stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" class="feather-sun">
-      <circle cx="12" cy="12" r="5"></circle>
-      <line x1="12" y1="1" x2="12" y2="3"></line>
-      <line x1="12" y1="21" x2="12" y2="23"></line>
-      <line x1="4.22" y1="4.22" x2="5.64" y2="5.64"></line>
-      <line x1="18.36" y1="18.36" x2="19.78" y2="19.78"></line>
-      <line x1="1" y1="12" x2="3" y2="12"></line>
-      <line x1="21" y1="12" x2="23" y2="12"></line>
-      <line x1="4.22" y1="19.78" x2="5.64" y2="18.36"></line>
-      <line x1="18.36" y1="5.64" x2="19.78" y2="4.22"></line>
-    </svg>
-  </symbol>
-  <symbol id="svg-moon" viewBox="0 0 24 24">
-    <title>Dark mode</title>
-    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor"
-      stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" class="icon-tabler-moon">
-      <path stroke="none" d="M0 0h24v24H0z" fill="none" />
-      <path d="M12 3c.132 0 .263 0 .393 0a7.5 7.5 0 0 0 7.92 12.446a9 9 0 1 1 -8.313 -12.454z" />
-    </svg>
-  </symbol>
-  <symbol id="svg-sun-half" viewBox="0 0 24 24">
-    <title>Auto light/dark mode</title>
-    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor"
-      stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" class="icon-tabler-shadow">
-      <path stroke="none" d="M0 0h24v24H0z" fill="none"/>
-      <circle cx="12" cy="12" r="9" />
-      <path d="M13 12h5" />
-      <path d="M13 15h4" />
-      <path d="M13 18h1" />
-      <path d="M13 9h4" />
-      <path d="M13 6h1" />
-    </svg>
-  </symbol>
-</svg>
-<input type="checkbox" class="sidebar-toggle" name="__navigation" id="__navigation">
-<input type="checkbox" class="sidebar-toggle" name="__toc" id="__toc">
-<label class="overlay sidebar-overlay" for="__navigation">
-  <div class="visually-hidden">Hide navigation sidebar</div>
-</label>
-<label class="overlay toc-overlay" for="__toc">
-  <div class="visually-hidden">Hide table of contents sidebar</div>
-</label>
-<div class="page">
-  <header class="mobile-header">
-    <div class="header-left">
-      <label class="nav-overlay-icon" for="__navigation">
-        <div class="visually-hidden">Toggle site navigation sidebar</div>
-        <i class="icon"><svg><use href="#svg-menu"></use></svg></i>
-      </label>
-    </div>
-    <div class="header-center">
-      <a href="index"><div class="brand">Koffi</div></a>
-    </div>
-    <div class="header-right">
-      <div class="theme-toggle-container theme-toggle-header">
-        <button class="theme-toggle">
-          <div class="visually-hidden">Toggle Light / Dark / Auto color theme</div>
-          <svg class="theme-icon-when-auto"><use href="#svg-sun-half"></use></svg>
-          <svg class="theme-icon-when-dark"><use href="#svg-moon"></use></svg>
-          <svg class="theme-icon-when-light"><use href="#svg-sun"></use></svg>
-        </button>
-      </div>
-      <label class="toc-overlay-icon toc-header-icon" for="__toc">
-        <div class="visually-hidden">Toggle table of contents sidebar</div>
-        <i class="icon"><svg><use href="#svg-toc"></use></svg></i>
-      </label>
-    </div>
-  </header>
-  <aside class="sidebar-drawer">
-    <div class="sidebar-container">
-      <div class="sidebar-sticky"><a class="sidebar-brand" href="index">
-  <span class="sidebar-brand-text">Koffi</span>
-</a><form class="sidebar-search-container" method="get" action="search" role="search">
-  <input class="sidebar-search" placeholder=Search name="q" aria-label="Search">
-  <input type="hidden" name="check_keywords" value="yes">
-  <input type="hidden" name="area" value="default">
-</form>
-<div id="searchbox"></div><div class="sidebar-scroll"><div class="sidebar-tree">
-  <ul class="current">
-<li class="toctree-l1"><a class="reference internal" href="platforms">Requirements</a></li>
-<li class="toctree-l1"><a class="reference internal" href="start">Quick start</a></li>
-<li class="toctree-l1 current current-page"><a class="current reference internal" href="#">Data types</a></li>
-<li class="toctree-l1"><a class="reference internal" href="functions">Functions</a></li>
-<li class="toctree-l1"><a class="reference internal" href="memory">Memory usage</a></li>
-<li class="toctree-l1"><a class="reference internal" href="benchmarks">Benchmarks</a></li>
-<li class="toctree-l1"><a class="reference internal" href="contribute">Contributing</a></li>
-<li class="toctree-l1"><a class="reference internal" href="changes">Changelog</a></li>
-</ul>
-</div>
-<div style="text-align: center; margin-top: 2em;">
-    <a href="https://www.npmjs.com/package/koffi"><img src="https://img.shields.io/badge/NPM-2.O.1-brightgreen" alt="NPM"/></a>
-    <a href="https://github.com/Koromix/luigi/tree/master/koffi"><img src="https://img.shields.io/badge/GitHub-Koffi-ff6600" alt="GitHub"/></a>
-</div></div>
-      </div>
-    </div>
-  </aside>
-  <div class="main">
-    <div class="content">
-      <div class="article-container">
-        <a href="#" class="back-to-top muted-link">
-          <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
-            <path d="M13 20h-2V8l-5.5 5.5-1.42-1.42L12 4.16l7.92 7.92-1.42 1.42L13 8v12z"></path>
-          </svg>
-          <span>Back to top</span>
-        </a>
-        <div class="content-icon-container">
-          <div class="theme-toggle-container theme-toggle-content">
-            <button class="theme-toggle">
-              <div class="visually-hidden">Toggle Light / Dark / Auto color theme</div>
-              <svg class="theme-icon-when-auto"><use href="#svg-sun-half"></use></svg>
-              <svg class="theme-icon-when-dark"><use href="#svg-moon"></use></svg>
-              <svg class="theme-icon-when-light"><use href="#svg-sun"></use></svg>
-            </button>
-          </div>
-          <label class="toc-overlay-icon toc-content-icon" for="__toc">
-            <div class="visually-hidden">Toggle table of contents sidebar</div>
-            <i class="icon"><svg><use href="#svg-toc"></use></svg></i>
-          </label>
-        </div>
-        <article role="main">
-          <section id="data-types">
-<h1>Data types<a class="headerlink" href="#data-types" title="Permalink to this heading">#</a></h1>
-<section id="primitive-types">
-<h2>Primitive types<a class="headerlink" href="#primitive-types" title="Permalink to this heading">#</a></h2>
-<section id="standard-types">
-<h3>Standard types<a class="headerlink" href="#standard-types" title="Permalink to this heading">#</a></h3>
-<p>While the C standard allows for variation in the size of most integer types, Koffi enforces the same definition for most primitive types, listed below:</p>
-<div class="table-wrapper colwidths-auto docutils container">
-<table class="docutils align-default">
-<thead>
-<tr class="row-odd"><th class="head"><p>JS type</p></th>
-<th class="head"><p>C type</p></th>
-<th class="head"><p>Bytes</p></th>
-<th class="head"><p>Signedness</p></th>
-<th class="head"><p>Note</p></th>
-</tr>
-</thead>
-<tbody>
-<tr class="row-even"><td><p>Undefined</p></td>
-<td><p>void</p></td>
-<td><p>0</p></td>
-<td><p></p></td>
-<td><p>Only valid as a return type</p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>int8, int8_t</p></td>
-<td><p>1</p></td>
-<td><p>Signed</p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-even"><td><p>Number (integer)</p></td>
-<td><p>uint8, uint8_t</p></td>
-<td><p>1</p></td>
-<td><p>Unsigned</p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>char</p></td>
-<td><p>1</p></td>
-<td><p>Signed</p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-even"><td><p>Number (integer)</p></td>
-<td><p>uchar, unsigned char</p></td>
-<td><p>1</p></td>
-<td><p>Unsigned</p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>char16, char16_t</p></td>
-<td><p>2</p></td>
-<td><p>Signed</p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-even"><td><p>Number (integer)</p></td>
-<td><p>int16, int16_t</p></td>
-<td><p>2</p></td>
-<td><p>Signed</p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>uint16, uint16_t</p></td>
-<td><p>2</p></td>
-<td><p>Unsigned</p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-even"><td><p>Number (integer)</p></td>
-<td><p>short</p></td>
-<td><p>2</p></td>
-<td><p>Signed</p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>ushort, unsigned short</p></td>
-<td><p>2</p></td>
-<td><p>Unsigned</p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-even"><td><p>Number (integer)</p></td>
-<td><p>int32, int32_t</p></td>
-<td><p>4</p></td>
-<td><p>Signed</p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>uint32, uint32_t</p></td>
-<td><p>4</p></td>
-<td><p>Unsigned</p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-even"><td><p>Number (integer)</p></td>
-<td><p>int</p></td>
-<td><p>4</p></td>
-<td><p>Signed</p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>uint, unsigned int</p></td>
-<td><p>4</p></td>
-<td><p>Unsigned</p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-even"><td><p>Number (integer)</p></td>
-<td><p>int64, int64_t</p></td>
-<td><p>8</p></td>
-<td><p>Signed</p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>uint64, uint64_t</p></td>
-<td><p>8</p></td>
-<td><p>Unsigned</p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-even"><td><p>Number (integer)</p></td>
-<td><p>longlong, long long</p></td>
-<td><p>8</p></td>
-<td><p>Signed</p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>ulonglong, unsigned long long</p></td>
-<td><p>8</p></td>
-<td><p>Unsigned</p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-even"><td><p>Number (float)</p></td>
-<td><p>float32</p></td>
-<td><p>4</p></td>
-<td><p></p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (float)</p></td>
-<td><p>float64</p></td>
-<td><p>8</p></td>
-<td><p></p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-even"><td><p>Number (float)</p></td>
-<td><p>float</p></td>
-<td><p>4</p></td>
-<td><p></p></td>
-<td><p></p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (float)</p></td>
-<td><p>double</p></td>
-<td><p>8</p></td>
-<td><p></p></td>
-<td><p></p></td>
-</tr>
-</tbody>
-</table>
-</div>
-<p>Koffi also accepts BigInt values when converting from JS to C integers. If the value exceeds the range of the C type, Koffi will convert the number to an undefined value. In the reverse direction, BigInt values are automatically used when needed for big 64-bit integers.</p>
-<p>Koffi defines a few more types that can change size depending on the OS and the architecture:</p>
-<div class="table-wrapper colwidths-auto docutils container">
-<table class="docutils align-default">
-<thead>
-<tr class="row-odd"><th class="head"><p>JS type</p></th>
-<th class="head"><p>C type</p></th>
-<th class="head"><p>Signedness</p></th>
-<th class="head"><p>Note</p></th>
-</tr>
-</thead>
-<tbody>
-<tr class="row-even"><td><p>Boolean</p></td>
-<td><p>bool</p></td>
-<td><p></p></td>
-<td><p>Usually one byte</p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>long</p></td>
-<td><p>Signed</p></td>
-<td><p>4 or 8 bytes depending on platform (LP64, LLP64)</p></td>
-</tr>
-<tr class="row-even"><td><p>Number (integer)</p></td>
-<td><p>ulong</p></td>
-<td><p>Unsigned</p></td>
-<td><p>4 or 8 bytes depending on platform (LP64, LLP64)</p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>unsigned long</p></td>
-<td><p>Unsigned</p></td>
-<td><p>4 or 8 bytes depending on platform (LP64, LLP64)</p></td>
-</tr>
-<tr class="row-even"><td><p>Number (integer)</p></td>
-<td><p>intptr</p></td>
-<td><p>Signed</p></td>
-<td><p>4 or 8 bytes depending on register width</p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>intptr_t</p></td>
-<td><p>Signed</p></td>
-<td><p>4 or 8 bytes depending on register width</p></td>
-</tr>
-<tr class="row-even"><td><p>Number (integer)</p></td>
-<td><p>uintptr</p></td>
-<td><p>Unsigned</p></td>
-<td><p>4 or 8 bytes depending on register width</p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>uintptr_t</p></td>
-<td><p>Unsigned</p></td>
-<td><p>4 or 8 bytes depending on register width</p></td>
-</tr>
-<tr class="row-even"><td><p>String</p></td>
-<td><p>str, string</p></td>
-<td><p></p></td>
-<td><p>JS strings are converted to and from UTF-8</p></td>
-</tr>
-<tr class="row-odd"><td><p>String</p></td>
-<td><p>str16, string16</p></td>
-<td><p></p></td>
-<td><p>JS strings are converted to and from UTF-16 (LE)</p></td>
-</tr>
-</tbody>
-</table>
-</div>
-<p>Primitive types can be specified by name (in a string) or through <code class="docutils literal notranslate"><span class="pre">koffi.types</span></code>:</p>
-<div class="highlight-js notranslate"><div class="highlight"><pre><span></span><span class="linenos">1</span><span class="c1">// These two lines do the same:</span>
-<span class="linenos">2</span><span class="kd">let</span> <span class="nx">struct1</span> <span class="o">=</span> <span class="nx">koffi</span><span class="p">.</span><span class="nx">struct</span><span class="p">({</span> <span class="nx">dummy</span><span class="o">:</span> <span class="s1">&#39;long&#39;</span> <span class="p">});</span>
-<span class="linenos">3</span><span class="kd">let</span> <span class="nx">struct2</span> <span class="o">=</span> <span class="nx">koffi</span><span class="p">.</span><span class="nx">struct</span><span class="p">({</span> <span class="nx">dummy</span><span class="o">:</span> <span class="nx">koffi</span><span class="p">.</span><span class="nx">types</span><span class="p">.</span><span class="kr">long</span> <span class="p">});</span>
-</pre></div>
-</div>
-</section>
-<section id="endian-sensitive-types">
-<h3>Endian-sensitive types<a class="headerlink" href="#endian-sensitive-types" title="Permalink to this heading">#</a></h3>
-<p>Koffi defines a bunch of endian-sensitive types, which can be used when dealing with binary data (network payloads, binary file formats, etc.).</p>
-<div class="table-wrapper colwidths-auto docutils container">
-<table class="docutils align-default">
-<thead>
-<tr class="row-odd"><th class="head"><p>JS type</p></th>
-<th class="head"><p>C type</p></th>
-<th class="head"><p>Bytes</p></th>
-<th class="head"><p>Signedness</p></th>
-<th class="head"><p>Endianness</p></th>
-</tr>
-</thead>
-<tbody>
-<tr class="row-even"><td><p>Number (integer)</p></td>
-<td><p>int16_le, int16_le_t</p></td>
-<td><p>2</p></td>
-<td><p>Signed</p></td>
-<td><p>Little Endian</p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>int16_be, int16_be_t</p></td>
-<td><p>2</p></td>
-<td><p>Signed</p></td>
-<td><p>Big Endian</p></td>
-</tr>
-<tr class="row-even"><td><p>Number (integer)</p></td>
-<td><p>uint16_le, uint16_le_t</p></td>
-<td><p>2</p></td>
-<td><p>Unsigned</p></td>
-<td><p>Little Endian</p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>uint16_be, uint16_be_t</p></td>
-<td><p>2</p></td>
-<td><p>Unsigned</p></td>
-<td><p>Big Endian</p></td>
-</tr>
-<tr class="row-even"><td><p>Number (integer)</p></td>
-<td><p>int32_le, int32_le_t</p></td>
-<td><p>4</p></td>
-<td><p>Signed</p></td>
-<td><p>Little Endian</p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>int32_be, int32_be_t</p></td>
-<td><p>4</p></td>
-<td><p>Signed</p></td>
-<td><p>Big Endian</p></td>
-</tr>
-<tr class="row-even"><td><p>Number (integer)</p></td>
-<td><p>uint32_le, uint32_le_t</p></td>
-<td><p>4</p></td>
-<td><p>Unsigned</p></td>
-<td><p>Little Endian</p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>uint32_be, uint32_be_t</p></td>
-<td><p>4</p></td>
-<td><p>Unsigned</p></td>
-<td><p>Big Endian</p></td>
-</tr>
-<tr class="row-even"><td><p>Number (integer)</p></td>
-<td><p>int64_le, int64_le_t</p></td>
-<td><p>8</p></td>
-<td><p>Signed</p></td>
-<td><p>Little Endian</p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>int64_be, int64_be_t</p></td>
-<td><p>8</p></td>
-<td><p>Signed</p></td>
-<td><p>Big Endian</p></td>
-</tr>
-<tr class="row-even"><td><p>Number (integer)</p></td>
-<td><p>uint64_le, uint64_le_t</p></td>
-<td><p>8</p></td>
-<td><p>Unsigned</p></td>
-<td><p>Little Endian</p></td>
-</tr>
-<tr class="row-odd"><td><p>Number (integer)</p></td>
-<td><p>uint64_be, uint64_be_t</p></td>
-<td><p>8</p></td>
-<td><p>Unsigned</p></td>
-<td><p>Big Endian</p></td>
-</tr>
-</tbody>
-</table>
-</div>
-</section>
-</section>
-<section id="struct-types">
-<h2>Struct types<a class="headerlink" href="#struct-types" title="Permalink to this heading">#</a></h2>
-<section id="struct-definition">
-<h3>Struct definition<a class="headerlink" href="#struct-definition" title="Permalink to this heading">#</a></h3>
-<p>Koffi converts JS objects to C structs, and vice-versa.</p>
-<p>Unlike function declarations, as of now there is only one way to create a struct type, with the <code class="docutils literal notranslate"><span class="pre">koffi.struct()</span></code> function. This function takes two arguments: the first one is the name of the type, and the second one is an object containing the struct member names and types. You can omit the first argument to declare an anonymous struct.</p>
-<p>The following example illustrates how to declare the same struct in C and in JS with Koffi:</p>
-<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="linenos">1</span><span class="k">typedef</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">A</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
-<span class="linenos">2</span><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">a</span><span class="p">;</span><span class="w"></span>
-<span class="linenos">3</span><span class="w">    </span><span class="kt">char</span><span class="w"> </span><span class="n">b</span><span class="p">;</span><span class="w"></span>
-<span class="linenos">4</span><span class="w">    </span><span class="k">const</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">c</span><span class="p">;</span><span class="w"></span>
-<span class="linenos">5</span><span class="w">    </span><span class="k">struct</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
-<span class="linenos">6</span><span class="w">        </span><span class="kt">double</span><span class="w"> </span><span class="n">d1</span><span class="p">;</span><span class="w"></span>
-<span class="linenos">7</span><span class="w">        </span><span class="kt">double</span><span class="w"> </span><span class="n">d2</span><span class="p">;</span><span class="w"></span>
-<span class="linenos">8</span><span class="w">    </span><span class="p">}</span><span class="w"> </span><span class="n">d</span><span class="p">;</span><span class="w"></span>
-<span class="linenos">9</span><span class="p">}</span><span class="w"> </span><span class="n">A</span><span class="p">;</span><span class="w"></span>
-</pre></div>
-</div>
-<div class="highlight-js notranslate"><div class="highlight"><pre><span></span><span class="linenos">1</span><span class="kd">const</span> <span class="nx">A</span> <span class="o">=</span> <span class="nx">koffi</span><span class="p">.</span><span class="nx">struct</span><span class="p">(</span><span class="s1">&#39;A&#39;</span><span class="p">,</span> <span class="p">{</span>
-<span class="linenos">2</span>    <span class="nx">a</span><span class="o">:</span> <span class="s1">&#39;int&#39;</span><span class="p">,</span>
-<span class="linenos">3</span>    <span class="nx">b</span><span class="o">:</span> <span class="s1">&#39;char&#39;</span><span class="p">,</span>
-<span class="linenos">4</span>    <span class="nx">c</span><span class="o">:</span> <span class="s1">&#39;const char *&#39;</span><span class="p">,</span> <span class="c1">// Koffi does not care about const, it is ignored</span>
-<span class="linenos">5</span>    <span class="nx">d</span><span class="o">:</span> <span class="nx">koffi</span><span class="p">.</span><span class="nx">struct</span><span class="p">({</span>
-<span class="linenos">6</span>        <span class="nx">d1</span><span class="o">:</span> <span class="s1">&#39;double&#39;</span><span class="p">,</span>
-<span class="linenos">7</span>        <span class="nx">d2</span><span class="o">:</span> <span class="s1">&#39;double&#39;</span>
-<span class="linenos">8</span>    <span class="p">})</span>
-<span class="linenos">9</span><span class="p">});</span>
-</pre></div>
-</div>
-<p>Koffi follows the C and ABI rules regarding struct alignment and padding.</p>
-<p>Once a struct is declared, you can use it by name (with a string, like you can do for primitive types) or through the value returned by the call to <code class="docutils literal notranslate"><span class="pre">koffi.struct()</span></code>. Only the latter is possible when declaring an anonymous struct.</p>
-<div class="highlight-js notranslate"><div class="highlight"><pre><span></span><span class="linenos">1</span><span class="c1">// The following two function declarations are equivalent, and declare a function taking an A value and returning A</span>
-<span class="linenos">2</span><span class="kd">const</span> <span class="nx">Function1</span> <span class="o">=</span> <span class="nx">lib</span><span class="p">.</span><span class="nx">func</span><span class="p">(</span><span class="s1">&#39;A Function(A value)&#39;</span><span class="p">);</span>
-<span class="linenos">3</span><span class="kd">const</span> <span class="nx">Function2</span> <span class="o">=</span> <span class="nx">lib</span><span class="p">.</span><span class="nx">func</span><span class="p">(</span><span class="s1">&#39;Function&#39;</span><span class="p">,</span> <span class="nx">A</span><span class="p">,</span> <span class="p">[</span><span class="nx">A</span><span class="p">]);</span>
-</pre></div>
-</div>
-<p>Koffi automatically follows the platform C ABI regarding alignment and padding. However, you can override these rules if needed with:</p>
-<ul class="simple">
-<li><p>Pack all members without padding with <code class="docutils literal notranslate"><span class="pre">koffi.pack()</span></code> (instead of <code class="docutils literal notranslate"><span class="pre">koffi.struct()</span></code>)</p></li>
-<li><p>Change alignment of a specific member as shown below</p></li>
-</ul>
-<div class="highlight-js notranslate"><div class="highlight"><pre><span></span><span class="linenos"> 1</span><span class="c1">// This struct is 3 bytes long</span>
-<span class="linenos"> 2</span><span class="kd">const</span> <span class="nx">PackedStruct</span> <span class="o">=</span> <span class="nx">koffi</span><span class="p">.</span><span class="nx">pack</span><span class="p">(</span><span class="s1">&#39;PackedStruct&#39;</span><span class="p">,</span> <span class="p">{</span>
-<span class="linenos"> 3</span>    <span class="nx">a</span><span class="o">:</span> <span class="s1">&#39;int8_t&#39;</span><span class="p">,</span>
-<span class="linenos"> 4</span>    <span class="nx">b</span><span class="o">:</span> <span class="s1">&#39;int16_t&#39;</span>
-<span class="linenos"> 5</span><span class="p">});</span>
-<span class="linenos"> 6</span>
-<span class="linenos"> 7</span><span class="c1">// This one is 18 bytes long, the second member has an alignment requirement of 16 bytes</span>
-<span class="linenos"> 8</span><span class="kd">const</span> <span class="nx">BigStruct</span> <span class="o">=</span> <span class="nx">koffi</span><span class="p">.</span><span class="nx">struct</span><span class="p">(</span><span class="s1">&#39;BigStruct&#39;</span><span class="p">,</span> <span class="p">{</span>
-<span class="linenos"> 9</span>    <span class="nx">a</span><span class="o">:</span> <span class="s1">&#39;int8_t&#39;</span><span class="p">,</span>
-<span class="linenos">10</span>    <span class="nx">b</span><span class="o">:</span> <span class="p">[</span><span class="mf">16</span><span class="p">,</span> <span class="s1">&#39;int16_t&#39;</span><span class="p">]</span>
-<span class="linenos">11</span><span class="p">})</span>
-</pre></div>
-</div>
-</section>
-<section id="opaque-types">
-<h3>Opaque types<a class="headerlink" href="#opaque-types" title="Permalink to this heading">#</a></h3>
-<p>Many C libraries use some kind of object-oriented API, with a pair of functions dedicated to create and delete objects. An obvious example of this can be found in stdio.h, with the opaque <code class="docutils literal notranslate"><span class="pre">FILE</span> <span class="pre">*</span></code> pointer. You can open and close files with <code class="docutils literal notranslate"><span class="pre">fopen()</span></code> and <code class="docutils literal notranslate"><span class="pre">fclose()</span></code>, and manipule the opaque pointer with other functions such as <code class="docutils literal notranslate"><span class="pre">fread()</span></code> or <code class="docutils literal notranslate"><span class="pre">ftell()</span></code>.</p>
-<p>In Koffi, you can manage this with opaque types. Declare the opaque type with <code class="docutils literal notranslate"><span class="pre">koffi.opaque(name)</span></code>, and use a pointer to this type either as a return type or some kind of <a class="reference internal" href="functions#output-parameters"><span class="std std-doc">output parameter</span></a> (with a double pointer).</p>
-<div class="admonition note">
-<p class="admonition-title">Note</p>
-<p>Opaque types <strong>have changed in version 2.0, and again in version 2.1</strong>.</p>
-<p>In Koffi 1.x, opaque handles were defined in a way that made them usable directly as parameter and return types, obscuring the underlying pointer.</p>
-<p>Now, you must use them through a pointer, and use an array for output parameters. This is shown in the example below (look for the call to <code class="docutils literal notranslate"><span class="pre">ConcatNewOut</span></code> in the JS part), and is described in the section on <a class="reference internal" href="functions#output-parameters"><span class="std std-doc">output parameters</span></a>.</p>
-<p>In addition to this, you should use <code class="docutils literal notranslate"><span class="pre">koffi.opaque()</span></code> (introduced in Koffi 2.1) instead of <code class="docutils literal notranslate"><span class="pre">koffi.handle()</span></code> which is deprecated, and will be removed eventually in Koffi 3.0.</p>
-<p>Consult the <a class="reference internal" href="changes"><span class="doc std std-doc">migration guide</span></a> for more information.</p>
-</div>
-<p>The full example below implements an iterative string builder (concatenator) in C, and uses it from Javascript to output a mix of Hello World and FizzBuzz. The builder is hidden behind an opaque type, and is created and destroyed using a pair of C functions: <code class="docutils literal notranslate"><span class="pre">ConcatNew</span></code> (or <code class="docutils literal notranslate"><span class="pre">ConcatNewOut</span></code>) and <code class="docutils literal notranslate"><span class="pre">ConcatFree</span></code>.</p>
-<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="linenos">  1</span><span class="c1">// Build with: clang -fPIC -o handles.so -shared handles.c -Wall -O2</span>
-<span class="linenos">  2</span>
-<span class="linenos">  3</span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdlib.h&gt;</span><span class="cp"></span>
-<span class="linenos">  4</span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdbool.h&gt;</span><span class="cp"></span>
-<span class="linenos">  5</span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdio.h&gt;</span><span class="cp"></span>
-<span class="linenos">  6</span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;errno.h&gt;</span><span class="cp"></span>
-<span class="linenos">  7</span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;string.h&gt;</span><span class="cp"></span>
-<span class="linenos">  8</span>
-<span class="linenos">  9</span><span class="k">typedef</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">Fragment</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
-<span class="linenos"> 10</span><span class="w">    </span><span class="k">struct</span><span class="w"> </span><span class="nc">Fragment</span><span class="w"> </span><span class="o">*</span><span class="n">next</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 11</span>
-<span class="linenos"> 12</span><span class="w">    </span><span class="kt">size_t</span><span class="w"> </span><span class="n">len</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 13</span><span class="w">    </span><span class="kt">char</span><span class="w"> </span><span class="n">str</span><span class="p">[];</span><span class="w"></span>
-<span class="linenos"> 14</span><span class="p">}</span><span class="w"> </span><span class="n">Fragment</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 15</span>
-<span class="linenos"> 16</span><span class="k">typedef</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">Concat</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
-<span class="linenos"> 17</span><span class="w">    </span><span class="n">Fragment</span><span class="w"> </span><span class="o">*</span><span class="n">first</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 18</span><span class="w">    </span><span class="n">Fragment</span><span class="w"> </span><span class="o">*</span><span class="n">last</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 19</span>
-<span class="linenos"> 20</span><span class="w">    </span><span class="kt">size_t</span><span class="w"> </span><span class="n">total</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 21</span><span class="p">}</span><span class="w"> </span><span class="n">Concat</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 22</span>
-<span class="linenos"> 23</span><span class="kt">bool</span><span class="w"> </span><span class="nf">ConcatNewOut</span><span class="p">(</span><span class="n">Concat</span><span class="w"> </span><span class="o">**</span><span class="n">out</span><span class="p">)</span><span class="w"></span>
-<span class="linenos"> 24</span><span class="p">{</span><span class="w"></span>
-<span class="linenos"> 25</span><span class="w">    </span><span class="n">Concat</span><span class="w"> </span><span class="o">*</span><span class="n">c</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="o">*</span><span class="n">c</span><span class="p">));</span><span class="w"></span>
-<span class="linenos"> 26</span><span class="w">    </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="o">!</span><span class="n">c</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
-<span class="linenos"> 27</span><span class="w">        </span><span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;Failed to allocate memory: %s</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">,</span><span class="w"> </span><span class="n">strerror</span><span class="p">(</span><span class="n">errno</span><span class="p">));</span><span class="w"></span>
-<span class="linenos"> 28</span><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="nb">false</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 29</span><span class="w">    </span><span class="p">}</span><span class="w"></span>
-<span class="linenos"> 30</span>
-<span class="linenos"> 31</span><span class="w">    </span><span class="n">c</span><span class="o">-&gt;</span><span class="n">first</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">NULL</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 32</span><span class="w">    </span><span class="n">c</span><span class="o">-&gt;</span><span class="n">last</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">NULL</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 33</span><span class="w">    </span><span class="n">c</span><span class="o">-&gt;</span><span class="n">total</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 34</span>
-<span class="linenos"> 35</span><span class="w">    </span><span class="o">*</span><span class="n">out</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">c</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 36</span><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="nb">true</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 37</span><span class="p">}</span><span class="w"></span>
-<span class="linenos"> 38</span>
-<span class="linenos"> 39</span><span class="n">Concat</span><span class="w"> </span><span class="o">*</span><span class="nf">ConcatNew</span><span class="p">()</span><span class="w"></span>
-<span class="linenos"> 40</span><span class="p">{</span><span class="w"></span>
-<span class="linenos"> 41</span><span class="w">    </span><span class="n">Concat</span><span class="w"> </span><span class="o">*</span><span class="n">c</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">NULL</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 42</span><span class="w">    </span><span class="n">ConcatNewOut</span><span class="p">(</span><span class="o">&amp;</span><span class="n">c</span><span class="p">);</span><span class="w"></span>
-<span class="linenos"> 43</span><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="n">c</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 44</span><span class="p">}</span><span class="w"></span>
-<span class="linenos"> 45</span>
-<span class="linenos"> 46</span><span class="kt">void</span><span class="w"> </span><span class="nf">ConcatFree</span><span class="p">(</span><span class="n">Concat</span><span class="w"> </span><span class="o">*</span><span class="n">c</span><span class="p">)</span><span class="w"></span>
-<span class="linenos"> 47</span><span class="p">{</span><span class="w"></span>
-<span class="linenos"> 48</span><span class="w">    </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="o">!</span><span class="n">c</span><span class="p">)</span><span class="w"></span>
-<span class="linenos"> 49</span><span class="w">        </span><span class="k">return</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 50</span>
-<span class="linenos"> 51</span><span class="w">    </span><span class="n">Fragment</span><span class="w"> </span><span class="o">*</span><span class="n">f</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">c</span><span class="o">-&gt;</span><span class="n">first</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 52</span>
-<span class="linenos"> 53</span><span class="w">    </span><span class="k">while</span><span class="w"> </span><span class="p">(</span><span class="n">f</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
-<span class="linenos"> 54</span><span class="w">        </span><span class="n">Fragment</span><span class="w"> </span><span class="o">*</span><span class="n">next</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">f</span><span class="o">-&gt;</span><span class="n">next</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 55</span><span class="w">        </span><span class="n">free</span><span class="p">(</span><span class="n">f</span><span class="p">);</span><span class="w"></span>
-<span class="linenos"> 56</span><span class="w">        </span><span class="n">f</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">next</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 57</span><span class="w">    </span><span class="p">}</span><span class="w"></span>
-<span class="linenos"> 58</span>
-<span class="linenos"> 59</span><span class="w">    </span><span class="n">free</span><span class="p">(</span><span class="n">c</span><span class="p">);</span><span class="w"></span>
-<span class="linenos"> 60</span><span class="p">}</span><span class="w"></span>
-<span class="linenos"> 61</span>
-<span class="linenos"> 62</span><span class="kt">bool</span><span class="w"> </span><span class="nf">ConcatAppend</span><span class="p">(</span><span class="n">Concat</span><span class="w"> </span><span class="o">*</span><span class="n">c</span><span class="p">,</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">frag</span><span class="p">)</span><span class="w"></span>
-<span class="linenos"> 63</span><span class="p">{</span><span class="w"></span>
-<span class="linenos"> 64</span><span class="w">    </span><span class="kt">size_t</span><span class="w"> </span><span class="n">len</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">strlen</span><span class="p">(</span><span class="n">frag</span><span class="p">);</span><span class="w"></span>
-<span class="linenos"> 65</span>
-<span class="linenos"> 66</span><span class="w">    </span><span class="n">Fragment</span><span class="w"> </span><span class="o">*</span><span class="n">f</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="o">*</span><span class="n">f</span><span class="p">)</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">len</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">);</span><span class="w"></span>
-<span class="linenos"> 67</span><span class="w">    </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="o">!</span><span class="n">f</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
-<span class="linenos"> 68</span><span class="w">        </span><span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;Failed to allocate memory: %s</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">,</span><span class="w"> </span><span class="n">strerror</span><span class="p">(</span><span class="n">errno</span><span class="p">));</span><span class="w"></span>
-<span class="linenos"> 69</span><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="nb">false</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 70</span><span class="w">    </span><span class="p">}</span><span class="w"></span>
-<span class="linenos"> 71</span>
-<span class="linenos"> 72</span><span class="w">    </span><span class="n">f</span><span class="o">-&gt;</span><span class="n">next</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">NULL</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 73</span><span class="w">    </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">c</span><span class="o">-&gt;</span><span class="n">last</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
-<span class="linenos"> 74</span><span class="w">        </span><span class="n">c</span><span class="o">-&gt;</span><span class="n">last</span><span class="o">-&gt;</span><span class="n">next</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">f</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 75</span><span class="w">    </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
-<span class="linenos"> 76</span><span class="w">        </span><span class="n">c</span><span class="o">-&gt;</span><span class="n">first</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">f</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 77</span><span class="w">    </span><span class="p">}</span><span class="w"></span>
-<span class="linenos"> 78</span><span class="w">    </span><span class="n">c</span><span class="o">-&gt;</span><span class="n">last</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">f</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 79</span><span class="w">    </span><span class="n">c</span><span class="o">-&gt;</span><span class="n">total</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="n">len</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 80</span>
-<span class="linenos"> 81</span><span class="w">    </span><span class="n">f</span><span class="o">-&gt;</span><span class="n">len</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">len</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 82</span><span class="w">    </span><span class="n">memcpy</span><span class="p">(</span><span class="n">f</span><span class="o">-&gt;</span><span class="n">str</span><span class="p">,</span><span class="w"> </span><span class="n">frag</span><span class="p">,</span><span class="w"> </span><span class="n">len</span><span class="p">);</span><span class="w"></span>
-<span class="linenos"> 83</span><span class="w">    </span><span class="n">f</span><span class="o">-&gt;</span><span class="n">str</span><span class="p">[</span><span class="n">len</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 84</span>
-<span class="linenos"> 85</span><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="nb">true</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 86</span><span class="p">}</span><span class="w"></span>
-<span class="linenos"> 87</span>
-<span class="linenos"> 88</span><span class="k">const</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="nf">ConcatBuild</span><span class="p">(</span><span class="n">Concat</span><span class="w"> </span><span class="o">*</span><span class="n">c</span><span class="p">)</span><span class="w"></span>
-<span class="linenos"> 89</span><span class="p">{</span><span class="w"></span>
-<span class="linenos"> 90</span><span class="w">    </span><span class="n">Fragment</span><span class="w"> </span><span class="o">*</span><span class="n">r</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="o">*</span><span class="n">r</span><span class="p">)</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">c</span><span class="o">-&gt;</span><span class="n">total</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">);</span><span class="w"></span>
-<span class="linenos"> 91</span><span class="w">    </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="o">!</span><span class="n">r</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
-<span class="linenos"> 92</span><span class="w">        </span><span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;Failed to allocate memory: %s</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">,</span><span class="w"> </span><span class="n">strerror</span><span class="p">(</span><span class="n">errno</span><span class="p">));</span><span class="w"></span>
-<span class="linenos"> 93</span><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="nb">NULL</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 94</span><span class="w">    </span><span class="p">}</span><span class="w"></span>
-<span class="linenos"> 95</span>
-<span class="linenos"> 96</span><span class="w">    </span><span class="n">r</span><span class="o">-&gt;</span><span class="n">next</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">NULL</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 97</span><span class="w">    </span><span class="n">r</span><span class="o">-&gt;</span><span class="n">len</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"></span>
-<span class="linenos"> 98</span>
-<span class="linenos"> 99</span><span class="w">    </span><span class="n">Fragment</span><span class="w"> </span><span class="o">*</span><span class="n">f</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">c</span><span class="o">-&gt;</span><span class="n">first</span><span class="p">;</span><span class="w"></span>
-<span class="linenos">100</span>
-<span class="linenos">101</span><span class="w">    </span><span class="k">while</span><span class="w"> </span><span class="p">(</span><span class="n">f</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
-<span class="linenos">102</span><span class="w">        </span><span class="n">Fragment</span><span class="w"> </span><span class="o">*</span><span class="n">next</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">f</span><span class="o">-&gt;</span><span class="n">next</span><span class="p">;</span><span class="w"></span>
-<span class="linenos">103</span>
-<span class="linenos">104</span><span class="w">        </span><span class="n">memcpy</span><span class="p">(</span><span class="n">r</span><span class="o">-&gt;</span><span class="n">str</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">r</span><span class="o">-&gt;</span><span class="n">len</span><span class="p">,</span><span class="w"> </span><span class="n">f</span><span class="o">-&gt;</span><span class="n">str</span><span class="p">,</span><span class="w"> </span><span class="n">f</span><span class="o">-&gt;</span><span class="n">len</span><span class="p">);</span><span class="w"></span>
-<span class="linenos">105</span><span class="w">        </span><span class="n">r</span><span class="o">-&gt;</span><span class="n">len</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="n">f</span><span class="o">-&gt;</span><span class="n">len</span><span class="p">;</span><span class="w"></span>
-<span class="linenos">106</span>
-<span class="linenos">107</span><span class="w">        </span><span class="n">free</span><span class="p">(</span><span class="n">f</span><span class="p">);</span><span class="w"></span>
-<span class="linenos">108</span><span class="w">        </span><span class="n">f</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">next</span><span class="p">;</span><span class="w"></span>
-<span class="linenos">109</span><span class="w">    </span><span class="p">}</span><span class="w"></span>
-<span class="linenos">110</span><span class="w">    </span><span class="n">r</span><span class="o">-&gt;</span><span class="n">str</span><span class="p">[</span><span class="n">r</span><span class="o">-&gt;</span><span class="n">len</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"></span>
-<span class="linenos">111</span>
-<span class="linenos">112</span><span class="w">    </span><span class="n">c</span><span class="o">-&gt;</span><span class="n">first</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">r</span><span class="p">;</span><span class="w"></span>
-<span class="linenos">113</span><span class="w">    </span><span class="n">c</span><span class="o">-&gt;</span><span class="n">last</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">r</span><span class="p">;</span><span class="w"></span>
-<span class="linenos">114</span>
-<span class="linenos">115</span><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="n">r</span><span class="o">-&gt;</span><span class="n">str</span><span class="p">;</span><span class="w"></span>
-<span class="linenos">116</span><span class="p">}</span><span class="w"></span>
-</pre></div>
-</div>
-<div class="highlight-js notranslate"><div class="highlight"><pre><span></span><span class="linenos"> 1</span><span class="kd">const</span> <span class="nx">koffi</span> <span class="o">=</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;koffi&#39;</span><span class="p">);</span>
-<span class="linenos"> 2</span><span class="kd">const</span> <span class="nx">lib</span> <span class="o">=</span> <span class="nx">koffi</span><span class="p">.</span><span class="nx">load</span><span class="p">(</span><span class="s1">&#39;./handles.so&#39;</span><span class="p">);</span>
-<span class="linenos"> 3</span>
-<span class="linenos"> 4</span><span class="kd">const</span> <span class="nx">Concat</span> <span class="o">=</span> <span class="nx">koffi</span><span class="p">.</span><span class="nx">opaque</span><span class="p">(</span><span class="s1">&#39;Concat&#39;</span><span class="p">);</span>
-<span class="linenos"> 5</span><span class="kd">const</span> <span class="nx">ConcatNewOut</span> <span class="o">=</span> <span class="nx">lib</span><span class="p">.</span><span class="nx">func</span><span class="p">(</span><span class="s1">&#39;bool ConcatNewOut(_Out_ Concat **out)&#39;</span><span class="p">);</span>
-<span class="linenos"> 6</span><span class="kd">const</span> <span class="nx">ConcatNew</span> <span class="o">=</span> <span class="nx">lib</span><span class="p">.</span><span class="nx">func</span><span class="p">(</span><span class="s1">&#39;Concat *ConcatNew()&#39;</span><span class="p">);</span>
-<span class="linenos"> 7</span><span class="kd">const</span> <span class="nx">ConcatFree</span> <span class="o">=</span> <span class="nx">lib</span><span class="p">.</span><span class="nx">func</span><span class="p">(</span><span class="s1">&#39;void ConcatFree(Concat *c)&#39;</span><span class="p">);</span>
-<span class="linenos"> 8</span><span class="kd">const</span> <span class="nx">ConcatAppend</span> <span class="o">=</span> <span class="nx">lib</span><span class="p">.</span><span class="nx">func</span><span class="p">(</span><span class="s1">&#39;bool ConcatAppend(Concat *c, const char *frag)&#39;</span><span class="p">);</span>
-<span class="linenos"> 9</span><span class="kd">const</span> <span class="nx">ConcatBuild</span> <span class="o">=</span> <span class="nx">lib</span><span class="p">.</span><span class="nx">func</span><span class="p">(</span><span class="s1">&#39;const char *ConcatBuild(Concat *c)&#39;</span><span class="p">);</span>
-<span class="linenos">10</span>
-<span class="linenos">11</span><span class="kd">let</span> <span class="nx">c</span> <span class="o">=</span> <span class="nx">ConcatNew</span><span class="p">();</span>
-<span class="linenos">12</span><span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="nx">c</span><span class="p">)</span> <span class="p">{</span>
-<span class="linenos">13</span>    <span class="c1">// This is stupid, it does the same, but try both versions (return value, output parameter)</span>
-<span class="linenos">14</span>    <span class="kd">let</span> <span class="nx">ptr</span> <span class="o">=</span> <span class="p">[</span><span class="kc">null</span><span class="p">];</span>
-<span class="linenos">15</span>    <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="nx">ConcatNewOut</span><span class="p">(</span><span class="nx">ptr</span><span class="p">))</span>
-<span class="linenos">16</span>        <span class="k">throw</span> <span class="ow">new</span> <span class="ne">Error</span><span class="p">(</span><span class="s1">&#39;Allocation failure&#39;</span><span class="p">);</span>
-<span class="linenos">17</span>    <span class="nx">c</span> <span class="o">=</span> <span class="nx">ptr</span><span class="p">[</span><span class="mf">0</span><span class="p">];</span>
-<span class="linenos">18</span><span class="p">}</span>
-<span class="linenos">19</span>
-<span class="linenos">20</span><span class="k">try</span> <span class="p">{</span>
-<span class="linenos">21</span>    <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="nx">ConcatAppend</span><span class="p">(</span><span class="nx">c</span><span class="p">,</span> <span class="s1">&#39;Hello... &#39;</span><span class="p">))</span>
-<span class="linenos">22</span>        <span class="k">throw</span> <span class="ow">new</span> <span class="ne">Error</span><span class="p">(</span><span class="s1">&#39;Allocation failure&#39;</span><span class="p">);</span>
-<span class="linenos">23</span>    <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="nx">ConcatAppend</span><span class="p">(</span><span class="nx">c</span><span class="p">,</span> <span class="s1">&#39;World!\n&#39;</span><span class="p">))</span>
-<span class="linenos">24</span>        <span class="k">throw</span> <span class="ow">new</span> <span class="ne">Error</span><span class="p">(</span><span class="s1">&#39;Allocation failure&#39;</span><span class="p">);</span>
-<span class="linenos">25</span>
-<span class="linenos">26</span>    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mf">1</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;=</span> <span class="mf">30</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
-<span class="linenos">27</span>        <span class="kd">let</span> <span class="nx">frag</span><span class="p">;</span>
-<span class="linenos">28</span>        <span class="k">if</span> <span class="p">(</span><span class="nx">i</span> <span class="o">%</span> <span class="mf">15</span> <span class="o">==</span> <span class="mf">0</span><span class="p">)</span> <span class="p">{</span>
-<span class="linenos">29</span>            <span class="nx">frag</span> <span class="o">=</span> <span class="s1">&#39;FizzBuzz&#39;</span><span class="p">;</span>
-<span class="linenos">30</span>        <span class="p">}</span> <span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="nx">i</span> <span class="o">%</span> <span class="mf">5</span> <span class="o">==</span> <span class="mf">0</span><span class="p">)</span> <span class="p">{</span>
-<span class="linenos">31</span>            <span class="nx">frag</span> <span class="o">=</span> <span class="s1">&#39;Buzz&#39;</span><span class="p">;</span>
-<span class="linenos">32</span>        <span class="p">}</span> <span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="nx">i</span> <span class="o">%</span> <span class="mf">3</span> <span class="o">==</span> <span class="mf">0</span><span class="p">)</span> <span class="p">{</span>
-<span class="linenos">33</span>            <span class="nx">frag</span> <span class="o">=</span> <span class="s1">&#39;Fizz&#39;</span><span class="p">;</span>
-<span class="linenos">34</span>        <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
-<span class="linenos">35</span>            <span class="nx">frag</span> <span class="o">=</span> <span class="nb">String</span><span class="p">(</span><span class="nx">i</span><span class="p">);</span>
-<span class="linenos">36</span>        <span class="p">}</span>
-<span class="linenos">37</span>
-<span class="linenos">38</span>        <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="nx">ConcatAppend</span><span class="p">(</span><span class="nx">c</span><span class="p">,</span> <span class="nx">frag</span><span class="p">))</span>
-<span class="linenos">39</span>            <span class="k">throw</span> <span class="ow">new</span> <span class="ne">Error</span><span class="p">(</span><span class="s1">&#39;Allocation failure&#39;</span><span class="p">);</span>
-<span class="linenos">40</span>        <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="nx">ConcatAppend</span><span class="p">(</span><span class="nx">c</span><span class="p">,</span> <span class="s1">&#39; &#39;</span><span class="p">))</span>
-<span class="linenos">41</span>            <span class="k">throw</span> <span class="ow">new</span> <span class="ne">Error</span><span class="p">(</span><span class="s1">&#39;Allocation failure&#39;</span><span class="p">);</span>
-<span class="linenos">42</span>    <span class="p">}</span>
-<span class="linenos">43</span>
-<span class="linenos">44</span>    <span class="kd">let</span> <span class="nx">str</span> <span class="o">=</span> <span class="nx">ConcatBuild</span><span class="p">(</span><span class="nx">c</span><span class="p">);</span>
-<span class="linenos">45</span>    <span class="k">if</span> <span class="p">(</span><span class="nx">str</span> <span class="o">==</span> <span class="kc">null</span><span class="p">)</span>
-<span class="linenos">46</span>        <span class="k">throw</span> <span class="ow">new</span> <span class="ne">Error</span><span class="p">(</span><span class="s1">&#39;Allocation failure&#39;</span><span class="p">);</span>
-<span class="linenos">47</span>    <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">str</span><span class="p">);</span>
-<span class="linenos">48</span><span class="p">}</span> <span class="k">finally</span> <span class="p">{</span>
-<span class="linenos">49</span>    <span class="nx">ConcatFree</span><span class="p">(</span><span class="nx">c</span><span class="p">);</span>
-<span class="linenos">50</span><span class="p">}</span>
-</pre></div>
-</div>
-</section>
-</section>
-<section id="pointer-types">
-<h2>Pointer types<a class="headerlink" href="#pointer-types" title="Permalink to this heading">#</a></h2>
-<p>In C, pointer arguments are used for differenty purposes. It is important to distinguish these use cases because Koffi provides different ways to deal with each of them:</p>
-<ul class="simple">
-<li><p><strong>Struct pointers</strong>: Use of struct pointers by C libraries fall in two cases: avoid (potentially) expensive copies, and to let the function change struct contents (output or input/output arguments).</p></li>
-<li><p><strong>Opaque pointers</strong>: the library does not expose the contents of the structs, and only provides you with a pointer to it (e.g. <code class="docutils literal notranslate"><span class="pre">FILE</span> <span class="pre">*</span></code>). Only the functions provided by the library can do something with this pointer, in Koffi we call this an opaque type. This is usually done for ABI-stability reason, and to prevent library users from messing directly with library internals.</p></li>
-<li><p><strong>Pointers to primitive types</strong>: This is more rare, and generally used for output or input/output arguments. The Win32 API has a lot of these.</p></li>
-<li><p><strong>Arrays</strong>: in C, you dynamically-sized arrays are usually passed to functions with pointers, either NULL-terminated (or any other sentinel value) or with an additional length argument.</p></li>
-</ul>
-<section id="struct-pointers">
-<h3>Struct pointers<a class="headerlink" href="#struct-pointers" title="Permalink to this heading">#</a></h3>
-<p>The following Win32 example uses <code class="docutils literal notranslate"><span class="pre">GetCursorPos()</span></code> (with an output parameter) to retrieve and show the current cursor position.</p>
-<div class="highlight-js notranslate"><div class="highlight"><pre><span></span><span class="linenos"> 1</span><span class="kd">const</span> <span class="nx">koffi</span> <span class="o">=</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;koffi&#39;</span><span class="p">);</span>
-<span class="linenos"> 2</span><span class="kd">const</span> <span class="nx">lib</span> <span class="o">=</span> <span class="nx">koffi</span><span class="p">.</span><span class="nx">load</span><span class="p">(</span><span class="s1">&#39;kernel32.dll&#39;</span><span class="p">);</span>
-<span class="linenos"> 3</span>
-<span class="linenos"> 4</span><span class="c1">// Type declarations</span>
-<span class="linenos"> 5</span><span class="kd">const</span> <span class="nx">POINT</span> <span class="o">=</span> <span class="nx">koffi</span><span class="p">.</span><span class="nx">struct</span><span class="p">(</span><span class="s1">&#39;POINT&#39;</span><span class="p">,</span> <span class="p">{</span>
-<span class="linenos"> 6</span>    <span class="nx">x</span><span class="o">:</span> <span class="s1">&#39;long&#39;</span><span class="p">,</span>
-<span class="linenos"> 7</span>    <span class="nx">y</span><span class="o">:</span> <span class="s1">&#39;long&#39;</span>
-<span class="linenos"> 8</span><span class="p">});</span>
-<span class="linenos"> 9</span>
-<span class="linenos">10</span><span class="c1">// Functions declarations</span>
-<span class="linenos">11</span><span class="kd">const</span> <span class="nx">GetCursorPos</span> <span class="o">=</span> <span class="nx">lib</span><span class="p">.</span><span class="nx">func</span><span class="p">(</span><span class="s1">&#39;int __stdcall GetCursorPos(_Out_ POINT *pos)&#39;</span><span class="p">);</span>
-<span class="linenos">12</span>
-<span class="linenos">13</span><span class="c1">// Get and show cursor position</span>
-<span class="linenos">14</span><span class="kd">let</span> <span class="nx">pos</span> <span class="o">=</span> <span class="p">{};</span>
-<span class="linenos">15</span><span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="nx">GetCursorPos</span><span class="p">(</span><span class="nx">pos</span><span class="p">))</span>
-<span class="linenos">16</span>    <span class="k">throw</span> <span class="ow">new</span> <span class="ne">Error</span><span class="p">(</span><span class="s1">&#39;Failed to get cursor position&#39;</span><span class="p">);</span>
-<span class="linenos">17</span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">pos</span><span class="p">);</span>
-</pre></div>
-</div>
-</section>
-<section id="named-pointer-types">
-<h3>Named pointer types<a class="headerlink" href="#named-pointer-types" title="Permalink to this heading">#</a></h3>
-<p><em>New in Koffi 2.0</em></p>
-<p>Some C libraries use handles, which behave as pointers to opaque structs. An example of this is the HANDLE type in the Win32 API. If you want to reproduce this behavior, you can define a <strong>named pointer type</strong> to an opaque type, like so:</p>
-<div class="highlight-js notranslate"><div class="highlight"><pre><span></span><span class="linenos">1</span><span class="kd">const</span> <span class="nx">HANDLE</span> <span class="o">=</span> <span class="nx">koffi</span><span class="p">.</span><span class="nx">pointer</span><span class="p">(</span><span class="s1">&#39;HANDLE&#39;</span><span class="p">,</span> <span class="nx">koffi</span><span class="p">.</span><span class="nx">opaque</span><span class="p">());</span>
-<span class="linenos">2</span>
-<span class="linenos">3</span><span class="c1">// And now you get to use it this way:</span>
-<span class="linenos">4</span><span class="kd">const</span> <span class="nx">GetHandleInformation</span> <span class="o">=</span> <span class="nx">lib</span><span class="p">.</span><span class="nx">func</span><span class="p">(</span><span class="s1">&#39;bool __stdcall GetHandleInformation(HANDLE h, _Out_ uint32_t *flags)&#39;</span><span class="p">);</span>
-<span class="linenos">5</span><span class="kd">const</span> <span class="nx">CloseHandle</span> <span class="o">=</span> <span class="nx">lib</span><span class="p">.</span><span class="nx">func</span><span class="p">(</span><span class="s1">&#39;bool __stdcall CloseHandle(HANDLE h)&#39;</span><span class="p">);</span>
-</pre></div>
-</div>
-</section>
-<section id="pointers-to-primitive-types">
-<h3>Pointers to primitive types<a class="headerlink" href="#pointers-to-primitive-types" title="Permalink to this heading">#</a></h3>
-<p>In javascript, it is not possible to pass a primitive value by reference to another function. This means that you cannot call a function and expect it to modify the value of one of its number or string parameter.</p>
-<p>However, arrays and objects (among others) are reference type values. Assigning an array or an object from one variable to another does not invole any copy. Instead, as the following example illustrates, the new variable references the same array as the first:</p>
-<div class="highlight-js notranslate"><div class="highlight"><pre><span></span><span class="linenos">1</span><span class="kd">let</span> <span class="nx">list1</span> <span class="o">=</span> <span class="p">[</span><span class="mf">1</span><span class="p">,</span> <span class="mf">2</span><span class="p">];</span>
-<span class="linenos">2</span><span class="kd">let</span> <span class="nx">list2</span> <span class="o">=</span> <span class="nx">list1</span><span class="p">;</span>
-<span class="linenos">3</span>
-<span class="linenos">4</span><span class="nx">list2</span><span class="p">[</span><span class="mf">1</span><span class="p">]</span> <span class="o">=</span> <span class="mf">42</span><span class="p">;</span>
-<span class="linenos">5</span>
-<span class="linenos">6</span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">list1</span><span class="p">);</span> <span class="c1">// Prints [1, 42]</span>
-</pre></div>
-</div>
-<p>All of this means that C functions that are expected to modify their primitive output values (such as an <code class="docutils literal notranslate"><span class="pre">int</span> <span class="pre">*</span></code> parameter) cannot be used directly. However, thanks to Koffi’s transparent array support, you can use Javascript arrays to approximate reference semantics with single-element arrays.</p>
-<p>Below, you can find an example of an addition function where the result is stored in an <code class="docutils literal notranslate"><span class="pre">int</span> <span class="pre">*</span></code> input/output parameter and how to use this function from Koffi.</p>
-<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="linenos">1</span><span class="kt">void</span><span class="w"> </span><span class="nf">AddInt</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="o">*</span><span class="n">dest</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">add</span><span class="p">)</span><span class="w"></span>
-<span class="linenos">2</span><span class="p">{</span><span class="w"></span>
-<span class="linenos">3</span><span class="w">    </span><span class="o">*</span><span class="n">dest</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="n">add</span><span class="p">;</span><span class="w"></span>
-<span class="linenos">4</span><span class="p">}</span><span class="w"></span>
-</pre></div>
-</div>
-<p>You can simply pass a single-element array as the first argument:</p>
-<div class="highlight-js notranslate"><div class="highlight"><pre><span></span><span class="linenos">1</span><span class="kd">const</span> <span class="nx">AddInt</span> <span class="o">=</span> <span class="nx">lib</span><span class="p">.</span><span class="nx">func</span><span class="p">(</span><span class="s1">&#39;void AddInt(_Inout_ int *dest, int add)&#39;</span><span class="p">);</span>
-<span class="linenos">2</span>
-<span class="linenos">3</span><span class="kd">let</span> <span class="nx">sum</span> <span class="o">=</span> <span class="p">[</span><span class="mf">36</span><span class="p">];</span>
-<span class="linenos">4</span><span class="nx">AddInt</span><span class="p">(</span><span class="nx">sum</span><span class="p">,</span> <span class="mf">6</span><span class="p">);</span>
-<span class="linenos">5</span>
-<span class="linenos">6</span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">sum</span><span class="p">[</span><span class="mf">0</span><span class="p">]);</span> <span class="c1">// Prints 42</span>
-</pre></div>
-</div>
-</section>
-</section>
-<section id="array-types">
-<h2>Array types<a class="headerlink" href="#array-types" title="Permalink to this heading">#</a></h2>
-<section id="fixed-size-c-arrays">
-<h3>Fixed-size C arrays<a class="headerlink" href="#fixed-size-c-arrays" title="Permalink to this heading">#</a></h3>
-<p>Fixed-size arrays are declared with <code class="docutils literal notranslate"><span class="pre">koffi.array(type,</span> <span class="pre">length)</span></code>. Just like in C, they cannot be passed as functions parameters (they degenerate to pointers), or returned by value. You can however embed them in struct types.</p>
-<p>Koffi applies the following conversion rules when passing arrays to/from C:</p>
-<ul class="simple">
-<li><p><strong>JS to C</strong>: Koffi can take a normal Array (e.g. <code class="docutils literal notranslate"><span class="pre">[1,</span> <span class="pre">2]</span></code>) or a TypedArray of the correct type (e.g. <code class="docutils literal notranslate"><span class="pre">Uint8Array</span></code> for an array of <code class="docutils literal notranslate"><span class="pre">uint8_t</span></code> numbers)</p></li>
-<li><p><strong>C to JS</strong> (return value, output parameters, callbacks): Koffi will use a TypedArray if possible. But you can change this behavior when you create the array type with the optional hint argument: <code class="docutils literal notranslate"><span class="pre">koffi.array('uint8_t',</span> <span class="pre">64,</span> <span class="pre">'array')</span></code>. For non-number types, such as arrays of strings or structs, Koffi creates normal arrays.</p></li>
-</ul>
-<p>See the example below:</p>
-<div class="highlight-js notranslate"><div class="highlight"><pre><span></span><span class="linenos"> 1</span><span class="kd">const</span> <span class="nx">koffi</span> <span class="o">=</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;koffi&#39;</span><span class="p">);</span>
-<span class="linenos"> 2</span>
-<span class="linenos"> 3</span><span class="c1">// Those two structs are exactly the same, only the array conversion hint is different</span>
-<span class="linenos"> 4</span><span class="kd">const</span> <span class="nx">Foo1</span> <span class="o">=</span> <span class="nx">koffi</span><span class="p">.</span><span class="nx">struct</span><span class="p">(</span><span class="s1">&#39;Foo&#39;</span><span class="p">,</span> <span class="p">{</span>
-<span class="linenos"> 5</span>    <span class="nx">i</span><span class="o">:</span> <span class="s1">&#39;int&#39;</span><span class="p">,</span>
-<span class="linenos"> 6</span>    <span class="nx">a16</span><span class="o">:</span> <span class="nx">koffi</span><span class="p">.</span><span class="nx">array</span><span class="p">(</span><span class="s1">&#39;int16_t&#39;</span><span class="p">,</span> <span class="mf">8</span><span class="p">)</span>
-<span class="linenos"> 7</span><span class="p">});</span>
-<span class="linenos"> 8</span><span class="kd">const</span> <span class="nx">Foo2</span> <span class="o">=</span> <span class="nx">koffi</span><span class="p">.</span><span class="nx">struct</span><span class="p">(</span><span class="s1">&#39;Foo&#39;</span><span class="p">,</span> <span class="p">{</span>
-<span class="linenos"> 9</span>    <span class="nx">i</span><span class="o">:</span> <span class="s1">&#39;int&#39;</span><span class="p">,</span>
-<span class="linenos">10</span>    <span class="nx">a16</span><span class="o">:</span> <span class="nx">koffi</span><span class="p">.</span><span class="nx">array</span><span class="p">(</span><span class="s1">&#39;int16_t&#39;</span><span class="p">,</span> <span class="mf">8</span><span class="p">,</span> <span class="s1">&#39;array&#39;</span><span class="p">)</span>
-<span class="linenos">11</span><span class="p">});</span>
-<span class="linenos">12</span>
-<span class="linenos">13</span><span class="c1">// Uses an hypothetical C function that just returns the struct passed as a parameter</span>
-<span class="linenos">14</span><span class="kd">const</span> <span class="nx">ReturnFoo1</span> <span class="o">=</span> <span class="nx">lib</span><span class="p">.</span><span class="nx">func</span><span class="p">(</span><span class="s1">&#39;Foo1 ReturnFoo(Foo1 p)&#39;</span><span class="p">);</span>
-<span class="linenos">15</span><span class="kd">const</span> <span class="nx">ReturnFoo2</span> <span class="o">=</span> <span class="nx">lib</span><span class="p">.</span><span class="nx">func</span><span class="p">(</span><span class="s1">&#39;Foo2 ReturnFoo(Foo2 p)&#39;</span><span class="p">);</span>
-<span class="linenos">16</span>
-<span class="linenos">17</span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">ReturnFoo1</span><span class="p">({</span> <span class="nx">i</span><span class="o">:</span> <span class="mf">5</span><span class="p">,</span> <span class="nx">a16</span><span class="o">:</span> <span class="p">[</span><span class="mf">6</span><span class="p">,</span> <span class="mf">8</span><span class="p">]</span> <span class="p">}))</span> <span class="c1">// Prints { i: 5, a16: Int16Array(2) [6, 8] }</span>
-<span class="linenos">18</span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">ReturnFoo2</span><span class="p">({</span> <span class="nx">i</span><span class="o">:</span> <span class="mf">5</span><span class="p">,</span> <span class="nx">a16</span><span class="o">:</span> <span class="p">[</span><span class="mf">6</span><span class="p">,</span> <span class="mf">8</span><span class="p">]</span> <span class="p">}))</span> <span class="c1">// Prints { i: 5, a16: [6, 8] }</span>
-</pre></div>
-</div>
-</section>
-<section id="fixed-size-string-buffers">
-<h3>Fixed-size string buffers<a class="headerlink" href="#fixed-size-string-buffers" title="Permalink to this heading">#</a></h3>
-<p>Koffi can also convert JS strings to fixed-sized arrays in the following cases:</p>
-<ul class="simple">
-<li><p><strong>char arrays</strong> are filled with the UTF-8 encoded string, truncated if needed. The buffer is always NUL-terminated.</p></li>
-<li><p><strong>char16 (or char16_t) arrays</strong> are filled with the UTF-16 encoded string, truncated if needed. The buffer is always NUL-terminated.</p></li>
-</ul>
-<p>The reverse case is also true, Koffi can convert a C fixed-size buffer to a JS string. This happens by default for char, char16 and char16_t arrays, but you can also explicitly ask for this with the <code class="docutils literal notranslate"><span class="pre">string</span></code> array hint (e.g. <code class="docutils literal notranslate"><span class="pre">koffi.array('char',</span> <span class="pre">8,</span> <span class="pre">'string')</span></code>).</p>
-</section>
-<section id="array-pointers-dynamic-arrays">
-<h3>Array pointers (dynamic arrays)<a class="headerlink" href="#array-pointers-dynamic-arrays" title="Permalink to this heading">#</a></h3>
-<p>In C, dynamically-sized arrays are usually passed around as pointers. The length is either passed as an additional argument, or inferred from the array content itself, for example with a terminating sentinel value (such as a NULL pointers in the case of an array of strings).</p>
-<p>Koffi can translate JS arrays and TypedArrays to pointer arguments. However, because C does not have a proper notion of dynamically-sized arrays (fat pointers), you need to provide the length or the sentinel value yourself depending on the API.</p>
-<p>Here is a simple example of a C function taking a NULL-terminated list of strings as input, to calculate the total length of all strings.</p>
-<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="linenos"> 1</span><span class="c1">// Build with: clang -fPIC -o length.so -shared length.c -Wall -O2</span>
-<span class="linenos"> 2</span>
-<span class="linenos"> 3</span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdlib.h&gt;</span><span class="cp"></span>
-<span class="linenos"> 4</span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdint.h&gt;</span><span class="cp"></span>
-<span class="linenos"> 5</span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;string.h&gt;</span><span class="cp"></span>
-<span class="linenos"> 6</span>
-<span class="linenos"> 7</span><span class="kt">int64_t</span><span class="w"> </span><span class="nf">ComputeTotalLength</span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">**</span><span class="n">strings</span><span class="p">)</span><span class="w"></span>
-<span class="linenos"> 8</span><span class="p">{</span><span class="w"></span>
-<span class="linenos"> 9</span><span class="w">    </span><span class="kt">int64_t</span><span class="w"> </span><span class="n">total</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"></span>
-<span class="linenos">10</span>
-<span class="linenos">11</span><span class="w">    </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">**</span><span class="n">ptr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">strings</span><span class="p">;</span><span class="w"> </span><span class="o">*</span><span class="n">ptr</span><span class="p">;</span><span class="w"> </span><span class="n">ptr</span><span class="o">++</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
-<span class="linenos">12</span><span class="w">        </span><span class="k">const</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">str</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">*</span><span class="n">ptr</span><span class="p">;</span><span class="w"></span>
-<span class="linenos">13</span><span class="w">        </span><span class="n">total</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="n">strlen</span><span class="p">(</span><span class="n">str</span><span class="p">);</span><span class="w"></span>
-<span class="linenos">14</span><span class="w">    </span><span class="p">}</span><span class="w"></span>
-<span class="linenos">15</span>
-<span class="linenos">16</span><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="n">total</span><span class="p">;</span><span class="w"></span>
-<span class="linenos">17</span><span class="p">}</span><span class="w"></span>
-</pre></div>
-</div>
-<div class="highlight-js notranslate"><div class="highlight"><pre><span></span><span class="linenos">1</span><span class="kd">const</span> <span class="nx">koffi</span> <span class="o">=</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;koffi&#39;</span><span class="p">);</span>
-<span class="linenos">2</span><span class="kd">const</span> <span class="nx">lib</span> <span class="o">=</span> <span class="nx">koffi</span><span class="p">.</span><span class="nx">load</span><span class="p">(</span><span class="s1">&#39;./length.so&#39;</span><span class="p">);</span>
-<span class="linenos">3</span>
-<span class="linenos">4</span><span class="kd">const</span> <span class="nx">ComputeTotalLength</span> <span class="o">=</span> <span class="nx">lib</span><span class="p">.</span><span class="nx">func</span><span class="p">(</span><span class="s1">&#39;int64_t ComputeTotalLength(const char **strings)&#39;</span><span class="p">);</span>
-<span class="linenos">5</span>
-<span class="linenos">6</span><span class="kd">let</span> <span class="nx">strings</span> <span class="o">=</span> <span class="p">[</span><span class="s1">&#39;Get&#39;</span><span class="p">,</span> <span class="s1">&#39;Total&#39;</span><span class="p">,</span> <span class="s1">&#39;Length&#39;</span><span class="p">,</span> <span class="kc">null</span><span class="p">];</span>
-<span class="linenos">7</span><span class="kd">let</span> <span class="nx">total</span> <span class="o">=</span> <span class="nx">ComputeTotalLength</span><span class="p">(</span><span class="nx">strings</span><span class="p">);</span>
-<span class="linenos">8</span>
-<span class="linenos">9</span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">total</span><span class="p">);</span> <span class="c1">// Prints 14</span>
-</pre></div>
-</div>
-<p>By default, just like for objects, array arguments are copied from JS to C but not vice-versa. You can however change the direction as documented in the section on <a class="reference internal" href="functions#output-parameters"><span class="std std-doc">output parameters</span></a>.</p>
-</section>
-</section>
-<section id="disposable-types">
-<h2>Disposable types<a class="headerlink" href="#disposable-types" title="Permalink to this heading">#</a></h2>
-<p>Disposable types allow you to register a function that will automatically called after each C to JS conversion performed by Koffi. This can be used to avoid leaking heap-allocated strings, for example.</p>
-<p>Read the documentation for <a class="reference internal" href="functions#heap-allocated-values"><span class="std std-doc">disposable types</span></a> on the page about function calls.</p>
-</section>
-<section id="utility-functions">
-<h2>Utility functions<a class="headerlink" href="#utility-functions" title="Permalink to this heading">#</a></h2>
-<section id="type-introspection">
-<h3>Type introspection<a class="headerlink" href="#type-introspection" title="Permalink to this heading">#</a></h3>
-<p><em>New in Koffi 2.0: <code class="docutils literal notranslate"><span class="pre">koffi.resolve()</span></code></em></p>
-<p>Koffi exposes three functions to explore type information:</p>
-<ul class="simple">
-<li><p><code class="docutils literal notranslate"><span class="pre">koffi.sizeof(type)</span></code> to get the size of a type</p></li>
-<li><p><code class="docutils literal notranslate"><span class="pre">koffi.alignof(type)</span></code> to get the alignment of a type</p></li>
-<li><p><code class="docutils literal notranslate"><span class="pre">koffi.introspect(type)</span></code> to get the definition of a type in an object containing: name, primitive, size, alignment, members (structs), reference (array, pointer) and length (array)</p></li>
-<li><p><code class="docutils literal notranslate"><span class="pre">koffi.resolve(type)</span></code> to get the resolved type object from a type string</p></li>
-</ul>
-<div class="admonition note">
-<p class="admonition-title">Note</p>
-<p>The value returned by <code class="docutils literal notranslate"><span class="pre">introspect()</span></code> has <strong>changed in version 2.0</strong>.</p>
-<p>In Koffi 1.x, it could only be used with struct types and returned the object passed to koffi.struct() with the member names and types.</p>
-<p>Consult the <a class="reference internal" href="changes"><span class="doc std std-doc">migration guide</span></a> for more information.</p>
-</div>
-<p>Just like before, you can refer to primitive types by their name or through <code class="docutils literal notranslate"><span class="pre">koffi.types</span></code>:</p>
-<div class="highlight-js notranslate"><div class="highlight"><pre><span></span><span class="linenos">1</span><span class="c1">// These two lines do the same:</span>
-<span class="linenos">2</span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">koffi</span><span class="p">.</span><span class="nx">sizeof</span><span class="p">(</span><span class="s1">&#39;long&#39;</span><span class="p">));</span>
-<span class="linenos">3</span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">koffi</span><span class="p">.</span><span class="nx">sizeof</span><span class="p">(</span><span class="nx">koffi</span><span class="p">.</span><span class="nx">types</span><span class="p">.</span><span class="kr">long</span><span class="p">));</span>
-</pre></div>
-</div>
-</section>
-<section id="type-aliases">
-<h3>Type aliases<a class="headerlink" href="#type-aliases" title="Permalink to this heading">#</a></h3>
-<p><em>New in Koffi 2.0</em></p>
-<p>You can alias a type with <code class="docutils literal notranslate"><span class="pre">koffi.alias(name,</span> <span class="pre">type)</span></code>. Aliased types are completely equivalent.</p>
-</section>
-</section>
-</section>
-        </article>
-      </div>
-      <footer>
-        <div class="related-pages">
-          <a class="next-page" href="functions">
-              <div class="page-info">
-                <div class="context">
-                  <span>Next</span>
-                </div>
-                <div class="title">Functions</div>
-              </div>
-              <svg><use href="#svg-arrow-right"></use></svg>
-            </a>
-          <a class="prev-page" href="start">
-              <svg><use href="#svg-arrow-right"></use></svg>
-              <div class="page-info">
-                <div class="context">
-                  <span>Previous</span>
-                </div>
-                <div class="title">Quick start</div>
-              </div>
-            </a>
-        </div>
-        <div class="bottom-of-page">
-          <div class="left-details">
-            <div class="copyright">
-                Copyright &#169; 2022, Niels Martignène
-            </div>
-            Made with <a href="https://www.sphinx-doc.org/">Sphinx</a> and <a class="muted-link" href="https://pradyunsg.me">@pradyunsg</a>'s
-            <a href="https://github.com/pradyunsg/furo">Furo</a>
-          </div>
-          <div class="right-details">
-            <div class="icons">
-            </div>
-          </div>
-        </div>
-      </footer>
-    </div>
-    <aside class="toc-drawer">
-      <div class="toc-sticky toc-scroll">
-        <div class="toc-title-container">
-          <span class="toc-title">
-            Contents
-          </span>
-        </div>
-        <div class="toc-tree-container">
-          <div class="toc-tree">
-            <ul>
-<li><a class="reference internal" href="#">Data types</a><ul>
-<li><a class="reference internal" href="#primitive-types">Primitive types</a><ul>
-<li><a class="reference internal" href="#standard-types">Standard types</a></li>
-<li><a class="reference internal" href="#endian-sensitive-types">Endian-sensitive types</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#struct-types">Struct types</a><ul>
-<li><a class="reference internal" href="#struct-definition">Struct definition</a></li>
-<li><a class="reference internal" href="#opaque-types">Opaque types</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#pointer-types">Pointer types</a><ul>
-<li><a class="reference internal" href="#struct-pointers">Struct pointers</a></li>
-<li><a class="reference internal" href="#named-pointer-types">Named pointer types</a></li>
-<li><a class="reference internal" href="#pointers-to-primitive-types">Pointers to primitive types</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#array-types">Array types</a><ul>
-<li><a class="reference internal" href="#fixed-size-c-arrays">Fixed-size C arrays</a></li>
-<li><a class="reference internal" href="#fixed-size-string-buffers">Fixed-size string buffers</a></li>
-<li><a class="reference internal" href="#array-pointers-dynamic-arrays">Array pointers (dynamic arrays)</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#disposable-types">Disposable types</a></li>
-<li><a class="reference internal" href="#utility-functions">Utility functions</a><ul>
-<li><a class="reference internal" href="#type-introspection">Type introspection</a></li>
-<li><a class="reference internal" href="#type-aliases">Type aliases</a></li>
-</ul>
-</li>
-</ul>
-</li>
-</ul>
-          </div>
-        </div>
-      </div>
-    </aside>
-  </div>
-</div><script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
-    <script src="_static/jquery.js"></script>
-    <script src="_static/underscore.js"></script>
-    <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
-    <script src="_static/doctools.js"></script>
-    <script src="_static/scripts/furo.js"></script>
-    </body>
-</html>