prism 2.0.0-arm-linux-gnu

data/include/prism/node.hpp

@@ -0,0 +1,272 @@
+/**
+ * @file node.hpp
+ *
+ * Checked casts between node structs, iteration over lists of nodes, and
+ * walking the tree from C++.
+ */
+#ifndef PRISM_NODE_HPP
+#define PRISM_NODE_HPP
+
+#include "prism/compiler/cplusplus.hpp"
+#include "prism/compiler/exceptions.hpp"
+#include "prism/compiler/lifetimebound.hpp"
+
+#include "prism/ast.hpp"
+#include "prism/node.h"
+#include "prism/node_type.hpp"
+
+#include <cassert>
+#include <cstddef>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <type_traits>
+
+namespace prism {
+
+/**
+ * Whether the given node, which must not be null, is of the given struct
+ *
+ * @tparam T The node struct type to check against.
+ * @param node The node to check.
+ * @return True if the node is of the given struct, false otherwise.
+ */
+template <typename T> [[nodiscard]] bool
+isa(const pm_node_t *node) noexcept {
+    static_assert(is_node_v<T>, "isa<T> requires a node struct declared in ast.h");
+    assert(node != nullptr);
+    return node->type == node_type_v<T>;
+}
+
+/**
+ * Cast the given node, which must not be null and must be of the given struct,
+ * to that struct. The type is checked in debug builds.
+ *
+ * @tparam T The node struct type to cast to.
+ * @param node The node to cast.
+ * @return The node cast to the given struct.
+ */
+template <typename T> [[nodiscard]] T *
+cast(pm_node_t *node) noexcept {
+    assert(isa<T>(node));
+    return reinterpret_cast<T *>(node);
+}
+
+/**
+ * Cast the given node, which must not be null and must be of the given struct,
+ * to that struct. The type is checked in debug builds.
+ *
+ * @tparam T The node struct type to cast to.
+ * @param node The node to cast.
+ * @return The node cast to the given struct.
+ */
+template <typename T> [[nodiscard]] const T *
+cast(const pm_node_t *node) noexcept {
+    assert(isa<T>(node));
+    return reinterpret_cast<const T *>(node);
+}
+
+/**
+ * Cast the given node to the given struct if it is of that struct, and return
+ * null otherwise. The node may be null, in which case this returns null.
+ *
+ * @tparam T The node struct type to cast to.
+ * @param node The node to cast.
+ * @return The node cast to the given struct if it is of that struct, or null
+ *   otherwise.
+ */
+template <typename T> [[nodiscard]] T *
+dyn_cast(pm_node_t *node) noexcept {
+    return (node != nullptr && isa<T>(node)) ? reinterpret_cast<T *>(node) : nullptr;
+}
+
+/**
+ * Cast the given node to the given struct if it is of that struct, and return
+ * null otherwise. The node may be null, in which case this returns null.
+ *
+ * @tparam T The node struct type to cast to.
+ * @param node The node to cast.
+ * @return The node cast to the given struct if it is of that struct, or null
+ *   otherwise.
+ */
+template <typename T> [[nodiscard]] const T *
+dyn_cast(const pm_node_t *node) noexcept {
+    return (node != nullptr && isa<T>(node)) ? reinterpret_cast<const T *>(node) : nullptr;
+}
+
+/**
+ * Return the pm_node_t embedded at the start of the given node struct.
+ *
+ * @tparam T The node struct type.
+ * @param node The node struct to upcast.
+ * @return The pm_node_t embedded at the start of the node struct.
+ */
+template <typename T> [[nodiscard]] pm_node_t *
+upcast(T *node) noexcept {
+    static_assert(is_node_v<T>, "upcast requires a node struct declared in ast.h");
+    return &node->base;
+}
+
+/**
+ * Return the pm_node_t embedded at the start of the given node struct.
+ *
+ * @tparam T The node struct type.
+ * @param node The node struct to upcast.
+ * @return The pm_node_t embedded at the start of the node struct.
+ */
+template <typename T> [[nodiscard]] const pm_node_t *
+upcast(const T *node) noexcept {
+    static_assert(is_node_v<T>, "upcast requires a node struct declared in ast.h");
+    return &node->base;
+}
+
+/**
+ * The nodes in a list, usable in a range-based for loop. It refers to the list
+ * rather than copying it, so the list must outlive it.
+ */
+class node_range {
+public:
+    /**
+     * Create a range over the nodes in the given list.
+     *
+     * @param list The list of nodes to create a range for.
+     */
+    explicit node_range(const pm_node_list_t &list PRISM_LIFETIMEBOUND) noexcept : list_(&list) {}
+
+    /**
+     * A pointer to the first node.
+     *
+     * @return A pointer to the first node, or null if the list is empty.
+     */
+    pm_node_t *const *begin() const noexcept { return list_->nodes; }
+
+    /**
+     * A pointer one past the last node.
+     *
+     * @return A pointer one past the last node, or null if the list is empty.
+     */
+    pm_node_t *const *end() const noexcept { return list_->nodes + list_->size; }
+
+    /**
+     * The number of nodes.
+     *
+     * @return The number of nodes.
+     */
+    std::size_t size() const noexcept { return list_->size; }
+
+    /**
+     * Whether there are no nodes.
+     *
+     * @return True if there are no nodes, false otherwise.
+     */
+    [[nodiscard]] bool empty() const noexcept { return list_->size == 0; }
+
+private:
+    const pm_node_list_t *list_;
+};
+
+namespace detail {
+
+/**
+ * The state shared between a walk and its C callback, passed through the C
+ * function's void * data parameter.
+ */
+template <typename F> struct visit_context {
+    /**
+     * The context for a visit, holding the visitor and any exception thrown.
+     *
+     * @param visitor The visitor callable to be used for each node.
+     */
+    explicit visit_context(F *visitor) noexcept : callable(visitor) {}
+
+    /** The visitor that the walk calls for each node. */
+    F *callable;
+
+#ifdef PRISM_HAS_EXCEPTIONS
+    /** The exception thrown by the visitor, if any. */
+    std::exception_ptr exception;
+#endif
+};
+
+/**
+ * Forwards the C visitor callback to a C++ callable. An exception cannot unwind
+ * through the C frames that call this function, so one thrown by the callable
+ * is caught here and the walk is stopped. The function that started the walk
+ * rethrows it once the C walk has returned. Without exceptions, the callable
+ * cannot throw, so it is called directly.
+ *
+ * @tparam F The type of the visitor callable.
+ * @param node The current node being visited.
+ * @param data The visit context containing the visitor and exception state.
+ * @return The result of the visit, indicating whether to descend, skip, or stop.
+ */
+template <typename F> pm_visit_result_t
+visit_callback(const pm_node_t *node, void *data) noexcept {
+    visit_context<F> *context = static_cast<visit_context<F> *>(data);
+
+#ifdef PRISM_HAS_EXCEPTIONS
+    try {
+        return std::invoke(*context->callable, node);
+    } catch (...) {
+        context->exception = std::current_exception();
+        return PM_VISIT_STOP;
+    }
+#else
+    return std::invoke(*context->callable, node);
+#endif
+}
+
+}
+
+/**
+ * Walk the tree rooted at the given node in pre-order, calling the visitor with
+ * each node. The visitor returns PM_VISIT_DESCEND to continue into that node's
+ * children, PM_VISIT_SKIP to continue past them, or PM_VISIT_STOP to end the
+ * walk. Returns false if the walk was stopped. If the visitor throws, the walk
+ * stops and the exception propagates from this function.
+ *
+ * @tparam F The type of the visitor callable.
+ * @param node The root node to start the walk from.
+ * @param visitor The visitor callable to invoke for each node.
+ * @return True if the walk completed, false if it was stopped.
+ */
+template <typename F> bool
+visit_node(const pm_node_t *node, F &&visitor) {
+    static_assert(std::is_invocable_r_v<pm_visit_result_t, F &, const pm_node_t *>, "visit_node requires a callable taking const pm_node_t * and returning pm_visit_result_t");
+    detail::visit_context<std::remove_reference_t<F>> context(std::addressof(visitor));
+    bool completed = pm_visit_node(node, detail::visit_callback<std::remove_reference_t<F>>, &context);
+
+#ifdef PRISM_HAS_EXCEPTIONS
+    if (context.exception) std::rethrow_exception(context.exception);
+#endif
+
+    return completed;
+}
+
+/**
+ * Walk the children of the given node, as visit_node does for every node whose
+ * visitor returns PM_VISIT_DESCEND. Returns false if the walk was stopped. If
+ * the visitor throws, the walk stops and the exception propagates from this
+ * function.
+ *
+ * @tparam F The type of the visitor callable.
+ * @param node The node whose children to walk.
+ * @param visitor The visitor callable to invoke for each child node.
+ * @return True if the walk completed, false if it was stopped.
+ */
+template <typename F> bool
+visit_child_nodes(const pm_node_t *node, F &&visitor) {
+    static_assert(std::is_invocable_r_v<pm_visit_result_t, F &, const pm_node_t *>, "visit_child_nodes requires a callable taking const pm_node_t * and returning pm_visit_result_t");
+    detail::visit_context<std::remove_reference_t<F>> context(std::addressof(visitor));
+    bool completed = pm_visit_child_nodes(node, detail::visit_callback<std::remove_reference_t<F>>, &context);
+
+#ifdef PRISM_HAS_EXCEPTIONS
+    if (context.exception) std::rethrow_exception(context.exception);
+#endif
+
+    return completed;
+}
+
+}
+
+#endif

data/include/prism/node_type.hpp

@@ -0,0 +1,38 @@
+/**
+ * @file node_type.hpp
+ *
+ * The traits that map node structs to node types. The specialization for each
+ * node struct is generated into ast.hpp.
+ */
+#ifndef PRISM_NODE_TYPE_HPP
+#define PRISM_NODE_TYPE_HPP
+
+#include "prism/compiler/cplusplus.hpp"
+
+#include "prism/ast.h"
+
+#include <type_traits>
+
+namespace prism {
+
+/**
+ * Maps a node struct to its node type, as in node_type<pm_call_node_t>::value
+ * being PM_CALL_NODE. Only the node structs declared in ast.h have a value.
+ */
+template <typename T> struct node_type {};
+
+/** The node type of the given node struct. */
+template <typename T> inline constexpr pm_node_type_t node_type_v = node_type<T>::value;
+
+/** Whether the given type is one of the node structs declared in ast.h. */
+template <typename T, typename = void> struct is_node : std::false_type {};
+
+/** Whether the given type is one of the node structs declared in ast.h. */
+template <typename T> struct is_node<T, std::void_t<decltype(node_type<T>::value)>> : std::true_type {};
+
+/** Whether the given type is one of the node structs declared in ast.h. */
+template <typename T> inline constexpr bool is_node_v = is_node<T>::value;
+
+}
+
+#endif

data/include/prism/options.h

@@ -0,0 +1,363 @@
+/**
+ * @file options.h
+ *
+ * The options that can be passed to parsing.
+ */
+#ifndef PRISM_OPTIONS_H
+#define PRISM_OPTIONS_H
+
+#include "prism/compiler/exported.h"
+#include "prism/compiler/nodiscard.h"
+#include "prism/compiler/nonnull.h"
+
+#include "prism/stringy.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * A scope of locals surrounding the code that is being parsed.
+ */
+typedef struct pm_options_scope_t pm_options_scope_t;
+
+/**
+ * The options that can be passed to the parser.
+ */
+typedef struct pm_options_t pm_options_t;
+
+/**
+ * String literals should not be frozen.
+ */
+#define PM_OPTIONS_FROZEN_STRING_LITERAL_DISABLED   ((int8_t) -1)
+
+/**
+ * String literals may be frozen or mutable depending on the implementation
+ * default.
+ */
+#define PM_OPTIONS_FROZEN_STRING_LITERAL_UNSET      ((int8_t)  0)
+
+/**
+ * String literals should be made frozen.
+ */
+#define PM_OPTIONS_FROZEN_STRING_LITERAL_ENABLED    ((int8_t)  1)
+
+/** The default value for parameters. */
+static const uint8_t PM_OPTIONS_SCOPE_FORWARDING_NONE = 0x0;
+
+/** When the scope is forwarding with the * parameter. */
+static const uint8_t PM_OPTIONS_SCOPE_FORWARDING_POSITIONALS = 0x1;
+
+/** When the scope is forwarding with the ** parameter. */
+static const uint8_t PM_OPTIONS_SCOPE_FORWARDING_KEYWORDS = 0x2;
+
+/** When the scope is forwarding with the & parameter. */
+static const uint8_t PM_OPTIONS_SCOPE_FORWARDING_BLOCK = 0x4;
+
+/** When the scope is forwarding with the ... parameter. */
+static const uint8_t PM_OPTIONS_SCOPE_FORWARDING_ALL = 0x8;
+
+/**
+ * The callback called when additional switches are found in a shebang comment
+ * that need to be processed by the runtime.
+ *
+ * @param options The options struct that may be updated by this callback.
+ *   Certain fields will be checked for changes, specifically encoding,
+ *   command_line, and frozen_string_literal.
+ * @param source The source of the shebang comment.
+ * @param length The length of the source.
+ * @param shebang_callback_data Any additional data that should be passed along
+ *   to the callback.
+ */
+typedef void (*pm_options_shebang_callback_t)(pm_options_t *options, const uint8_t *source, size_t length, void *shebang_callback_data);
+
+/**
+ * A bit representing whether or not the command line -a option was set. -a
+ * splits the input line $_ into $F.
+ */
+static const uint8_t PM_OPTIONS_COMMAND_LINE_A = 0x1;
+
+/**
+ * A bit representing whether or not the command line -e option was set. -e
+ * allow the user to specify a script to be executed. This is necessary for
+ * prism to know because certain warnings are not generated when -e is used.
+ */
+static const uint8_t PM_OPTIONS_COMMAND_LINE_E = 0x2;
+
+/**
+ * A bit representing whether or not the command line -l option was set. -l
+ * chomps the input line by default.
+ */
+static const uint8_t PM_OPTIONS_COMMAND_LINE_L = 0x4;
+
+/**
+ * A bit representing whether or not the command line -n option was set. -n
+ * wraps the script in a while gets loop.
+ */
+static const uint8_t PM_OPTIONS_COMMAND_LINE_N = 0x8;
+
+/**
+ * A bit representing whether or not the command line -p option was set. -p
+ * prints the value of $_ at the end of each loop.
+ */
+static const uint8_t PM_OPTIONS_COMMAND_LINE_P = 0x10;
+
+/**
+ * A bit representing whether or not the command line -x option was set. -x
+ * searches the input file for a shebang that includes "ruby".
+ */
+static const uint8_t PM_OPTIONS_COMMAND_LINE_X = 0x20;
+
+/**
+ * Allocate a new options struct. If the options struct cannot be allocated,
+ * this function aborts the process.
+ *
+ * @returns A new options struct with default values. It is the responsibility
+ *     of the caller to free this struct using pm_options_free().
+ */
+PRISM_NODISCARD PRISM_EXPORTED_FUNCTION pm_options_t * pm_options_new(void);
+
+/**
+ * Free both the held memory of the given options struct and the struct itself.
+ *
+ * @param options The options struct to free.
+ */
+PRISM_EXPORTED_FUNCTION void pm_options_free(pm_options_t *options) PRISM_NONNULL(1);
+
+/**
+ * Set the shebang callback option on the given options struct.
+ *
+ * @param options The options struct to set the shebang callback on.
+ * @param shebang_callback The shebang callback to set.
+ * @param shebang_callback_data Any additional data that should be passed along
+ *   to the callback.
+ */
+PRISM_EXPORTED_FUNCTION void pm_options_shebang_callback_set(pm_options_t *options, pm_options_shebang_callback_t shebang_callback, void *shebang_callback_data) PRISM_NONNULL(1);
+
+/**
+ * Get the filepath option on the given options struct.
+ *
+ * @param options The options struct to get the filepath from.
+ * @returns The filepath.
+ */
+PRISM_EXPORTED_FUNCTION const pm_string_t * pm_options_filepath(const pm_options_t *options) PRISM_NONNULL(1);
+
+/**
+ * Set the filepath option on the given options struct.
+ *
+ * @param options The options struct to set the filepath on.
+ * @param filepath The filepath to set.
+ */
+PRISM_EXPORTED_FUNCTION void pm_options_filepath_set(pm_options_t *options, const char *filepath) PRISM_NONNULL(1);
+
+/**
+ * Set the line option on the given options struct.
+ *
+ * @param options The options struct to set the line on.
+ * @param line The line to set.
+ */
+PRISM_EXPORTED_FUNCTION void pm_options_line_set(pm_options_t *options, int32_t line) PRISM_NONNULL(1);
+
+/**
+ * Set the encoding option on the given options struct.
+ *
+ * @param options The options struct to set the encoding on.
+ * @param encoding The encoding to set.
+ */
+PRISM_EXPORTED_FUNCTION void pm_options_encoding_set(pm_options_t *options, const char *encoding) PRISM_NONNULL(1);
+
+/**
+ * Set the encoding_locked option on the given options struct.
+ *
+ * @param options The options struct to set the encoding_locked value on.
+ * @param encoding_locked The encoding_locked value to set.
+ */
+PRISM_EXPORTED_FUNCTION void pm_options_encoding_locked_set(pm_options_t *options, bool encoding_locked) PRISM_NONNULL(1);
+
+/**
+ * Set the frozen string literal option on the given options struct.
+ *
+ * @param options The options struct to set the frozen string literal value on.
+ * @param frozen_string_literal The frozen string literal value to set.
+ */
+PRISM_EXPORTED_FUNCTION void pm_options_frozen_string_literal_set(pm_options_t *options, bool frozen_string_literal) PRISM_NONNULL(1);
+
+/**
+ * Sets the command line option on the given options struct.
+ *
+ * @param options The options struct to set the command line option on.
+ * @param command_line The command_line value to set.
+ */
+PRISM_EXPORTED_FUNCTION void pm_options_command_line_set(pm_options_t *options, uint8_t command_line) PRISM_NONNULL(1);
+
+/**
+ * Set the version option on the given options struct by parsing the given
+ * string. If the string contains an invalid option, this returns false.
+ * Otherwise, it returns true.
+ *
+ * @param options The options struct to set the version on.
+ * @param version The version to set.
+ * @param length The length of the version string.
+ * @returns Whether or not the version was parsed successfully.
+ */
+PRISM_EXPORTED_FUNCTION bool pm_options_version_set(pm_options_t *options, const char *version, size_t length) PRISM_NONNULL(1);
+
+/**
+ * Set the version option on the given options struct to the lowest version of
+ * Ruby that prism supports.
+ *
+ * @param options The options struct to set the version on.
+ */
+PRISM_EXPORTED_FUNCTION void pm_options_version_set_lowest(pm_options_t *options) PRISM_NONNULL(1);
+
+/**
+ * Set the version option on the given options struct to the highest version of
+ * Ruby that prism supports.
+ *
+ * @param options The options struct to set the version on.
+ */
+PRISM_EXPORTED_FUNCTION void pm_options_version_set_highest(pm_options_t *options) PRISM_NONNULL(1);
+
+/**
+ * Set the main script option on the given options struct.
+ *
+ * @param options The options struct to set the main script value on.
+ * @param main_script The main script value to set.
+ */
+PRISM_EXPORTED_FUNCTION void pm_options_main_script_set(pm_options_t *options, bool main_script) PRISM_NONNULL(1);
+
+/**
+ * Set the partial script option on the given options struct.
+ *
+ * @param options The options struct to set the partial script value on.
+ * @param partial_script The partial script value to set.
+ */
+PRISM_EXPORTED_FUNCTION void pm_options_partial_script_set(pm_options_t *options, bool partial_script) PRISM_NONNULL(1);
+
+/**
+ * Get the freeze option on the given options struct.
+ *
+ * @param options The options struct to get the freeze value from.
+ * @returns The freeze value.
+ */
+PRISM_EXPORTED_FUNCTION bool pm_options_freeze(const pm_options_t *options) PRISM_NONNULL(1);
+
+/**
+ * Set the freeze option on the given options struct.
+ *
+ * @param options The options struct to set the freeze value on.
+ * @param freeze The freeze value to set.
+ */
+PRISM_EXPORTED_FUNCTION void pm_options_freeze_set(pm_options_t *options, bool freeze) PRISM_NONNULL(1);
+
+/**
+ * Get the attach_comments option on the given options struct.
+ *
+ * @param options The options struct to get the attach_comments value from.
+ * @returns The attach_comments value.
+ */
+PRISM_EXPORTED_FUNCTION bool pm_options_attach_comments(const pm_options_t *options) PRISM_NONNULL(1);
+
+/**
+ * Set the attach_comments option on the given options struct. When this is
+ * set, the parser's comment list is sorted by start offset after parsing and
+ * every comment is assigned an owning node. Without it, comments are left in
+ * the order they were lexed and no nodes own any comments.
+ *
+ * @param options The options struct to set the attach_comments value on.
+ * @param attach_comments The attach_comments value to set.
+ */
+PRISM_EXPORTED_FUNCTION void pm_options_attach_comments_set(pm_options_t *options, bool attach_comments) PRISM_NONNULL(1);
+
+/**
+ * Get the raise_error option on the given options struct.
+ *
+ * @param options The options struct to get the raise_error value from.
+ * @returns The raise_error value.
+ */
+PRISM_EXPORTED_FUNCTION uint8_t pm_options_raise_error(const pm_options_t *options) PRISM_NONNULL(1);
+
+/**
+ * Set the raise_error option on the given options struct.
+ *
+ * @param options The options struct to set the raise_error value on.
+ * @param raise_error The raise_error value to set.
+ */
+PRISM_EXPORTED_FUNCTION void pm_options_raise_error_set(pm_options_t *options, uint8_t raise_error) PRISM_NONNULL(1);
+
+/**
+ * Allocate and zero out the scopes array on the given options struct.
+ *
+ * @param options The options struct to initialize the scopes array on.
+ * @param scopes_count The number of scopes to allocate.
+ * @returns Whether or not the scopes array was initialized successfully.
+ */
+PRISM_EXPORTED_FUNCTION bool pm_options_scopes_init(pm_options_t *options, size_t scopes_count) PRISM_NONNULL(1);
+
+/**
+ * Return a constant pointer to the scope at the given index within the given
+ * options.
+ *
+ * @param options The options struct to get the scope from.
+ * @param index The index of the scope to get.
+ * @returns A constant pointer to the scope at the given index.
+ */
+PRISM_EXPORTED_FUNCTION const pm_options_scope_t * pm_options_scope(const pm_options_t *options, size_t index) PRISM_NONNULL(1);
+
+/**
+ * Return a mutable pointer to the scope at the given index within the given
+ * options.
+ *
+ * @param options The options struct to get the scope from.
+ * @param index The index of the scope to get.
+ * @returns A mutable pointer to the scope at the given index.
+ */
+PRISM_EXPORTED_FUNCTION pm_options_scope_t * pm_options_scope_mut(pm_options_t *options, size_t index) PRISM_NONNULL(1);
+
+/**
+ * Create a new options scope struct. This will hold a set of locals that are in
+ * scope surrounding the code that is being parsed. If the scope was unable to
+ * allocate its locals, this function will abort the process.
+ *
+ * @param scope The scope struct to initialize.
+ * @param locals_count The number of locals to allocate.
+ */
+PRISM_EXPORTED_FUNCTION void pm_options_scope_init(pm_options_scope_t *scope, size_t locals_count) PRISM_NONNULL(1);
+
+/**
+ * Return a constant pointer to the local at the given index within the given
+ * scope.
+ *
+ * @param scope The scope struct to get the local from.
+ * @param index The index of the local to get.
+ * @returns A constant pointer to the local at the given index.
+ */
+PRISM_EXPORTED_FUNCTION const pm_string_t * pm_options_scope_local(const pm_options_scope_t *scope, size_t index) PRISM_NONNULL(1);
+
+/**
+ * Return a mutable pointer to the local at the given index within the given
+ * scope, for setting the local's name with pm_string_init. The parser copies
+ * the name when it is created, so its bytes must remain valid until then.
+ *
+ * @param scope The scope struct to get the local from.
+ * @param index The index of the local to get.
+ * @returns A mutable pointer to the local at the given index.
+ */
+PRISM_EXPORTED_FUNCTION pm_string_t * pm_options_scope_local_mut(pm_options_scope_t *scope, size_t index) PRISM_NONNULL(1);
+
+/**
+ * Set the forwarding option on the given scope struct.
+ *
+ * @param scope The scope struct to set the forwarding on.
+ * @param forwarding The forwarding value to set.
+ */
+PRISM_EXPORTED_FUNCTION void pm_options_scope_forwarding_set(pm_options_scope_t *scope, uint8_t forwarding) PRISM_NONNULL(1);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif