caiyu/gmio
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Improve use of inlined functions

Browse Source
This commit is contained in:
Hugues Delorme 2015-03-31 10:10:26 +02:00
parent 82f6386256
commit 0f3b8d1e59
17 changed files with 92 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/gmio_core/buffer.c
View File

@ -25,7 +25,7 @@
# include <malloc.h>
#endif
GMIO_INLINE static gmio_buffer_t gmio_buffer_null()
GMIO_INLINE gmio_buffer_t gmio_buffer_null()
{
gmio_buffer_t buff = { 0 };
return buff;

8
src/gmio_core/error.h
View File

@ -50,4 +50,12 @@ enum gmio_error
typedef enum gmio_error gmio_error_t;
/*! Returns true if <tt>code == GMIO_NO_ERROR</tt> */
GMIO_INLINE gmio_bool_t gmio_no_error(int code)
{ return code == GMIO_NO_ERROR; }
/*! Returns true if <tt>code != GMIO_NO_ERROR</tt> */
GMIO_INLINE gmio_bool_t gmio_error(int code)
{ return code != GMIO_NO_ERROR; }
#endif /* GMIO_ERROR_H */

6
src/gmio_core/global.h
View File

@ -114,9 +114,11 @@ typedef double gmio_float64_t;
#ifndef GMIO_INLINE
# if defined(__GNUC__)
# define GMIO_INLINE __inline__ /* Compatible with C90 */
# define GMIO_INLINE __inline__ static /* Compatible with C90 */
# elif defined(_MSC_VER)
# define GMIO_INLINE __inline
# define GMIO_INLINE __inline static
# elif !defined(DOXYGEN)
# define GMIO_INLINE
# else
/*! Expands to the C compiler specific inline keyword (if any) */
# define GMIO_INLINE

25
src/gmio_core/internal/byte_codec.h
View File

@ -13,16 +13,13 @@
** "http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html".
****************************************************************************/
/* WARNING :
* this header has no multi-inclusion guard. It must be included only once
* in the translation unit of use. The reason is that all functions
* defined here are meant to be inlined for performance purpose
*/
#ifndef GMIO_INTERNAL_BYTE_CODEC_H
#define GMIO_INTERNAL_BYTE_CODEC_H
#include "../global.h"
/*! Reads a 16bit integer from memory-location \p bytes (little-endian) */
GMIO_INLINE static uint16_t gmio_decode_uint16_le(const uint8_t* bytes)
GMIO_INLINE uint16_t gmio_decode_uint16_le(const uint8_t* bytes)
{
/* |0 |1 | */
/* |BB|AA| -> 0xAABB */
@ -30,7 +27,7 @@ GMIO_INLINE static uint16_t gmio_decode_uint16_le(const uint8_t* bytes)
}
/*! Reads a 16bit integer from memory-location \p bytes (big-endian) */
GMIO_INLINE static uint16_t gmio_decode_uint16_be(const uint8_t* bytes)
GMIO_INLINE uint16_t gmio_decode_uint16_be(const uint8_t* bytes)
{
/* |0 |1 | */
/* |AA|BB| -> 0xAABB */
@ -39,28 +36,28 @@ GMIO_INLINE static uint16_t gmio_decode_uint16_be(const uint8_t* bytes)
/*! Writes 16bit integer \p val to the memory location at \p bytes in
* little-endian */
GMIO_INLINE static void gmio_encode_uint16_le(uint16_t val, uint8_t* bytes)
GMIO_INLINE void gmio_encode_uint16_le(uint16_t val, uint8_t* bytes)
{
bytes[0] = val & 0xFF;
bytes[1] = (val >> 8) & 0xFF;
}
/*! Reads a 32bit integer from memory-location \p bytes (little-endian) */
GMIO_INLINE static uint32_t gmio_decode_uint32_le(const uint8_t* bytes)
GMIO_INLINE uint32_t gmio_decode_uint32_le(const uint8_t* bytes)
{
/* |DD|CC|BB|AA| -> 0xAABBCCDD */
return bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24);
}
/*! Reads a 32bit integer from memory-location \p bytes (mixed-endian) */
GMIO_INLINE static uint32_t gmio_decode_uint32_me(const uint8_t* bytes)
GMIO_INLINE uint32_t gmio_decode_uint32_me(const uint8_t* bytes)
{
/* |DD|CC|BB|AA| -> 0xCCDDAABB */
return (bytes[0] << 16) | (bytes[1] << 24) | (bytes[3] << 8) | bytes[2];
}
/*! Reads a 32bit integer from memory-location \p bytes (big-endian) */
GMIO_INLINE static uint32_t gmio_decode_uint32_be(const uint8_t* bytes)
GMIO_INLINE uint32_t gmio_decode_uint32_be(const uint8_t* bytes)
{
/* |DD|CC|BB|AA| -> 0xDDCCBBAA */
return bytes[3] | (bytes[2] << 8) | (bytes[1] << 16) | (bytes[0] << 24);
@ -68,7 +65,7 @@ GMIO_INLINE static uint32_t gmio_decode_uint32_be(const uint8_t* bytes)
/*! Writes 32bit integer \p val to the memory location at \p bytes in
* little-endian */
GMIO_INLINE static void gmio_encode_uint32_le(uint32_t val, uint8_t* bytes)
GMIO_INLINE void gmio_encode_uint32_le(uint32_t val, uint8_t* bytes)
{
bytes[0] = val & 0xFF;
bytes[1] = (val >> 8) & 0xFF;
@ -78,10 +75,12 @@ GMIO_INLINE static void gmio_encode_uint32_le(uint32_t val, uint8_t* bytes)
/*! Writes 32bit integer \p val to the memory location at \p bytes in
* big-endian */
GMIO_INLINE static void gmio_encode_uint32_be(uint32_t val, uint8_t* bytes)
GMIO_INLINE void gmio_encode_uint32_be(uint32_t val, uint8_t* bytes)
{
bytes[0] = (val >> 24) & 0xFF;
bytes[1] = (val >> 16) & 0xFF;
bytes[2] = (val >> 8) & 0xFF;
bytes[3] = val & 0xFF;
}
#endif /* GMIO_INTERNAL_BYTE_CODEC_H */

13
src/gmio_core/internal/byte_swap.h
View File

@ -13,11 +13,8 @@
** "http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html".
****************************************************************************/
/* WARNING :
* this header has no multi-inclusion guard. It must be included only once
* in the translation unit of use. The reason is that all functions
* defined here are meant to be inlined for performance purpose
*/
#ifndef GMIO_INTERNAL_BYTE_SWAP_H
#define GMIO_INTERNAL_BYTE_SWAP_H
#include "../global.h"
@ -27,7 +24,7 @@
/*! Returns \p val with the order of bytes reversed, uses compiler builtin
* functions if available */
GMIO_INLINE static uint16_t gmio_uint16_bswap(uint16_t val)
GMIO_INLINE uint16_t gmio_uint16_bswap(uint16_t val)
{
#ifdef GMIO_HAVE_GCC_BUILTIN_BSWAP16_FUNC
return __builtin_bswap16(val);
@ -40,7 +37,7 @@ GMIO_INLINE static uint16_t gmio_uint16_bswap(uint16_t val)
/*! Returns \p val with the order of bytes reversed, uses compiler builtin
* functions if available */
GMIO_INLINE static uint32_t gmio_uint32_bswap(uint32_t val)
GMIO_INLINE uint32_t gmio_uint32_bswap(uint32_t val)
{
#ifdef GMIO_HAVE_GCC_BUILTIN_BSWAP32_FUNC
return __builtin_bswap32(val);
@ -54,3 +51,5 @@ GMIO_INLINE static uint32_t gmio_uint32_bswap(uint32_t val)
| ((val >> 24) & 0x000000FF);
#endif
}
#endif /* GMIO_INTERNAL_BYTE_SWAP_H */

33
src/gmio_core/internal/fast_atof.h
View File

@ -4,20 +4,17 @@
* and irrXML.h
*/
/* Adapted to ISO-C90.
*
* WARNING :
* this header has no multi-inclusion guard. It must be included only once
* in the translation unit of use. The reason is that all functions
* defined here are meant to be inlined for performance purpose
*/
/* Adapted to ISO-C90 */
#ifndef GMIO_INTERNAL_FAST_ATOF_H
#define GMIO_INTERNAL_FAST_ATOF_H
#include "../global.h"
#include <float.h>
#include <limits.h>
GMIO_INLINE static gmio_bool_t is_local_decimal_point(char in)
GMIO_INLINE gmio_bool_t is_local_decimal_point(char in)
{
/*! Selection of characters which count as decimal point in fast_atof
* TODO: This should probably also be used in irr::core::string, but
@ -60,7 +57,7 @@ const float fast_atof_table[17] = {
* \return The unsigned integer value of the digits. If the string specifies
* too many digits to encode in an uint32_t then INT_MAX will be returned.
*/
GMIO_INLINE static uint32_t strtoul10(const char* in, const char** out)
GMIO_INLINE uint32_t strtoul10(const char* in, const char** out)
{
gmio_bool_t overflow=GMIO_FALSE;
uint32_t unsignedValue = 0;
@ -99,7 +96,7 @@ GMIO_INLINE static uint32_t strtoul10(const char* in, const char** out)
* too many digits to encode in an int32_t then +INT_MAX or -INT_MAX will be
* returned.
*/
GMIO_INLINE static int32_t strtol10(const char* in, const char** out)
GMIO_INLINE int32_t strtol10(const char* in, const char** out)
{
const gmio_bool_t negative = ('-' == *in);
uint32_t unsignedValue = 0;
@ -136,7 +133,7 @@ GMIO_INLINE static int32_t strtol10(const char* in, const char** out)
* \return The unsigned integer value of the digit. 0xffffffff if the input is
* not hex
*/
GMIO_INLINE static uint32_t ctoul16(char in)
GMIO_INLINE uint32_t ctoul16(char in)
{
if (in >= '0' && in <= '9')
return in - '0';
@ -158,7 +155,7 @@ GMIO_INLINE static uint32_t ctoul16(char in)
* \return The unsigned integer value of the digits. If the string specifies
* too many digits to encode in an uint32_t then INT_MAX will be returned.
*/
GMIO_INLINE static uint32_t strtoul16(const char* in, const char** out)
GMIO_INLINE uint32_t strtoul16(const char* in, const char** out)
{
gmio_bool_t overflow=GMIO_FALSE;
uint32_t unsignedValue = 0;
@ -203,7 +200,7 @@ GMIO_INLINE static uint32_t strtoul16(const char* in, const char** out)
* \return The unsigned integer value of the digits. If the string specifies
* too many digits to encode in an uint32_t then INT_MAX will be returned.
*/
GMIO_INLINE static uint32_t strtoul8(const char* in, const char** out)
GMIO_INLINE uint32_t strtoul8(const char* in, const char** out)
{
gmio_bool_t overflow=GMIO_FALSE;
uint32_t unsignedValue = 0;
@ -245,7 +242,7 @@ GMIO_INLINE static uint32_t strtoul8(const char* in, const char** out)
* \return The unsigned integer value of the digits. If the string specifies
* too many digits to encode in an uint32_t then INT_MAX will be returned.
*/
GMIO_INLINE static uint32_t strtoul_prefix(const char* in, const char** out)
GMIO_INLINE uint32_t strtoul_prefix(const char* in, const char** out)
{
if (!in)
{
@ -268,7 +265,7 @@ GMIO_INLINE static uint32_t strtoul_prefix(const char* in, const char** out)
* \return The whole positive floating point representation of the digit
* sequence.
*/
GMIO_INLINE static gmio_float32_t strtof10(const char* in, const char** out)
GMIO_INLINE gmio_float32_t strtof10(const char* in, const char** out)
{
const uint32_t MAX_SAFE_U32_VALUE = UINT_MAX / 10 - 10;
uint32_t intValue = 0;
@ -315,7 +312,7 @@ GMIO_INLINE static gmio_float32_t strtof10(const char* in, const char** out)
* \return Pointer to the first character in the string that wasn't used
* to create the float value.
*/
GMIO_INLINE static const char* fast_atof_move(
GMIO_INLINE const char* fast_atof_move(
const char* in, gmio_float32_t* result)
{
const gmio_bool_t negative = ('-' == *in);
@ -360,7 +357,7 @@ GMIO_INLINE static const char* fast_atof_move(
* wasn't used to create the float value.
* \result Float value parsed from the input string
*/
GMIO_INLINE static float fast_atof(const char* floatAsString, const char** out)
GMIO_INLINE float fast_atof(const char* floatAsString, const char** out)
{
float ret;
if (out)
@ -369,3 +366,5 @@ GMIO_INLINE static float fast_atof(const char* floatAsString, const char** out)
fast_atof_move(floatAsString, &ret);
return ret;
}
#endif /* GMIO_INTERNAL_FAST_ATOF_H */

34
src/gmio_core/internal/helper_error.h
View File

@ -1,34 +0,0 @@
/****************************************************************************
** GeomIO Library
** Copyright FougSys (2 Mar. 2015)
** contact@fougsys.fr
**
** This software is a reusable library whose purpose is to provide complete
** I/O support for various CAD file formats (eg. STL)
**
** This software is governed by the CeCILL-B license under French law and
** abiding by the rules of distribution of free software. You can use,
** modify and/ or redistribute the software under the terms of the CeCILL-B
** license as circulated by CEA, CNRS and INRIA at the following URL
** "http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html".
****************************************************************************/
/* WARNING :
* this header has no multi-inclusion guard. It must be included only once
* in the translation unit of use. The reason is that all functions
* defined here are meant to be inlined for performance purpose
*/
#include "../error.h"
/*! Returns true if <tt>code == GMIO_NO_ERROR</tt> */
GMIO_INLINE static gmio_bool_t gmio_no_error(int code)
{
return code == GMIO_NO_ERROR;
}
/*! Returns true if <tt>code != GMIO_NO_ERROR</tt> */
GMIO_INLINE static gmio_bool_t gmio_error(int code)
{
return code != GMIO_NO_ERROR;
}

21
src/gmio_core/internal/helper_stream.h
View File

@ -13,16 +13,13 @@
** "http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html".
****************************************************************************/
/* WARNING :
* this header has no multi-inclusion guard. It must be included only once
* in the translation unit of use. The reason is that all functions
* defined here are meant to be inlined for performance purpose
*/
#ifndef GMIO_INTERNAL_HELPER_STREAM_H
#define GMIO_INTERNAL_HELPER_STREAM_H
#include "../stream.h"
/*! Safe and convenient function for gmio_stream::at_end_func() */
GMIO_INLINE static gmio_bool_t gmio_stream_at_end(gmio_stream_t* stream)
GMIO_INLINE gmio_bool_t gmio_stream_at_end(gmio_stream_t* stream)
{
if (stream != NULL && stream->at_end_func != NULL)
return stream->at_end_func(stream->cookie);
@ -30,7 +27,7 @@ GMIO_INLINE static gmio_bool_t gmio_stream_at_end(gmio_stream_t* stream)
}
/*! Safe and convenient function for gmio_stream::error_func() */
GMIO_INLINE static int gmio_stream_error(gmio_stream_t* stream)
GMIO_INLINE int gmio_stream_error(gmio_stream_t* stream)
{
if (stream != NULL && stream->error_func != NULL)
return stream->error_func(stream->cookie);
@ -38,7 +35,7 @@ GMIO_INLINE static int gmio_stream_error(gmio_stream_t* stream)
}
/*! Safe and convenient function for gmio_stream::read_func() */
GMIO_INLINE static size_t gmio_stream_read(
GMIO_INLINE size_t gmio_stream_read(
gmio_stream_t* stream, void *ptr, size_t size, size_t count)
{
if (stream != NULL && stream->read_func != NULL)
@ -47,7 +44,7 @@ GMIO_INLINE static size_t gmio_stream_read(
}
/*! Safe and convenient function for gmio_stream::write_func() */
GMIO_INLINE static size_t gmio_stream_write(
GMIO_INLINE size_t gmio_stream_write(
gmio_stream_t* stream, const void *ptr, size_t size, size_t count)
{
if (stream != NULL && stream->write_func != NULL)
@ -56,7 +53,7 @@ GMIO_INLINE static size_t gmio_stream_write(
}
/*! Safe and convenient function for gmio_stream::size_func() */
GMIO_INLINE static size_t gmio_stream_size(gmio_stream_t* stream)
GMIO_INLINE size_t gmio_stream_size(gmio_stream_t* stream)
{
if (stream != NULL && stream->size_func != NULL)
return stream->size_func(stream->cookie);
@ -64,8 +61,10 @@ GMIO_INLINE static size_t gmio_stream_size(gmio_stream_t* stream)
}
/*! Safe and convenient function for gmio_stream::rewind_func() */
GMIO_INLINE static void gmio_stream_rewind(gmio_stream_t* stream)
GMIO_INLINE void gmio_stream_rewind(gmio_stream_t* stream)
{
if (stream != NULL && stream->rewind_func != NULL)
stream->rewind_func(stream->cookie);
}
#endif /* GMIO_INTERNAL_HELPER_STREAM_H */

13
src/gmio_core/internal/helper_transfer.h
View File

@ -13,18 +13,15 @@
** "http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html".
****************************************************************************/
/* WARNING :
* this header has no multi-inclusion guard. It must be included only once
* in the translation unit of use. The reason is that all functions
* defined here are meant to be inlined for performance purpose
*/
#ifndef GMIO_INTERNAL_HELPER_TRANSFER_H
#define GMIO_INTERNAL_HELPER_TRANSFER_H
#include "../transfer.h"
#include <stddef.h>
/*! Safe and convenient function for gmio_transfer::is_stop_requested_func() */
GMIO_INLINE static gmio_bool_t gmio_transfer_is_stop_requested(
GMIO_INLINE gmio_bool_t gmio_transfer_is_stop_requested(
const gmio_transfer_t* trsf)
{
if (trsf != NULL && trsf->is_stop_requested_func != NULL)
@ -33,9 +30,11 @@ GMIO_INLINE static gmio_bool_t gmio_transfer_is_stop_requested(
}
/*! Safe and convenient function for gmio_transfer::handle_progress_func() */
GMIO_INLINE static void gmio_transfer_handle_progress(
GMIO_INLINE void gmio_transfer_handle_progress(
const gmio_transfer_t* trsf, size_t value, size_t max_value)
{
if (trsf != NULL && trsf->handle_progress_func != NULL)
trsf->handle_progress_func(trsf->cookie, value, max_value);
}
#endif /* GMIO_INTERNAL_HELPER_TRANSFER_H */

11
src/gmio_core/internal/safe_cast.h
View File

@ -13,18 +13,15 @@
** "http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html".
****************************************************************************/
/* WARNING :
* this header has no multi-inclusion guard. It must be included only once
* in the translation unit of use. The reason is that all functions
* defined here are meant to be inlined for performance purpose
*/
#ifndef GMIO_INTERNAL_SAFE_CAST_H
#define GMIO_INTERNAL_SAFE_CAST_H
#include "../global.h"
#include <stddef.h>
/*! Returns \p val safely casted to unsigned 32b integer */
GMIO_INLINE static uint32_t gmio_size_to_uint32(size_t val)
GMIO_INLINE uint32_t gmio_size_to_uint32(size_t val)
{
#if GMIO_TARGET_ARCH_BIT_SIZE > 32
return val > 0xFFFFFFFF ? 0xFFFFFFFF : (uint32_t)val;
@ -32,3 +29,5 @@ GMIO_INLINE static uint32_t gmio_size_to_uint32(size_t val)
return val;
#endif
}
#endif /* GMIO_INTERNAL_SAFE_CAST_H */

10
src/gmio_core/internal/string_parse.c
View File

@ -16,6 +16,10 @@
#include "string_parse.h"
#include "helper_stream.h"
/*#define GMIO_USE_FAST_ATOF*/
#ifdef GMIO_USE_FAST_ATOF
# include "fast_atof.h"
#endif
#include <ctype.h>
#include <errno.h>
@ -116,8 +120,10 @@ int gmio_get_float32(const char *str, gmio_float32_t *value_ptr)
{
char* end_ptr; /* for strtod() */
#ifdef GMIO_HAVE_STRTOF_FUNC
*value_ptr = strtof(str, &end_ptr); /* Requires C99 */
#if defined(GMIO_USE_FAST_ATOF)
*value_ptr = fast_atof(str, &end_ptr);
#elif defined(GMIO_HAVE_STRTOF_FUNC) /* Requires C99 */
*value_ptr = strtof(str, &end_ptr);
#else
*value_ptr = (gmio_float32_t)strtod(str, &end_ptr);
#endif

17
src/gmio_stl/internal/helper_stl_mesh_creator.h
View File

@ -13,17 +13,14 @@
** "http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html".
****************************************************************************/
/* WARNING :
* this header has no multi-inclusion guard. It must be included only once
* in the translation unit of use. The reason is that all functions
* defined here are meant to be inlined for performance purpose
*/
#ifndef GMIO_INTERNAL_HELPER_STL_MESH_CREATOR_H
#define GMIO_INTERNAL_HELPER_STL_MESH_CREATOR_H
#include "../stl_mesh_creator.h"
/*! Safe and convenient function for
* gmio_stl_mesh_creator::ascii_begin_solid_func() */
GMIO_INLINE static void gmio_stl_mesh_creator_ascii_begin_solid(
GMIO_INLINE void gmio_stl_mesh_creator_ascii_begin_solid(
gmio_stl_mesh_creator_t* creator,
size_t stream_size,
const char* solid_name)
@ -36,7 +33,7 @@ GMIO_INLINE static void gmio_stl_mesh_creator_ascii_begin_solid(
/*! Safe and convenient function for
* gmio_stl_mesh_creator::binary_begin_solid_func() */
GMIO_INLINE static void gmio_stl_mesh_creator_binary_begin_solid(
GMIO_INLINE void gmio_stl_mesh_creator_binary_begin_solid(
gmio_stl_mesh_creator_t* creator,
uint32_t tri_count,
const uint8_t* header)
@ -47,7 +44,7 @@ GMIO_INLINE static void gmio_stl_mesh_creator_binary_begin_solid(
/*! Safe and convenient function for
* gmio_stl_mesh_creator::add_triangle_func() */
GMIO_INLINE static void gmio_stl_mesh_creator_add_triangle(
GMIO_INLINE void gmio_stl_mesh_creator_add_triangle(
gmio_stl_mesh_creator_t* creator,
uint32_t tri_id,
const gmio_stl_triangle_t* triangle)
@ -58,9 +55,11 @@ GMIO_INLINE static void gmio_stl_mesh_creator_add_triangle(
/*! Safe and convenient function for
* gmio_stl_mesh_creator::end_solid_func() */
GMIO_INLINE static void gmio_stl_mesh_creator_end_solid(
GMIO_INLINE void gmio_stl_mesh_creator_end_solid(
gmio_stl_mesh_creator_t* creator)
{
if (creator != NULL && creator->end_solid_func != NULL)
creator->end_solid_func(creator->cookie);
}
#endif /* GMIO_INTERNAL_HELPER_STL_MESH_CREATOR_H */

1
src/gmio_stl/internal/stl_rw_common.c
View File

@ -16,7 +16,6 @@
#include "stl_rw_common.h"
#include "../../gmio_core/error.h"
#include "../../gmio_core/internal/helper_error.h"
#include "../stl_error.h"
gmio_bool_t gmio_check_transfer(int *error, const gmio_transfer_t* trsf)

12
src/gmio_stl/stla_read.c
View File

@ -134,7 +134,7 @@ static void gmio_stream_fwd_iterator_stla_read_hook(
}
}
GMIO_INLINE static gmio_bool_t parsing_can_continue(
GMIO_INLINE gmio_bool_t parsing_can_continue(
const gmio_stla_parse_data_t* data)
{
if (!data->error && !data->stream_iterator_cookie.is_stop_requested)
@ -142,13 +142,13 @@ GMIO_INLINE static gmio_bool_t parsing_can_continue(
return GMIO_FALSE;
}
GMIO_INLINE static const char* current_token_as_identifier(
GMIO_INLINE const char* current_token_as_identifier(
const gmio_stla_parse_data_t* data)
{
return data->token == ID_token ? data->string_buffer.ptr : "";
}
GMIO_INLINE static int get_current_token_as_float32(
GMIO_INLINE int get_current_token_as_float32(
const gmio_stla_parse_data_t* data, gmio_float32_t* value_ptr)
{
if (data->token == FLOAT_token)
@ -156,7 +156,7 @@ GMIO_INLINE static int get_current_token_as_float32(
return -3;
}
GMIO_INLINE static void parsing_error(gmio_stla_parse_data_t* data)
GMIO_INLINE void parsing_error(gmio_stla_parse_data_t* data)
{
data->error = GMIO_TRUE;
data->token = unknown_token;
@ -239,7 +239,7 @@ static gmio_stla_token_t parsing_find_token(
return ID_token;
}
GMIO_INLINE static void parsing_advance(gmio_stla_parse_data_t* data)
GMIO_INLINE void parsing_advance(gmio_stla_parse_data_t* data)
{
if (!parsing_can_continue(data))
return;
@ -253,7 +253,7 @@ GMIO_INLINE static void parsing_advance(gmio_stla_parse_data_t* data)
parsing_error(data);
}
GMIO_INLINE static void parsing_eat_token(
GMIO_INLINE void parsing_eat_token(
gmio_stla_token_t token, gmio_stla_parse_data_t* data)
{
if (!parsing_can_continue(data))

1
src/gmio_stl/stla_write.c
View File

@ -21,7 +21,6 @@
#include "stl_error.h"
#include "../gmio_core/error.h"
#include "../gmio_core/internal/helper_error.h"
#include "../gmio_core/internal/helper_stream.h"
#include "../gmio_core/internal/helper_transfer.h"
#include "../gmio_core/internal/min_max.h"

3
src/gmio_stl/stlb_read.c
View File

@ -26,14 +26,13 @@
#include "../gmio_core/error.h"
#include "../gmio_core/internal/byte_swap.h"
#include "../gmio_core/internal/convert.h"
#include "../gmio_core/internal/helper_error.h"
#include "../gmio_core/internal/helper_stream.h"
#include "../gmio_core/internal/helper_transfer.h"
#include "../gmio_core/internal/safe_cast.h"
#include <string.h>
GMIO_INLINE static void read_triangle_memcpy(
GMIO_INLINE void read_triangle_memcpy(
const uint8_t* buffer, gmio_stl_triangle_t* triangle)
{
/* *triangle = *((gmio_stl_triangle_t*)(buffer)); */

3
src/gmio_stl/stlb_write.c
View File

@ -25,14 +25,13 @@
#include "../gmio_core/error.h"
#include "../gmio_core/internal/byte_codec.h"
#include "../gmio_core/internal/min_max.h"
#include "../gmio_core/internal/helper_error.h"
#include "../gmio_core/internal/helper_stream.h"
#include "../gmio_core/internal/helper_transfer.h"
#include "../gmio_core/internal/safe_cast.h"
#include <string.h>
GMIO_INLINE static void write_triangle_memcpy(
GMIO_INLINE void write_triangle_memcpy(
const gmio_stl_triangle_t* triangle, uint8_t* buffer)
{
memcpy(buffer, triangle, GMIO_STLB_TRIANGLE_RAWSIZE);