VM: Re-format to use at most one newline between functions

runtime/include/dart_api.h

 /*
  * Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
  * for details. All rights reserved. Use of this source code is governed by a
  * BSD-style license that can be found in the LICENSE file.
  */
 
 #ifndef RUNTIME_INCLUDE_DART_API_H_
 #define RUNTIME_INCLUDE_DART_API_H_
 
 /** \mainpage Dart Embedding API Reference
@@ skipping 510 matching lines @@
 DART_EXPORT Dart_WeakPersistentHandle
 Dart_NewWeakPersistentHandle(Dart_Handle object,
                              void* peer,
                              intptr_t external_allocation_size,
                              Dart_WeakPersistentHandleFinalizer callback);
 
 DART_EXPORT void Dart_DeleteWeakPersistentHandle(
     Dart_Isolate isolate,
     Dart_WeakPersistentHandle object);
 
-
 /*
  * ============================
  * Garbage Collection Callbacks
  * ============================
  */
 
 /**
  * Callbacks signal the beginning and end of a garbage collection.
  *
  * These signals are intended to be used by the embedder to manage the
@@ skipping 23 matching lines @@
  *   is called. A NULL value removes the existing epilogue callback function
  *   if any.
  *
  * \return Success if the callbacks were added.  Otherwise, returns an
  *   error handle.
  */
 DART_EXPORT Dart_Handle
 Dart_SetGcCallbacks(Dart_GcPrologueCallback prologue_callback,
                     Dart_GcEpilogueCallback epilogue_callback);
 
-
 /*
  * ==========================
  * Initialization and Globals
  * ==========================
  */
 
 /**
  * Gets the version string for the Dart VM.
  *
  * The version of the Dart VM can be accessed without initializing the VM.
  *
  * \return The version string for the embedded Dart VM.
  */
 DART_EXPORT const char* Dart_VersionString();
 
-
 /**
  * Isolate specific flags are set when creating a new isolate using the
  * Dart_IsolateFlags structure.
  *
  * Current version of flags is encoded in a 32-bit integer with 16 bits used
  * for each part.
  */
 
 #define DART_FLAGS_CURRENT_VERSION (0x00000002)
 
@@ skipping 239 matching lines @@
  *
  * \return True if VM flags set successfully.
  */
 DART_EXPORT bool Dart_SetVMFlags(int argc, const char** argv);
 
 /**
  * Returns true if the named VM flag is set.
  */
 DART_EXPORT bool Dart_IsVMFlagSet(const char* flag_name);
 
-
 /*
  * ========
  * Isolates
  * ========
  */
 
 /**
  * Creates a new isolate. The new isolate becomes the current isolate.
  *
  * A snapshot can be used to restore the VM quickly to a saved state
@@ skipping 197 matching lines @@
  *
  * When isolates are spawned this function is used to indicate that
  * the creation and initialization (including script loading) of the
  * isolate is complete and the isolate can start.
  * This function does not expect there to be a current isolate.
  *
  * \param isolate The isolate to be made runnable.
  */
 DART_EXPORT bool Dart_IsolateMakeRunnable(Dart_Isolate isolate);
 
-
 /*
  * ==================
  * Messages and Ports
  * ==================
  */
 
 /**
  * A port is used to send or receive inter-isolate messages
  */
 typedef int64_t Dart_Port;
@@ skipping 108 matching lines @@
 DART_EXPORT bool Dart_IsPausedOnExit();
 
 /**
  * Called when the embedder has paused the current isolate on exit and when
  * the embedder has resumed the isolate.
  *
  * \param paused Is the isolate paused on exit?
  */
 DART_EXPORT void Dart_SetPausedOnExit(bool paused);
 
-
 /**
  * Called when the embedder has caught a top level unhandled exception error
  * in the current isolate.
  *
  * NOTE: It is illegal to call this twice on the same isolate without first
  * clearing the sticky error to null.
  *
  * \param error The unhandled exception error.
  */
 DART_EXPORT void Dart_SetStickyError(Dart_Handle error);
 
-
 /**
  * Does the current isolate have a sticky error?
  */
 DART_EXPORT bool Dart_HasStickyError();
 
-
 /**
  * Gets the sticky error for the current isolate.
  *
  * \return A handle to the sticky error object or null.
  */
 DART_EXPORT Dart_Handle Dart_GetStickyError();
 
-
 /**
  * Handles the next pending message for the current isolate.
  *
  * May generate an unhandled exception error.
  *
  * \return A valid handle if no error occurs during the operation.
  */
 DART_EXPORT Dart_Handle Dart_HandleMessage();
 
 /**
@@ skipping 84 matching lines @@
 /**
  * Gets the SendPort id for the provided SendPort.
  * \param port A SendPort object whose id is desired.
  * \param port_id Returns the id of the SendPort.
  * \return Success if no error occurs. Otherwise returns
  *   an error handle.
  */
 DART_EXPORT Dart_Handle Dart_SendPortGetId(Dart_Handle port,
                                            Dart_Port* port_id);
 
-
 /*
  * ======
  * Scopes
  * ======
  */
 
 /**
  * Enters a new scope.
  *
  * All new local handles will be created in this scope. Additionally,
@@ skipping 30 matching lines @@
  * All the memory allocated this way will be reclaimed either on the
  * next call to Dart_ExitScope or when the native port handler exits.
  *
  * \param size Size of the memory to allocate.
  *
  * \return A pointer to the allocated memory. NULL if allocation
  *   failed. Failure might due to is no current VM zone.
  */
 DART_EXPORT uint8_t* Dart_ScopeAllocate(intptr_t size);
 
-
 /*
  * =======
  * Objects
  * =======
  */
 
 /**
  * Returns the null object.
  *
  * \return A handle to the null object.
@@ skipping 40 matching lines @@
  * \param object An object.
  * \param type A type.
  * \param instanceof Return true if 'object' is an instance of type 'type'.
  *
  * \return A valid handle if no error occurs during the operation.
  */
 DART_EXPORT Dart_Handle Dart_ObjectIsType(Dart_Handle object,
                                           Dart_Handle type,
                                           bool* instanceof);
 
-
 /**
  * Query object type.
  *
  * \param object Some Object.
  *
  * \return true if Object is of the specified type.
  */
 DART_EXPORT bool Dart_IsInstance(Dart_Handle object);
 DART_EXPORT bool Dart_IsNumber(Dart_Handle object);
 DART_EXPORT bool Dart_IsInteger(Dart_Handle object);
 DART_EXPORT bool Dart_IsDouble(Dart_Handle object);
 DART_EXPORT bool Dart_IsBoolean(Dart_Handle object);
 DART_EXPORT bool Dart_IsString(Dart_Handle object);
 DART_EXPORT bool Dart_IsStringLatin1(Dart_Handle object); /* (ISO-8859-1) */
 DART_EXPORT bool Dart_IsExternalString(Dart_Handle object);
 DART_EXPORT bool Dart_IsList(Dart_Handle object);
 DART_EXPORT bool Dart_IsMap(Dart_Handle object);
 DART_EXPORT bool Dart_IsLibrary(Dart_Handle object);
 DART_EXPORT bool Dart_IsType(Dart_Handle handle);
 DART_EXPORT bool Dart_IsFunction(Dart_Handle handle);
 DART_EXPORT bool Dart_IsVariable(Dart_Handle handle);
 DART_EXPORT bool Dart_IsTypeVariable(Dart_Handle handle);
 DART_EXPORT bool Dart_IsClosure(Dart_Handle object);
 DART_EXPORT bool Dart_IsTypedData(Dart_Handle object);
 DART_EXPORT bool Dart_IsByteBuffer(Dart_Handle object);
 DART_EXPORT bool Dart_IsFuture(Dart_Handle object);
 
-
 /*
  * =========
  * Instances
  * =========
  */
 
 /*
  * For the purposes of the embedding api, not all objects returned are
  * Dart language objects.  Within the api, we use the term 'Instance'
  * to indicate handles which refer to true Dart language objects.
  *
  * TODO(turnidge): Reorganize the "Object" section above, pulling down
  * any functions that more properly belong here. */
 
 /**
  * Gets the type of a Dart language object.
  *
  * \param instance Some Dart object.
  *
  * \return If no error occurs, the type is returned. Otherwise an
  *   error handle is returned.
  */
 DART_EXPORT Dart_Handle Dart_InstanceGetType(Dart_Handle instance);
 
-
 /*
  * =============================
  * Numbers, Integers and Doubles
  * =============================
  */
 
 /**
  * Does this Integer fit into a 64-bit signed integer?
  *
  * \param integer An integer.
@@ skipping 113 matching lines @@
  * it and returns the object returned by the getter.
  *
  * \param library Library object
  * \param function_name Name of the top level function
  *
  * \return A valid Dart instance if no error occurs during the operation.
  */
 DART_EXPORT Dart_Handle Dart_GetClosure(Dart_Handle library,
                                         Dart_Handle function_name);
 
-
 /*
  * ========
  * Booleans
  * ========
  */
 
 /**
  * Returns the True object.
  *
  * Requires there to be a current isolate.
@@ skipping 24 matching lines @@
 /**
  * Gets the value of a Boolean
  *
  * \param boolean_obj A Boolean
  * \param value Returns the value of the Boolean.
  *
  * \return A valid handle if no error occurs during the operation.
  */
 DART_EXPORT Dart_Handle Dart_BooleanValue(Dart_Handle boolean_obj, bool* value);
 
-
 /*
  * =======
  * Strings
  * =======
  */
 
 /**
  * Gets the length of a String.
  *
  * \param str A String.
@@ skipping 302 matching lines @@
                                             intptr_t length);
 
 /**
  * May generate an unhandled exception error.
  */
 DART_EXPORT Dart_Handle Dart_ListSetAsBytes(Dart_Handle list,
                                             intptr_t offset,
                                             const uint8_t* native_array,
                                             intptr_t length);
 
-
 /*
  * ====
  * Maps
  * ====
  */
 
 /**
  * Gets the Object at some key of a Map.
  *
  * May generate an unhandled exception error.
@@ skipping 23 matching lines @@
  *
  * May generate an unhandled exception error.
  *
  * \param map A Map.
  *
  * \return The list of key Objects if no error occurs. Otherwise returns an
  *   error handle.
  */
 DART_EXPORT Dart_Handle Dart_MapKeys(Dart_Handle map);
 
-
 /*
  * ==========
  * Typed Data
  * ==========
  */
 
 typedef enum {
   Dart_TypedData_kByteData = 0,
   Dart_TypedData_kInt8,
   Dart_TypedData_kUint8,
@@ skipping 106 matching lines @@
 /**
  * Returns the TypedData object associated with the ByteBuffer object.
  *
  * \param byte_buffer The ByteBuffer object.
  *
  * \return The TypedData object if no error occurs. Otherwise returns
  *   an error handle.
  */
 DART_EXPORT Dart_Handle Dart_GetDataFromByteBuffer(Dart_Handle byte_buffer);
 
-
 /*
  * ============================================================
  * Invoking Constructors, Methods, Closures and Field accessors
  * ============================================================
  */
 
 /**
  * Invokes a constructor, creating a new object.
  *
  * This function allows hidden constructors (constructors with leading
@@ skipping 147 matching lines @@
  * \param container An object, type, or library.
  * \param name A field name.
  * \param value The new field value.
  *
  * \return A valid handle if no error occurs.
  */
 DART_EXPORT Dart_Handle Dart_SetField(Dart_Handle container,
                                       Dart_Handle name,
                                       Dart_Handle value);
 
-
 /*
  * ==========
  * Exceptions
  * ==========
  */
 
 /*
  * TODO(turnidge): Remove these functions from the api and replace all
  * uses with Dart_NewUnhandledExceptionError. */
 
@@ skipping 25 matching lines @@
  * successful, this function does not return. Note that this means
  * that the destructors of any stack-allocated C++ objects will not be
  * called. If there are no Dart frames on the stack, an error occurs.
  *
  * \return An error handle if the exception was not thrown.
  *   Otherwise the function does not return.
  */
 DART_EXPORT Dart_Handle Dart_RethrowException(Dart_Handle exception,
                                               Dart_Handle stacktrace);
 
-
 /*
  * ===========================
  * Native fields and functions
  * ===========================
  */
 
 /**
  * Creates a native wrapper class.
  *
  * TODO(turnidge): Document.
@@ skipping 108 matching lines @@
  * \return Success if all the arguments could be extracted correctly,
  *   returns an error handle if there were any errors while extracting the
  *   arguments (mismatched number of arguments, incorrect types, etc.).
  */
 DART_EXPORT Dart_Handle
 Dart_GetNativeArguments(Dart_NativeArguments args,
                         int num_arguments,
                         const Dart_NativeArgument_Descriptor* arg_descriptors,
                         Dart_NativeArgument_Value* arg_values);
 
-
 /**
  * Gets the native argument at some index.
  */
 DART_EXPORT Dart_Handle Dart_GetNativeArgument(Dart_NativeArguments args,
                                                int index);
 /* TODO(turnidge): Specify the behavior of an out-of-bounds access. */
 
 /**
  * Gets the number of native arguments.
  */
@@ skipping 137 matching lines @@
  *
  * The parameters to the native reverse resolver function are:
  * \param nf A Dart_NativeFunction.
  *
  * \return A const UTF-8 string containing the symbol name or NULL.
  *
  * See Dart_SetNativeResolver.
  */
 typedef const uint8_t* (*Dart_NativeEntrySymbol)(Dart_NativeFunction nf);
 
-
 /*
  * ===========
  * Environment
  * ===========
  */
 
 /**
  * An environment lookup callback function.
  *
  * \param name The name of the value to lookup in the environment.
@@ skipping 20 matching lines @@
  * \param resolver A native entry resolver.
  *
  * \return A valid handle if the native resolver was set successfully.
  */
 DART_EXPORT Dart_Handle
 Dart_SetNativeResolver(Dart_Handle library,
                        Dart_NativeEntryResolver resolver,
                        Dart_NativeEntrySymbol symbol);
 /* TODO(turnidge): Rename to Dart_LibrarySetNativeResolver? */
 
-
 /**
  * Returns the callback used to resolve native functions for a library.
  *
  * \param library A library.
  * \param resolver a pointer to a Dart_NativeEntryResolver
  *
  * \return A valid handle if the library was found.
  */
 DART_EXPORT Dart_Handle
 Dart_GetNativeResolver(Dart_Handle library, Dart_NativeEntryResolver* resolver);
 
-
 /**
  * Returns the callback used to resolve native function symbols for a library.
  *
  * \param library A library.
  * \param resolver a pointer to a Dart_NativeEntrySymbol.
  *
  * \return A valid handle if the library was found.
  */
 DART_EXPORT Dart_Handle Dart_GetNativeSymbol(Dart_Handle library,
                                              Dart_NativeEntrySymbol* resolver);
 
-
 /*
  * =====================
  * Scripts and Libraries
  * =====================
  */
 
 typedef enum {
   Dart_kCanonicalizeUrl = 0,
   Dart_kScriptTag,
   Dart_kSourceTag,
@@ skipping 129 matching lines @@
  * \param kernel_program The kernel program obtained via
  *        `Dart_ReadKernelBinary`.
  *
  * The VM will take ownership of the `kernel_program` object.
  *
  * \return If no error occurs, the Library object corresponding to the root
  *   script is returned. Otherwise an error handle is returned.
  */
 DART_EXPORT Dart_Handle Dart_LoadKernel(void* kernel_program);
 
-
 /**
  * Constructs an in-memory kernel program form a binary.
  *
  * \param buffer The start of a memory buffer containing the binary format.
  * \param buffer_len The length of the memory buffer.
  *
  * \return kernel_program The `dart::kernel::Program` object.
  */
 DART_EXPORT void* Dart_ReadKernelBinary(const uint8_t* buffer,
                                         intptr_t buffer_len);
 
 /**
  * Gets the library for the root script for the current isolate.
  *
  * If the root script has not yet been set for the current isolate,
  * this function returns Dart_Null().  This function never returns an
  * error handle.
  *
  * \return Returns the root Library for the current isolate or Dart_Null().
  */
 DART_EXPORT Dart_Handle Dart_RootLibrary();
 
-
 /**
  * Sets the root library for the current isolate.
  *
  * \return Returns an error handle if `library` is not a library handle.
  */
 DART_EXPORT Dart_Handle Dart_SetRootLibrary(Dart_Handle library);
 
-
 /**
  * Lookup or instantiate a type by name and type arguments from a Library.
  *
  * \param library The library containing the class or interface.
  * \param class_name The class name for the type.
  * \param number_of_type_arguments Number of type arguments.
  *   For non parametric types the number of type arguments would be 0.
  * \param type_arguments Pointer to an array of type arguments.
  *   For non parameteric types a NULL would be passed in for this argument.
  *
@@ skipping 17 matching lines @@
 DART_EXPORT Dart_Handle Dart_GetClass(Dart_Handle library,
                                       Dart_Handle class_name);
 /* TODO(asiva): The above method needs to be removed once all uses
  * of it are removed from the embedder code. */
 
 /**
  * Returns the url from which a library was loaded.
  */
 DART_EXPORT Dart_Handle Dart_LibraryUrl(Dart_Handle library);
 
-
 /**
  * \return An array of libraries.
  */
 DART_EXPORT Dart_Handle Dart_GetLoadedLibraries();
 
-
 DART_EXPORT Dart_Handle Dart_LookupLibrary(Dart_Handle url);
 /* TODO(turnidge): Consider returning Dart_Null() when the library is
  * not found to distinguish that from a true error case. */
 
-
 /**
  * Report an loading error for the library.
  *
  * \param library The library that failed to load.
  * \param error The Dart error instance containing the load error.
  *
  * \return If the VM handles the error, the return value is
  * a null handle. If it doesn't handle the error, the error
  * object is returned.
  */
 DART_EXPORT Dart_Handle Dart_LibraryHandleError(Dart_Handle library,
                                                 Dart_Handle error);
 
-
 /**
  * Called by the embedder to provide the source for an "import"
  * directive.  This function should be called in response to a
  * Dart_kImportTag tag handler request (See Dart_LibraryTagHandler,
  * above).
  *
  * \param library The library where the "import" directive occurs.
  *
  * \param url The original url requested for the import.
  *
@@ skipping 26 matching lines @@
  * \param library The library into which to import another library.
  * \param import The library to import.
  * \param prefix The prefix under which to import.
  *
  * \return A valid handle if no error occurs during the operation.
  */
 DART_EXPORT Dart_Handle Dart_LibraryImportLibrary(Dart_Handle library,
                                                   Dart_Handle import,
                                                   Dart_Handle prefix);
 
-
 /**
  * Returns a flattened list of pairs. The first element in each pair is the
  * importing library and and the second element is the imported library for each
  * import in the isolate of a library whose URI's scheme is [scheme].
  *
  * Requires there to be a current isolate.
  *
  * \return A handle to a list of flattened pairs of importer-importee.
  */
 DART_EXPORT Dart_Handle Dart_GetImportsOfScheme(Dart_Handle scheme);
 
-
 /**
  * Called by the embedder to provide the source for a "part of"
  * directive.  This function should be called in response to a
  * Dart_kSourceTag tag handler request (See Dart_LibraryTagHandler,
  * above).
  *
  * \param library The library where the "part of" directive occurs.
  *
  * \param url The original url requested for the part.
  *
@@ skipping 13 matching lines @@
  * \return A valid handle if no error occurs during the operation.
  */
 DART_EXPORT Dart_Handle Dart_LoadSource(Dart_Handle library,
                                         Dart_Handle url,
                                         Dart_Handle resolved_url,
                                         Dart_Handle source,
                                         intptr_t line_offset,
                                         intptr_t column_offset);
 /* TODO(turnidge): Rename to Dart_LibraryLoadSource? */
 
-
 /**
  * Loads a patch source string into a library.
  *
  * \param library A library
  * \param url A url identifying the origin of the patch source
  * \param source A string of Dart patch source
  */
 DART_EXPORT Dart_Handle Dart_LibraryLoadPatch(Dart_Handle library,
                                               Dart_Handle url,
                                               Dart_Handle patch_source);
 
-
 /**
  * Indicates that all outstanding load requests have been satisfied.
  * This finalizes all the new classes loaded and optionally completes
  * deferred library futures.
  *
  * Requires there to be a current isolate.
  *
  * \param complete_futures Specify true if all deferred library
  *  futures should be completed, false otherwise.
  *
  * \return Success if all classes have been finalized and deferred library
  *   futures are completed. Otherwise, returns an error.
  */
 DART_EXPORT Dart_Handle Dart_FinalizeLoading(bool complete_futures);
 
-
 /*
  * =====
  * Peers
  * =====
  */
 
 /**
  * The peer field is a lazily allocated field intended for storage of
  * an uncommonly used values.  Most instances types can have a peer
  * field allocated.  The exceptions are subtypes of Null, num, and
@@ skipping 17 matching lines @@
  * 'peer'.
  *
  * \param object An object.
  * \param peer A value to store in the peer field.
  *
  * \return Returns an error if 'object' is a subtype of Null, num, or
  *   bool.
  */
 DART_EXPORT Dart_Handle Dart_SetPeer(Dart_Handle object, void* peer);
 
-
 /*
  * ======
  * Kernel
  * ======
  */
 
-
 /**
  * Experimental support for Dart to Kernel parser isolate.
  *
  * TODO(hausner): Document finalized interface.
  *
  */
 
 typedef enum {
   Dart_KernelCompilationStatus_Unknown = -1,
   Dart_KernelCompilationStatus_Ok = 0,
@@ skipping 25 matching lines @@
                             Dart_SourceFile source_files[]);
 
 #define DART_KERNEL_ISOLATE_NAME "kernel-service"
 
 /*
  * =======
  * Service
  * =======
  */
 
-
 #define DART_VM_SERVICE_ISOLATE_NAME "vm-service"
 
 /**
  * Returns true if isolate is the service isolate.
  *
  * \param isolate An isolate
  *
  * \return Returns true if 'isolate' is the service isolate.
  */
 DART_EXPORT bool Dart_IsServiceIsolate(Dart_Isolate isolate);
 
-
 /**
  * Returns the port that script load requests should be sent on.
  *
  * \return Returns the port for load requests or ILLEGAL_PORT if the service
  * isolate failed to startup or does not support load requests.
  */
 DART_EXPORT Dart_Port Dart_ServiceWaitForLoadPort();
 
-
 /**
  * Record all functions which have been compiled in the current isolate.
  *
  * \param buffer Returns a pointer to a buffer containing the trace.
  *   This buffer is scope allocated and is only valid  until the next call to
  *   Dart_ExitScope.
  * \param size Returns the size of the buffer.
  * \return Returns an valid handle upon success.
  */
 DART_EXPORT Dart_Handle Dart_SaveCompilationTrace(uint8_t** buffer,
                                                   intptr_t* buffer_length);
 
-
 /**
  * Compile all functions from data from Dart_SaveCompilationTrace. Unlike JIT
  * feedback, this data is fuzzy: loading does not need to happen in the exact
  * program that was saved, the saver and loader do not need to agree on checked
  * mode versus production mode or debug/release/product.
  *
  * \return Returns an error handle if a compilation error was encountered.
  */
 DART_EXPORT Dart_Handle Dart_LoadCompilationTrace(uint8_t* buffer,
                                                   intptr_t buffer_length);
 
-
 /*
  * ==============
  * Precompilation
  * ==============
  */
 
 /**
  * Saves a serialized version of the information collected for use by the
  * optimizing compiler, such as type feedback and usage counters. When this
  * information is passed to Dart_Precompile, the AOT compiler may use it to
  * produce faster and smaller code. The feedback is only used if the JIT that
  * created it and the AOT compiler consuming it
  *   - are running the same Dart program
  *   - are built from the same version of the VM
  *   - agree on whether type checks and assertions are enabled
  *
  * \return Returns an error handler if the VM was built in a mode that does not
  * support saving JIT feedback.
  */
 DART_EXPORT Dart_Handle Dart_SaveJITFeedback(uint8_t** buffer,
                                              intptr_t* buffer_length);
 
-
 typedef struct {
   const char* library_uri;
   const char* class_name;
   const char* function_name;
 } Dart_QualifiedFunctionName;
 
-
 /**
  * Compiles all functions reachable from the provided entry points and marks
  * the isolate to disallow future compilation.
  *
  * \param entry_points A list of functions that may be invoked through the
  * embedding API, e.g. Dart_Invoke/GetField/SetField/New/InvokeClosure.
  *
  * \param reset_fields Controls whether static fields are reset. Fields without
  * an initializer will be set to null, and fields with an initializer will have
  * their initializer run the next time they are accessed.
  *
  * reset_fields is true when we are about to create a precompilated snapshot.
  * Some fields are already been initialized as part of the loading logic, and
  * we want them to be reinitialized in the new process that will load the
  * snapshot.
  *
  * \return An error handle if a compilation error or runtime error running const
  * constructors was encountered.
  */
 DART_EXPORT Dart_Handle
 Dart_Precompile(Dart_QualifiedFunctionName entry_points[],
                 uint8_t* jit_feedback,
                 intptr_t jit_feedback_length);
 
-
 /**
  *  Creates a precompiled snapshot.
  *   - A root library must have been loaded.
  *   - Dart_Precompile must have been called.
  *
  *  Outputs an assembly file defining the symbols
  *   - kDartVmSnapshotData
  *   - kDartVmSnapshotInstructions
  *   - kDartIsolateSnapshotData
  *   - kDartIsolateSnapshotInstructions
  *
  *  The assembly should be compiled as a static or shared library and linked or
  *  loaded by the embedder.
  *  Running this snapshot requires a VM compiled with DART_PRECOMPILED_SNAPSHOT.
  *  The kDartVmSnapshotData and kDartVmSnapshotInstructions should be passed to
  *  Dart_Initialize. The kDartIsolateSnapshotData and
  *  kDartIsoalteSnapshotInstructions should be passed to Dart_CreateIsolate.
  *
  *  The buffers are scope allocated and are only valid until the next call to
  *  Dart_ExitScope.
  *
  * \return A valid handle if no error occurs during the operation.
  */
 DART_EXPORT Dart_Handle
 Dart_CreateAppAOTSnapshotAsAssembly(uint8_t** assembly_buffer,
                                     intptr_t* assembly_size);
 
-
 /**
  *  Same as Dart_CreateAppAOTSnapshotAsAssembly, except all the pieces are
  *  provided directly as bytes that the embedder can load with mmap. The
  *  instructions pieces must be loaded with read and execute permissions; the
  *  other pieces may be loaded as read-only.
  */
 DART_EXPORT Dart_Handle
 Dart_CreateAppAOTSnapshotAsBlobs(uint8_t** vm_snapshot_data_buffer,
                                  intptr_t* vm_snapshot_data_size,
                                  uint8_t** vm_snapshot_instructions_buffer,
                                  intptr_t* vm_snapshot_instructions_size,
                                  uint8_t** isolate_snapshot_data_buffer,
                                  intptr_t* isolate_snapshot_data_size,
                                  uint8_t** isolate_snapshot_instructions_buffer,
                                  intptr_t* isolate_snapshot_instructions_size);
 
 /**
  * Sorts the class-ids in depth first traversal order of the inheritance
  * tree. This is a costly operation, but it can make method dispatch
  * more efficient and is done before writing snapshots.
  *
  * \return A valid handle if no error occurs during the operation.
  */
 DART_EXPORT Dart_Handle Dart_SortClasses();
 
-
 /**
  *  Creates a snapshot that caches compiled code and type feedback for faster
  *  startup and quicker warmup in a subsequent process.
  *
  *  Outputs a snapshot in two pieces. The pieces should be passed to
  *  Dart_CreateIsolate in a VM using the same VM snapshot pieces used in the
  *  current VM. The instructions piece must be loaded with read and execute
  *  permissions; the data piece may be loaded as read-only.
  *
  *   - Requires the VM to have been started with --load-deferred-eagerly.
  *   - Requires the VM to have not been started with --precompilation.
  *   - Not supported when targeting IA32 or DBC.
  *   - The VM writing the snapshot and the VM reading the snapshot must be the
  *     same version, must be built in the same DEBUG/RELEASE/PRODUCT mode, must
  *     be targeting the same architecture, and must both be in checked mode or
  *     both in unchecked mode.
  *
  *  The buffers are scope allocated and are only valid until the next call to
  *  Dart_ExitScope.
  *
  * \return A valid handle if no error occurs during the operation.
  */
 DART_EXPORT Dart_Handle
 Dart_CreateAppJITSnapshotAsBlobs(uint8_t** isolate_snapshot_data_buffer,
                                  intptr_t* isolate_snapshot_data_size,
                                  uint8_t** isolate_snapshot_instructions_buffer,
                                  intptr_t* isolate_snapshot_instructions_size);
 
-
 /**
  * Like Dart_CreateAppJITSnapshotAsBlobs, but also creates a new VM snapshot.
  */
 DART_EXPORT Dart_Handle Dart_CreateCoreJITSnapshotAsBlobs(
     uint8_t** vm_snapshot_data_buffer,
     intptr_t* vm_snapshot_data_size,
     uint8_t** vm_snapshot_instructions_buffer,
     intptr_t* vm_snapshot_instructions_size,
     uint8_t** isolate_snapshot_data_buffer,
     intptr_t* isolate_snapshot_data_size,
     uint8_t** isolate_snapshot_instructions_buffer,
     intptr_t* isolate_snapshot_instructions_size);
 
-
 /**
  *  Returns whether the VM only supports running from precompiled snapshots and
  *  not from any other kind of snapshot or from source (that is, the VM was
  *  compiled with DART_PRECOMPILED_RUNTIME).
  */
 DART_EXPORT bool Dart_IsPrecompiledRuntime();
 
-
 /**
  *  Print a native stack trace. Used for crash handling.
  */
 DART_EXPORT void Dart_DumpNativeStackTrace(void* context);
 
 #endif /* INCLUDE_DART_API_H_ */ /* NOLINT */