add microros precompiled libs

Author: hierophect

ports/espressif/microros-ext/esp32/libmicroros.a

@@ -0,0 +1,123 @@
+// Copyright 2020 Open Source Robotics Foundation, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef RCL_LOGGING_INTERFACE__RCL_LOGGING_INTERFACE_H_
+#define RCL_LOGGING_INTERFACE__RCL_LOGGING_INTERFACE_H_
+
+#include "rcl_logging_interface/visibility_control.h"
+#include "rcutils/allocator.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum
+{
+  RCL_LOGGING_RET_OK = 0,
+  RCL_LOGGING_RET_ERROR = 2,
+  RCL_LOGGING_RET_INVALID_ARGUMENT = 11,
+  RCL_LOGGING_RET_CONFIG_FILE_DOESNT_EXIST = 21,
+  RCL_LOGGING_RET_CONFIG_FILE_INVALID = 22,
+} rcl_logging_ret_t;
+
+/// Initialize the external logging library.
+/**
+ * \param[in] config_file The location of a config file that the external
+ *   logging library should use to configure itself.
+ *   If provided, it must be a null terminated C string.
+ *   If set to NULL or the empty string, the logging library will use defaults.
+ * \param[in] allocator The allocator to use for memory allocation.  This is
+ *   an rcutils_allocator_t rather than an rcl_allocator_t to ensure that the
+ *   rcl_logging_* packages don't have a circular dependency back to rcl.
+ * \return RCL_LOGGING_RET_OK if initialized successfully.
+ * \return RCL_LOGGING_RET_ERROR if an unspecified error occurs.
+ * \return RCL_LOGGING_RET_CONFIG_FILE_DOESNT_EXIST if a config_file is provided
+ *   but the file doesn't exist.
+ * \return RCL_LOGGING_RET_CONFIG_FILE_INVALID if a config_file is provided but
+ *   the logging backend doesn't understand it.
+ */
+RCL_LOGGING_INTERFACE_PUBLIC
+RCUTILS_WARN_UNUSED
+rcl_logging_ret_t
+rcl_logging_external_initialize(const char * config_file, rcutils_allocator_t allocator);
+
+/// Free the resources allocated for the external logging system.
+/**
+ * This puts the system into a state equivalent to being uninitialized.
+ *
+ * \return RCL_LOGGING_RET_OK if successfully shutdown, or
+ * \return RCL_LOGGING_RET_ERROR if an unspecified error occurs.
+ */
+RCL_LOGGING_INTERFACE_PUBLIC
+RCUTILS_WARN_UNUSED
+rcl_logging_ret_t
+rcl_logging_external_shutdown();
+
+/// Log a message.
+/**
+ * \param[in] severity The severity level of the message being logged.
+ * \param[in] name The name of the logger, must either be a null terminated
+ *   C string or NULL.
+ *   If NULL or empty the root logger will be used.
+ * \param[in] msg The message to be logged. Must be a null terminated C string.
+ */
+RCL_LOGGING_INTERFACE_PUBLIC
+void
+rcl_logging_external_log(int severity, const char * name, const char * msg);
+
+/// Set the severity level for a logger.
+/**
+ * This function sets the severity level for the specified logger.
+ * If the name provided is an empty string or NULL it will change the level of
+ * the root logger.
+ *
+ * \param[in] name The name of the logger.
+ *   Must be a null terminated C string or NULL.
+ * \param[in] level The severity level to be used for the specified logger.
+ * \return RCL_LOGGING_RET_OK if set successfully, or
+ * \return RCL_LOGGING_RET_ERROR if an unspecified error occurs.
+ */
+RCL_LOGGING_INTERFACE_PUBLIC
+RCUTILS_WARN_UNUSED
+rcl_logging_ret_t rcl_logging_external_set_logger_level(const char * name, int level);
+
+/// Get the logging directory.
+/**
+ * Uses various environment variables to construct a logging directory path.
+ *
+ * Use $ROS_LOG_DIR if ROS_LOG_DIR is set and not empty.
+ * Otherwise, use $ROS_HOME/log, using ~/.ros for ROS_HOME if not set or if empty.
+ *
+ * It also expands an initial '~' to the current user's home directory,
+ * and converts the path separator if necessary.
+ *
+ * If successful, the directory C string should be deallocated using the given allocator when it is
+ * no longer needed.
+ *
+ * \param[in] allocator The allocator to use for memory allocation.
+ * \param[out] directory The C string pointer at which to write the directory path.
+ *   Only meaningful if the call is successful. Must not be nullptr and must point to nullptr.
+ * \return RCL_LOGGING_RET_OK if successful, or
+ * \return RCL_LOGGING_RET_INVALID_ARGUMENT if any arguments are invalid, or
+ * \return RCL_LOGGING_RET_ERROR if an unspecified error occurs.
+ */
+RCL_LOGGING_INTERFACE_PUBLIC
+rcl_logging_ret_t
+rcl_logging_get_logging_directory(rcutils_allocator_t allocator, char ** directory);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // RCL_LOGGING_INTERFACE__RCL_LOGGING_INTERFACE_H_

ports/espressif/microros-ext/esp32s2/libmicroros.a

@@ -0,0 +1,57 @@
+// Copyright 2020 Open Source Robotics Foundation, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef RCL_LOGGING_INTERFACE__VISIBILITY_CONTROL_H_
+#define RCL_LOGGING_INTERFACE__VISIBILITY_CONTROL_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// This logic was borrowed (then namespaced) from the examples on the gcc wiki:
+//     https://gcc.gnu.org/wiki/Visibility
+
+#if defined _WIN32 || defined __CYGWIN__
+  #ifdef __GNUC__
+    #define RCL_LOGGING_INTERFACE_EXPORT __attribute__ ((dllexport))
+    #define RCL_LOGGING_INTERFACE_IMPORT __attribute__ ((dllimport))
+  #else
+    #define RCL_LOGGING_INTERFACE_EXPORT __declspec(dllexport)
+    #define RCL_LOGGING_INTERFACE_IMPORT __declspec(dllimport)
+  #endif
+  #ifdef RCL_LOGGING_INTERFACE_BUILDING_DLL
+    #define RCL_LOGGING_INTERFACE_PUBLIC RCL_LOGGING_INTERFACE_EXPORT
+  #else
+    #define RCL_LOGGING_INTERFACE_PUBLIC RCL_LOGGING_INTERFACE_IMPORT
+  #endif
+  #define RCL_LOGGING_INTERFACE_PUBLIC_TYPE RCL_LOGGING_INTERFACE_PUBLIC
+  #define RCL_LOGGING_INTERFACE_LOCAL
+#else
+  #define RCL_LOGGING_INTERFACE_EXPORT __attribute__ ((visibility("default")))
+  #define RCL_LOGGING_INTERFACE_IMPORT
+  #if __GNUC__ >= 4
+    #define RCL_LOGGING_INTERFACE_PUBLIC __attribute__ ((visibility("default")))
+    #define RCL_LOGGING_INTERFACE_LOCAL  __attribute__ ((visibility("hidden")))
+  #else
+    #define RCL_LOGGING_INTERFACE_PUBLIC
+    #define RCL_LOGGING_INTERFACE_LOCAL
+  #endif
+  #define RCL_LOGGING_INTERFACE_PUBLIC_TYPE
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // RCL_LOGGING_INTERFACE__VISIBILITY_CONTROL_H_

ports/espressif/microros-ext/esp32s3/libmicroros.a

@@ -0,0 +1,166 @@
+// Copyright 2015 Open Source Robotics Foundation, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/// \file
+
+#ifndef RCUTILS__ALLOCATOR_H_
+#define RCUTILS__ALLOCATOR_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdbool.h>
+#include <stddef.h>
+
+#include "rcutils/macros.h"
+#include "rcutils/types/rcutils_ret.h"
+#include "rcutils/visibility_control.h"
+
+/// Encapsulation of an allocator.
+/**
+ * The default allocator uses malloc(), free(), calloc(), and realloc().
+ * It can be obtained using rcutils_get_default_allocator().
+ *
+ * The allocator should be trivially copyable.
+ * Meaning that the struct should continue to work after being assignment
+ * copied into a new struct.
+ * Specifically the object pointed to by the state pointer should remain valid
+ * until all uses of the allocator have been made.
+ * Particular care should be taken when giving an allocator to functions like
+ * rcutils_*_init() where it is stored within another object and used later.
+ * Developers should note that, while the fields of a const-qualified allocator
+ * struct cannot be modified, the state of the allocator can be modified.
+ */
+typedef struct rcutils_allocator_s
+{
+  /// Allocate memory, given a size and the `state` pointer.
+  /** An error should be indicated by returning `NULL`. */
+  void * (*allocate)(size_t size, void * state);
+  /// Deallocate previously allocated memory, mimicking free().
+  /** Also takes the `state` pointer. */
+  void (* deallocate)(void * pointer, void * state);
+  /// Reallocate if possible, otherwise it deallocates and allocates.
+  /**
+   * Also takes the `state` pointer.
+   *
+   * If unsupported then do deallocate and then allocate.
+   * This should behave as realloc() does, as opposed to posix's
+   * [reallocf](https://linux.die.net/man/3/reallocf), i.e. the memory given
+   * by pointer will not be free'd automatically if realloc() fails.
+   * For reallocf-like behavior use rcutils_reallocf().
+   * This function must be able to take an input pointer of `NULL` and succeed.
+   */
+  void * (*reallocate)(void * pointer, size_t size, void * state);
+  /// Allocate memory with all elements set to zero, given a number of elements and their size.
+  /** An error should be indicated by returning `NULL`. */
+  void * (*zero_allocate)(size_t number_of_elements, size_t size_of_element, void * state);
+  /// Implementation defined state storage.
+  /**
+   * This is passed as the final parameter to other allocator functions.
+   * Note that the contents of the state can be modified even in const-qualified
+   * allocator objects.
+   */
+  void * state;
+} rcutils_allocator_t;
+
+/// Return a zero initialized allocator.
+/**
+ * Note that this is an invalid allocator and should only be used as a placeholder.
+ */
+RCUTILS_PUBLIC
+RCUTILS_WARN_UNUSED
+rcutils_allocator_t
+rcutils_get_zero_initialized_allocator(void);
+
+/// Set rcutils default allocators.
+/**
+ * <hr>
+ * Attribute          | Adherence
+ * ------------------ | -------------
+ * Allocates Memory   | No
+ * Thread-Safe        | Yes
+ * Uses Atomics       | No
+ * Lock-Free          | Yes
+ */
+RCUTILS_PUBLIC
+RCUTILS_WARN_UNUSED
+bool
+rcutils_set_default_allocator(rcutils_allocator_t * allocator);
+  
+/// Return a properly initialized rcutils_allocator_t with default values.
+/**
+ * This defaults to:
+ *
+ * - allocate = wraps malloc()
+ * - deallocate = wraps free()
+ * - reallocate = wraps realloc()
+ * - zero_allocate = wraps calloc()
+ * - state = `NULL`
+ *
+ * <hr>
+ * Attribute          | Adherence
+ * ------------------ | -------------
+ * Allocates Memory   | No
+ * Thread-Safe        | Yes
+ * Uses Atomics       | No
+ * Lock-Free          | Yes
+ */
+RCUTILS_PUBLIC
+RCUTILS_WARN_UNUSED
+rcutils_allocator_t
+rcutils_get_default_allocator(void);
+
+/// Return true if the given allocator has non-null function pointers.
+/**
+ * \param[in] allocator to be checked by the function
+ * \return `true` if the allocator is valid, `false` otherwise.
+ */
+RCUTILS_PUBLIC
+RCUTILS_WARN_UNUSED
+bool
+rcutils_allocator_is_valid(const rcutils_allocator_t * allocator);
+
+/// Check the given allocator and run fail_statement if it is not valid.
+#define RCUTILS_CHECK_ALLOCATOR(allocator, fail_statement) \
+  if (!rcutils_allocator_is_valid(allocator)) { \
+    fail_statement; \
+  }
+
+/// Check the given allocator, and set the message in msg and run fail_statement if it is not valid.
+#define RCUTILS_CHECK_ALLOCATOR_WITH_MSG(allocator, msg, fail_statement) \
+  if (!rcutils_allocator_is_valid(allocator)) { \
+    RCUTILS_SET_ERROR_MSG(msg); \
+    fail_statement; \
+  }
+
+/// Emulate the behavior of [reallocf](https://linux.die.net/man/3/reallocf).
+/**
+ * This function will return `NULL` if the allocator is `NULL` or has `NULL` for
+ * function pointer fields.
+ * \param[inout] pointer to the memory which will be reallocated
+ * \param[in] size in bytes
+ * \param[in] allocator to be used to allocate and deallocate memory
+ */
+RCUTILS_PUBLIC
+RCUTILS_WARN_UNUSED
+void *
+rcutils_reallocf(void * pointer, size_t size, rcutils_allocator_t * allocator);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // RCUTILS__ALLOCATOR_H_