new site

src/site/articles/native-extensions-for-standalone-dart-vm/index.markdown

 ---
 layout: default
 title: "Native Extensions for the Standalone Dart VM"
 description: "Learn how to enable command-line Dart apps to call C/C++ functions."
 rel:
   author: william-hesse
 ---
 
 # {{ page.title }}
 _Written by William Hesse <br />
@@ skipping 48 matching lines @@
 {% endhighlight %}
 
 The code that implements a native extension executes at two different times. First, it runs when the native extension is loaded. Later, it runs when a function with a native implementation is called.
 
 Here is the sequence of events at load time, when a Dart app that imports sample_synchronous_extension.dart starts running:
 
 1. The Dart library sample_synchronous_extension.dart is loaded, and the Dart VM hits the code <b><code>#import("dart-ext:sample_extension")</code></b>.
 2. The VM loads the shared library "sample_extension" from the directory containing the Dart library.
 3. The function sample_extension_Init() in the shared library is called. It registers the shared library function ResolveName() as the name resolver for all native functions in the library sample_extension.dart. We'll see what the name resolver does when we look at synchronous native functions, below.
 
-<aside class="note" markdown="1">
-**Note:**
+<aside>
+  <div class="alert alert-info">
+    <strong>Note:</strong>
 The filename of the shared library depends on the platform. On Windows, the VM loads sample_extension.dll, on Linux it loads libsample_extension.so, and on Mac it loads libsample_extension.dylib. We show how to build and link these shared libraries in an appendix at the end of the article.
+  </div>
 </aside>
 
 ###Using the Dart Embedding API from native code
 
 As the sample extensions show, the native shared library contains an initialization function, a name resolution function, and the native implementations of functions declared as native in the Dart part of the extension. The initialization function registers the native name resolution function as responsible for looking up native function names in this library. When a function declared as **<code>native "<em>function_name</em>"</code>**
 in the Dart library is called, the native library's name resolution function is called with the string "<em>function_name</em>" as an argument, plus the number of arguments in the function call. The name resolution function then returns a function pointer to the native implementation of that function. The initialization function and the name resolution function look pretty much the same in all Dart native extensions.
 
 The functions in the native library use the Dart Embedding API to communicate with the VM, so the native code includes the header <b>dart_api.h</b>, which is in the SDK at dart-sdk/include/dart_api.h or in the repository at [runtime/include/dart_api.h](http://dart.googlecode.com/svn/trunk/dart/runtime/include/dart_api.h). The Dart Embedding API is the interface that embedders use to include the Dart VM in a web browser or in the standalone VM for the command line. It consists of about 100 function interfaces and many data type and data structure definitions. These are all shown, with comments, in dart_api.h. Examples of using them are in the unit test file [runtime/vm/dart_api_impl_test.cc](http://code.google.com/p/dart/source/browse/trunk/dart/runtime/vm/dart_api_impl_test.cc).
 
 A native function to be called from Dart must have the type **Dart\_NativeFunction**, which is defined in dart_api.h as:
@@ skipping 273 matching lines @@
 1. Create a new project of type Win32/Win32 project in Visual Studio 2008 or 2010. Give the project the same name as the native extension. On the next screen of the wizard, change the application type to DLL and select "Empty project", then choose finish.
 2. Add the C/C++ files for the native extension to the source files folder in the project.  Make sure to include the [extension name]_dllmain_win.cc file.
 3. Change the following settings in the project's properties:
    1. Configuration properties / Linker / Input / Additional dependencies: Add dart-sdk\bin\dart.lib, from the downloaded Dart SDK.
    2. Configuration properties / C/C++ / General / Additional Include Directories: Add the path to the directory containing dart_api.h, which is dart-sdk/include in the downloaded Dart SDK.
    3. Configuration properties / C/C++ / Preprocessor / Preprocessor Definitions: Add DART_SHARED_LIB. This is just to export the <extension name>_init function from the DLL, since it has been declared as DART_EXPORT.
 4. Build the project, and copy the DLL to the correct directory, relative to the Dart library part of the extension.  Make sure to build a 32-bit DLL for use with the 32-bit SDK download, and a 64-bit DLL for use with the 64-bit download.