| // 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 DART_ARCHIVE_MESSAGING_H_ |
| #define DART_ARCHIVE_MESSAGING_H_ |
| |
| #include "dart_archive.h" |
| |
| /** |
| * Posts a reponse to the main Dart isolate. Only one response should be sent |
| * for each request. |
| * |
| * [p] is the reply port for the isolate. [success] indicates whether or not the |
| * request completed successfully; if not, [err] indicates the precise nature of |
| * the error. [response] contains request-specific response data to send to |
| * Dart; it may not be `NULL`, but it may be the Dart `null` value. |
| */ |
| void postResult(Dart_Port p, bool success, int err, Dart_CObject* response); |
| |
| /** |
| * Posts an error response to the main Dart isolate. |
| * |
| * This should be used when libarchive signals an error. The errno and error |
| * message are taken from libarchive's built-in error information for [a]. |
| */ |
| void postError(Dart_Port p, struct archive* a); |
| |
| /** |
| * Posts an invalid argument error response to the main Dart isolate. |
| * |
| * This should be used when the arguments sent by the Dart code have unexpected |
| * types. Takes a `printf`-style [format] string for describing the error. Note |
| * that the error string will be cut off at 256 characters. |
| */ |
| void postInvalidArgument(Dart_Port p, const char* format, ...); |
| |
| /** |
| * Posts a success response to the main Dart isolate. [response] is the |
| * request-specific Dart object containing the response data. It may be `NULL`. |
| */ |
| void postSuccess(Dart_Port p, Dart_CObject* response); |
| |
| /** |
| * Checks [error], the return code of a libarchive call for error conditions, |
| * and sends an appropriate error response if any are detected. |
| * |
| * Returns `true` if an error is detected and the containing function should |
| * short-circuit. |
| */ |
| bool checkError(Dart_Port p, struct archive* a, int result); |
| |
| /** |
| * Sends an error response if [pointer] is invalid. [name] is the name of the |
| * object being allocated, for error reporting. |
| * |
| * Returns `true` if an error is detected and the containing function should |
| * short-circuit. |
| */ |
| bool checkPointerError(Dart_Port p, void* pointer, char* name); |
| |
| /** |
| * Like [checkError], but sends a success message with no attached data if no |
| * error is detected. No further responses should be sent after calling this. |
| */ |
| void checkResult(Dart_Port p, struct archive* a, int result); |
| |
| /** |
| * Like [checkPointerError], but sends a success message with the pointer as a |
| * Dart integer if no error is detected. No further responses should be sent |
| * after calling this. |
| */ |
| void checkPointerResult(Dart_Port p, void* pointer, char* name); |
| |
| /** |
| * Checks that [object] is of the expected type [type]. If not, sends an |
| * appropriate error response. |
| * |
| * Returns `true` if a type error is detected and the containing function should |
| * short-circuit. |
| */ |
| bool checkType(Dart_Port p, Dart_CObject* object, enum Type type); |
| |
| /** |
| * Gets the [i]th argument from [request], which should be the Dart object |
| * passed in to each handler function. If this fails (e.g. there isn't an [i]th |
| * argument), it will return `NULL`. |
| */ |
| Dart_CObject* getArgument(Dart_Port p, Dart_CObject* request, int i); |
| |
| /** |
| * Like [getArgument], but also ensures that the argument is of type [type]. |
| */ |
| Dart_CObject* getTypedArgument(Dart_Port p, Dart_CObject* request, int i, |
| enum Type type); |
| |
| /** |
| * Like [getArgument], but also ensures that the argument is an integer type |
| * (`int32` or `int64`). [getInteger] should be used to extract the actual value |
| * of the argument. |
| */ |
| Dart_CObject* getIntArgument(Dart_Port p, Dart_CObject* request, int i); |
| |
| /** |
| * Gets the integer value of [object], which should be an `int32` or an `int64`. |
| * Note that this does not validate the type of its argument. |
| */ |
| int64_t getInteger(Dart_CObject* object); |
| |
| /** |
| * Like [getArgument], but also ensures that the argument is a string or null. |
| * [getNullableString] should be used to extract the actual value of the |
| * argument. |
| */ |
| Dart_CObject* getNullableStringArgument(Dart_Port p, Dart_CObject* request, |
| int i); |
| |
| /** |
| * Gets the string value of [object] or `NULL` if it's null. Note that this does |
| * not validate the type of its argument. |
| */ |
| char* getNullableString(Dart_CObject* object); |
| |
| /** |
| * Gets the module, name, and value, for a libarchive `set_option` function |
| * call. Returns whether or not the arguments were parsed correctly. |
| */ |
| bool getOptionArguments(Dart_Port p, Dart_CObject* request, char** module, |
| char** name, char** value); |
| |
| /** Declares a null [Dart_CObject] named [name]. */ |
| #define DART_NULL(name) \ |
| Dart_CObject name; \ |
| name.type = kNull; |
| |
| /** |
| * Declares a [Dart_CObject] bool named [name] with value [val]. |
| * |
| * [val] should be a C boolean. |
| */ |
| #define DART_BOOL(name, val) \ |
| Dart_CObject name; \ |
| name.type = kBool; \ |
| name.value.as_bool = val; |
| |
| /** |
| * Declares a [Dart_CObject] `int32` named [name] with value [val]. |
| * |
| * [val] should be a C integer. |
| */ |
| #define DART_INT32(name, val) \ |
| Dart_CObject name; \ |
| name.type = kInt32; \ |
| name.value.as_int32 = val; |
| |
| /** |
| * Declares a [Dart_CObject] `int64` named [name] with value [val]. |
| * |
| * [val] should be a C integer. |
| */ |
| #define DART_INT64(name, val) \ |
| Dart_CObject name; \ |
| name.type = kInt64; \ |
| name.value.as_int64 = val; |
| |
| /** |
| * Declares a [Dart_CObject] double named [name] with value [val]. |
| * |
| * [val] should be a C float. |
| */ |
| #define DART_DOUBLE(name, val) \ |
| Dart_CObject name; \ |
| name.type = kDouble; \ |
| name.value.as_double = val; |
| |
| /** |
| * Declares a [Dart_CObject] string named [name] with value [val]. |
| * |
| * [val] should be a C string or `NULL`. |
| */ |
| #define DART_STRING(name, val) \ |
| Dart_CObject name; \ |
| if (val == NULL) { \ |
| name.type = kNull; \ |
| } else { \ |
| name.type = kString; \ |
| name.value.as_string = val; \ |
| } |
| |
| #endif // DART_ARCHIVE_MESSAGING_H_ |