gullradriel/nilorea-library
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Page: n__common_8h
Pages
Examples Files Home Module AABB3D Module ACCEPT_POOL Module ALLEGRO4 Module ALLEGRO5 Module ANIM_LIB Module ASTAR Module ATLAS_LIB Module AVRO Module CLOCK_SYNC Module COMMONS Module CONFIGFILE Module CYPHER_BASE64 Module CYPHER_VIGENERE Module DEAD_RECKONING Module ENUMS Module EXCEPTIONS Module GAME_ENV Module GIT Module GUI Module HASH_TABLE Module ISOMETRIC_ENGINE Module LIST Module LOG Module LOGNODUP Module LZ4 Module NETWORKING Module NETWORK_MSG Module N_COOKIES Module N_DIFF Module N_DIGEST Module N_DISK_CACHE Module N_DNS Module N_ECC Module N_ENTROPY Module N_FILES Module N_FLUIDS Module N_GUI_COLOR Module N_GUI_COLORWHEEL Module N_GUI_CURVE Module N_GUI_GRID Module N_GUI_POPUP Module N_HEX Module N_HTTP3 Module N_HTTP_COOKIE Module N_HTTP_FORM Module N_HTTP_MIME Module N_HTTP_REQ Module N_HTTP_RESP Module N_HTTP_ROUTER Module N_HTTP_SERVER Module N_ICC Module N_JSON Module N_KAFKA Module N_LINALG Module N_MODULE Module N_OPENSSL_COMPAT Module N_PRETTY Module N_PTH Module N_QUERY Module N_RANDOM Module N_SHA256 Module N_STR Module N_TIFF Module N_TIME Module N_USER Module N_X509 Module N_ZIP Module PARTICLES Module PCRE Module PHYSICS Module SIGNALS Module STACK Module THREADS Module TRAJECTORY Module TREE Module ZLIB Modules Pages Struct A4_BMP Struct A4_TIMER Struct AABB3D Struct ANIM_DATA Struct ANIM_FRAME Struct ANIM_GFX Struct ANIM_LIB Struct ASTAR_BOX Struct ASTAR_CELL Struct ASTAR_GRID Struct ASTAR_HEAP Struct ASTAR_HEAP_NODE Struct ASTAR_NODE Struct ASTAR_PATH Struct AVRO_FIELD Struct AVRO_READER Struct AVRO_SCHEMA Struct BITMAP Struct CALLBACK_DATA Struct CA_CTX Struct CLIENT_JOB Struct CLIENT_STATE Struct CONFIG_FILE Struct CONFIG_FILE_SECTION Struct CYPHER_PARAM Struct DATA Struct DEMO_PANEL Struct DICTIONARY_DEFINITION Struct DICTIONARY_ENTRY Struct DIFF_OUT Struct DIFF_TEXT Struct DRAW_STATE Struct DR_ENTITY Struct DR_STATE Struct DR_VEC3 Struct ExceptionContextList Struct FONT Struct GAME_ENV Struct H2BUF Struct H2_DYN_ENTRY Struct H2_STREAM Struct HASH_NODE Struct HASH_TABLE Struct ISO_DRAW_ENTRY Struct ISO_MAP Struct ISO_PROJECTION Struct ISO_TILE_SEGMENT Struct ISO_TILE_SEGMENTS Struct ISO_VISIBLE_EDGES Struct JS_STATE Struct LEX_ITEM Struct LIST Struct LIST_NODE Struct LOG_LEVELS Struct LexMenu Struct MEMBER Struct MIDI Struct NESTED Struct NETWORK Struct NETWORK_HTTP_INFO Struct NETWORK_POOL Struct NETWORK_SSL_THREAD_PARAMS Struct NETW_ACCEPT_POOL Struct NETW_ACCEPT_POOL_STATS Struct NETW_MSG Struct NETW_SNI_ARG Struct NODE_DATA Struct N_ATLAS Struct N_ATLAS_PAGE Struct N_CLOCK_SYNC Struct N_COOKIE Struct N_COOKIE_JAR Struct N_DIFF_LINE Struct N_DIFF_RESULT Struct N_DISK_CACHE Struct N_ENTROPY_BIT Struct N_ENTROPY_POS Struct N_FILE_INFO Struct N_FLUID Struct N_FLUID_THREAD_PARAMS Struct N_FORM_FIELD Struct N_GIT_COMMIT_INFO Struct N_GIT_REMOTE_AUTH Struct N_GIT_REPO Struct N_GIT_STATUS_ENTRY Struct N_GUI_BUTTON_DATA Struct N_GUI_CHECKBOX_DATA Struct N_GUI_COLOR_PICKER Struct N_GUI_COMBOBOX_DATA Struct N_GUI_CTX Struct N_GUI_CUSTOM_DATA Struct N_GUI_DATAGRID_COL Struct N_GUI_DATAGRID_DATA Struct N_GUI_DROPMENU_DATA Struct N_GUI_DROPMENU_ENTRY Struct N_GUI_GRID_CALLBACKS Struct N_GUI_HEXVIEW_DATA Struct N_GUI_IMAGE_DATA Struct N_GUI_KVTABLE Struct N_GUI_KV_CONTENT Struct N_GUI_KV_ROW Struct N_GUI_LABEL_DATA Struct N_GUI_LISTBOX_DATA Struct N_GUI_LISTITEM Struct N_GUI_MARKDOWNVIEW_DATA Struct N_GUI_MD_FONTS Struct N_GUI_MD_STYLE Struct N_GUI_MEAS_ENTRY Struct N_GUI_MOUSE_EVENT Struct N_GUI_PENDING_GEOM Struct N_GUI_PENDING_WIDGET Struct N_GUI_POPUP Struct N_GUI_PROGRESSBAR_DATA Struct N_GUI_RADIOLIST_DATA Struct N_GUI_SB_TRACK Struct N_GUI_SCROLLBAR_DATA Struct N_GUI_SECTION Struct N_GUI_SECTIONLIST Struct N_GUI_SLIDER_DATA Struct N_GUI_SPLITPANE_DATA Struct N_GUI_STYLE Struct N_GUI_SUGGEST_SINK Struct N_GUI_SYNTAXVIEW_DATA Struct N_GUI_TAB_PANEL Struct N_GUI_TB_BUTTONS Struct N_GUI_TEXTAREA_DATA Struct N_GUI_TEXT_DIMS Struct N_GUI_THEME Struct N_GUI_TREE Struct N_GUI_TREE_NODE Struct N_GUI_TREE_STATE Struct N_GUI_WIDGET Struct N_GUI_WINDOW Struct N_H2_FRAME Struct N_H2_HEADER Struct N_H2_HPACK Struct N_H2_REQUEST Struct N_H2_SERVER Struct N_H2_SETTING Struct N_HTML_ATTR_ Struct N_HTML_FORM Struct N_HTML_TAG_ Struct N_HTTP3_RESPONSE Struct N_HTTP_FIELD Struct N_HTTP_FORM Struct N_HTTP_FORM_MULTIPART Struct N_HTTP_FORM_PART Struct N_HTTP_MULTIPART_PART Struct N_HTTP_REQUEST Struct N_HTTP_RESP Struct N_HTTP_RESPONSE Struct N_HTTP_SERVER Struct N_HTTP_SERVER_CONFIG Struct N_HTTP_SERVER_REQUEST Struct N_HTTP_SERVER_STATS Struct N_HTTP_SET_COOKIE Struct N_HTTP_STREAM Struct N_ISO_CAMERA Struct N_ISO_OBJECT Struct N_KAFKA Struct N_KAFKA_EVENT Struct N_MOCK_SERVER Struct N_MODULE Struct N_PARALLEL_SLICE Struct N_PARALLEL_TEAM Struct N_PARALLEL_WORKER Struct N_PCRE Struct N_PROXY_CFG Struct N_PTH Struct N_PTH_TENSOR Struct N_QUERY Struct N_ROUTE Struct N_ROUTER Struct N_ROUTE_MATCH Struct N_SHA256 Struct N_SOCKET Struct N_SPAWN_PIPE Struct N_SSE_CONN Struct N_SSE_EVENT Struct N_STR Struct N_TIFF Struct N_TIFF_ENTRY Struct N_TIME Struct N_URL Struct N_URL_PARAM Struct N_USER Struct N_USERLIST Struct N_WS_CONN Struct N_WS_FRAME Struct N_WS_MESSAGE Struct N_ZIP_MEMBER Struct OCTREE Struct OCTREE_NODE Struct PARSER Struct PARTICLE Struct PARTICLE_EMITTER Struct PARTICLE_SYSTEM Struct PEER Struct PHYSICS Struct PK_OBJ Struct PK_VM Struct POINT2D Struct POINT3D Struct PRETTY_OUT Struct QNODE Struct QUADTREE Struct QUADTREE_NODE Struct REC Struct RGB Struct SAMPLE Struct SEEN Struct SHARER Struct SRV Struct SRV_ARG Struct STACK Struct STACK_ITEM Struct SYNTAX_RUN Struct THREAD_POOL Struct THREAD_POOL_NODE Struct THREAD_WAITING_PROC Struct TRAJECTORY Struct TRAJECTORY_POINT Struct TREE Struct TREE_NODE Struct TS_LOG Struct WAYPOINT3D Struct WORKER_ARG Struct ZIP_SINK Struct _N_DC_ENTRY Struct _N_DC_GROUP_ENTRY Struct _N_GUI_COLORWHEEL Struct _N_GUI_COLORWHEEL_BLOCK Struct _N_GUI_COLORWHEEL_MOUSE Struct _N_GUI_CURVE Struct _N_GUI_CURVE_BLOCK Struct _N_GUI_CURVE_MOUSE Struct _N_GUI_GRID Struct _N_GUI_POPUP_ENTRY Struct _N_GUI_POPUP_LEVEL Struct _N_GUI_SB_SKIN Struct _N_GUI_TA_STEP Struct _N_GUI_THUMB Struct _N_GUI_WRAP_ACC Struct _compiled Struct _conn Struct _ip_slot Struct _mp_param Struct _n_civil Struct _seg Struct client Struct collector Struct date_vector Struct md_atom Struct md_cells Struct md_hit Struct md_line_ctx Struct mline Struct n_http_req_header Struct n_http_req_limits Struct n_http_request Struct n_markdown_block Struct n_markdown_doc Struct n_markdown_inline Struct n_markdown_span Struct n_reactor_stats Struct n_url_safe Struct n_url_safe_head Struct n_wrap_item Struct producer_state Struct rects Struct reply Struct runner Struct sink Struct tbuf Struct wrap_hit Struct wrap_span Structures Union COORD_VALUE Union HASH_DATA Union NODE_DATA_TYPES Union STACK_DATA dir_310dcdd4703e877a6b99d5dc3fc54d27 dir_68267d1309a1af8e8297ef4c3efbcdba dir_d28a4824dc47e487b107a5db32ef43c4 dir_d44c64559bbebec7f509842c48db8b23 ex__accept__pool__client_8c ex__accept__pool__server_8c ex__allegro__4_8c ex__atlas_8c ex__avro_8c ex__base64_8c ex__bind__exclusive_8c ex__clipboard_8c ex__clock__sync_8c ex__common_8c ex__configfile_8c ex__cookies_8c ex__crypto_8c ex__diff_8c ex__digest_8c ex__disk__cache_8c ex__dns_8c ex__ecc_8c ex__entropy_8c ex__exceptions_8c ex__file_8c ex__file__copy_8c ex__fluid_8c ex__fluid__config_8c ex__fluid__config_8h ex__git_8c ex__gui_8c ex__gui__bench_8c ex__gui__button__keys_8c ex__gui__checkbox__label_8c ex__gui__checkbox__release_8c ex__gui__color__picker_8c ex__gui__colorwheel_8c ex__gui__combobox__items_8c ex__gui__combobox__wheel_8c ex__gui__cursor_8c ex__gui__curve_8c ex__gui__custom_8c ex__gui__custom__mouse_8c ex__gui__datagrid_8c ex__gui__datagrid__keys_8c ex__gui__datagrid__sort_8c ex__gui__detach_8c ex__gui__dictionary_8c ex__gui__display__fallback_8c ex__gui__double__click_8c ex__gui__dropmenu_8c ex__gui__frameless__drag_8c ex__gui__global__scroll_8c ex__gui__glyph_8c ex__gui__grid_8c ex__gui__hexview_8c ex__gui__hover_8c ex__gui__isometric_8c ex__gui__kvtable_8c ex__gui__label__fits_8c ex__gui__label__lines_8c ex__gui__layout__persist_8c ex__gui__listbox_8c ex__gui__md_8c ex__gui__multiwin_8c ex__gui__network_8c ex__gui__particles_8c ex__gui__placeholder_8c ex__gui__popup_8c ex__gui__progressbar_8c ex__gui__reentrant_8c ex__gui__round_8c ex__gui__sectionlist_8c ex__gui__slider__default_8c ex__gui__slider__handle_8c ex__gui__slider__step_8c ex__gui__splitpane_8c ex__gui__suggest_8c ex__gui__syntaxview_8c ex__gui__text__shorten_8c ex__gui__textarea__selection_8c ex__gui__tooltip_8c ex__gui__tree__lazy_8c ex__gui__tree__order_8c ex__gui__tree__state_8c ex__gui__window__rect_8c ex__gui__zorder_8c ex__hash_8c ex__hex_8c ex__html_8c ex__http2_8c ex__http2__server_8c ex__http3_8c ex__http__cookie_8c ex__http__form_8c ex__http__mime_8c ex__http__req_8c ex__http__response_8c ex__http__router_8c ex__http__server_8c ex__icc_8c ex__iso__astar_8c ex__json_8c ex__kafka_8c ex__linalg_8c ex__list_8c ex__log_8c ex__markdown_8c ex__module_8c ex__monolith_8c ex__network_8c ex__network_8h ex__network__accept_8c ex__network__alpn_8c ex__network__connect__abort_8c ex__network__mock_8c ex__network__proxy_8c ex__network__reactor_8c ex__network__sni_8c ex__network__sse_8c ex__network__ssl_8c ex__network__ssl__hardened_8c ex__network__ssl__hostname_8c ex__network__ssl__nonblock_8c ex__network__tls__defaults_8c ex__network__ws_8c ex__network__ws__limits_8c ex__nstr_8c ex__parallel__for_8c ex__parallel__team_8c ex__pcre_8c ex__pretty_8c ex__pth_8c ex__query_8c ex__random_8c ex__sha256_8c ex__signals_8c ex__spawn_8c ex__ssrf_8c ex__stack_8c ex__thread__pool__discard_8c ex__thread__pool__wait_8c ex__threads_8c ex__tiff_8c ex__time__formats_8c ex__trajectory_8c ex__trees_8c ex__url_8c ex__url__safe_8c ex__wrap_8c ex__x509_8c ex__zip_8c ex__zlib_8c ex_accept_pool_client_8c example ex_accept_pool_server_8c example ex_allegro_4_8c example ex_atlas_8c example ex_base64_8c example ex_clock_sync_8c example ex_common_8c example ex_configfile_8c example ex_cookies_8c example ex_crypto_8c example ex_diff_8c example ex_digest_8c example ex_disk_cache_8c example ex_dns_8c example ex_ecc_8c example ex_entropy_8c example ex_exceptions_8c example ex_file_8c example ex_file_copy_8c example ex_fluid_8c example ex_fluid_config_8c example ex_fluid_config_8h example ex_git_8c example ex_gui_8c example ex_gui_bench_8c example ex_gui_button_keys_8c example ex_gui_checkbox_label_8c example ex_gui_checkbox_release_8c example ex_gui_color_picker_8c example ex_gui_colorwheel_8c example ex_gui_combobox_items_8c example ex_gui_combobox_wheel_8c example ex_gui_cursor_8c example ex_gui_curve_8c example ex_gui_custom_8c example ex_gui_custom_mouse_8c example ex_gui_datagrid_8c example ex_gui_datagrid_keys_8c example ex_gui_datagrid_sort_8c example ex_gui_detach_8c example ex_gui_dictionary_8c example ex_gui_display_fallback_8c example ex_gui_double_click_8c example ex_gui_dropmenu_8c example ex_gui_frameless_drag_8c example ex_gui_global_scroll_8c example ex_gui_glyph_8c example ex_gui_grid_8c example ex_gui_hexview_8c example ex_gui_hover_8c example ex_gui_isometric_8c example ex_gui_kvtable_8c example ex_gui_label_fits_8c example ex_gui_label_lines_8c example ex_gui_layout_persist_8c example ex_gui_listbox_8c example ex_gui_md_8c example ex_gui_multiwin_8c example ex_gui_network_8c example ex_gui_particles_8c example ex_gui_placeholder_8c example ex_gui_popup_8c example ex_gui_progressbar_8c example ex_gui_reentrant_8c example ex_gui_round_8c example ex_gui_sectionlist_8c example ex_gui_slider_default_8c example ex_gui_slider_handle_8c example ex_gui_slider_step_8c example ex_gui_splitpane_8c example ex_gui_suggest_8c example ex_gui_syntaxview_8c example ex_gui_text_shorten_8c example ex_gui_textarea_selection_8c example ex_gui_tooltip_8c example ex_gui_tree_lazy_8c example ex_gui_tree_order_8c example ex_gui_tree_state_8c example ex_gui_window_rect_8c example ex_gui_zorder_8c example ex_hash_8c example ex_hex_8c example ex_html_8c example ex_http2_8c example ex_http2_server_8c example ex_http_cookie_8c example ex_http_form_8c example ex_http_mime_8c example ex_http_req_8c example ex_http_response_8c example ex_http_router_8c example ex_http_server_8c example ex_icc_8c example ex_iso_astar_8c example ex_json_8c example ex_kafka_8c example ex_linalg_8c example ex_list_8c example ex_log_8c example ex_markdown_8c example ex_module_8c example ex_monolith_8c example ex_network_8c example ex_network_8h example ex_network_accept_8c example ex_network_alpn_8c example ex_network_connect_abort_8c example ex_network_mock_8c example ex_network_proxy_8c example ex_network_reactor_8c example ex_network_sni_8c example ex_network_sse_8c example ex_network_ssl_8c example ex_network_ssl_hardened_8c example ex_network_ssl_hostname_8c example ex_network_ssl_nonblock_8c example ex_network_tls_defaults_8c example ex_network_ws_8c example ex_network_ws_limits_8c example ex_nstr_8c example ex_parallel_for_8c example ex_parallel_team_8c example ex_pcre_8c example ex_pretty_8c example ex_pth_8c example ex_query_8c example ex_random_8c example ex_sha256_8c example ex_signals_8c example ex_spawn_8c example ex_ssrf_8c example ex_stack_8c example ex_threads_8c example ex_tiff_8c example ex_time_formats_8c example ex_trajectory_8c example ex_trees_8c example ex_url_8c example ex_url_safe_8c example ex_wrap_8c example ex_x509_8c example ex_zip_8c example ex_zlib_8c example mainpage_8dox n__3d_8c n__3d_8h n__aabb_8c n__aabb_8h n__allegro5_8c n__allegro5_8h n__allegro__4_8c n__allegro__4_8h n__anim_8c n__anim_8h n__astar_8c n__astar_8h n__atlas_8c n__atlas_8h n__avro_8c n__avro_8h n__base64_8c n__base64_8h n__clipboard_8c n__clipboard_8h n__clock__sync_8c n__clock__sync_8h n__common_8c n__common_8h n__config__file_8c n__config__file_8h n__cookies_8c n__cookies_8h n__crypto_8c n__crypto_8h n__dead__reckoning_8c n__dead__reckoning_8h n__diff_8c n__diff_8h n__digest_8c n__digest_8h n__disk__cache_8c n__disk__cache_8h n__dns_8c n__dns_8h n__ecc_8c n__ecc_8h n__entropy_8c n__entropy_8h n__enum_8h n__exceptions_8c n__exceptions_8h n__files_8c n__files_8h n__fluids_8c n__fluids_8h n__games_8c n__games_8h n__git_8c n__git_8h n__gui_8c n__gui_8h n__gui__color_8c n__gui__color_8h n__gui__colorwheel_8c n__gui__colorwheel_8h n__gui__curve_8c n__gui__curve_8h n__gui__grid_8c n__gui__grid_8h n__gui__md_8c n__gui__md_8h n__gui__popup_8c n__gui__popup_8h n__hash_8c n__hash_8h n__hex_8c n__hex_8h n__html_8c n__html_8h n__http2_8c n__http2_8h n__http2__server_8c n__http2__server_8h n__http3_8c n__http3_8h n__http__cookie_8c n__http__cookie_8h n__http__form_8c n__http__form_8h n__http__mime_8c n__http__mime_8h n__http__req_8c n__http__req_8h n__http__response_8c n__http__response_8h n__http__router_8c n__http__router_8h n__http__server_8c n__http__server_8h n__icc_8c n__icc_8h n__iso__engine_8c n__iso__engine_8h n__json_8c n__json_8h n__kafka_8c n__kafka_8h n__linalg_8c n__linalg_8h n__list_8c n__list_8h n__log_8c n__log_8h n__lz4_8c n__lz4_8h n__markdown_8c n__markdown_8h n__module_8c n__module_8h n__network_8c n__network_8h n__network__accept__pool_8c n__network__accept__pool_8h n__network__msg_8c n__network__msg_8h n__nodup__log_8c n__nodup__log_8h n__openssl__compat_8h n__particles_8c n__particles_8h n__pcre_8c n__pcre_8h n__pretty_8c n__pretty_8h n__pth_8c n__pth_8h n__query_8c n__query_8h n__random_8c n__random_8h n__reactor_8c n__reactor_8h n__sha256_8c n__sha256_8h n__signals_8c n__signals_8h n__ssrf_8c n__ssrf_8h n__stack_8c n__stack_8h n__str_8c n__str_8h n__thread__pool_8c n__thread__pool_8h n__tiff_8c n__tiff_8h n__time_8c n__time_8h n__trajectory_8c n__trajectory_8h n__trees_8c n__trees_8h n__url__safe_8c n__url__safe_8h n__user_8c n__user_8h n__windows_8h n__wrap_8c n__wrap_8h n__x509_8c n__x509_8h n__zip_8c n__zip_8h n__zlib_8c n__zlib_8h nilorea_8h
9 n__common_8h
gullradriel edited this page 2026-10-29 20:54:40 +01:00
Table of Contents

include/nilorea/n_common.h

Common headers and low-level functions & define. More...

Detailed Description

Common headers and low-level functions & define.

Author: Castagnier Mickael

Version: 1.0

Date: 24/03/05

Source code

/*
 * Nilorea Library
 * Copyright (C) 2005-2026 Castagnier Mickael
 *
 * 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.
 *
 * SPDX-License-Identifier: Apache-2.0
 */


#ifndef __NILOREA_COMMONS__
#define __NILOREA_COMMONS__

#ifdef __cplusplus
extern "C" {
#endif


#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <malloc.h>
#include <errno.h>
#include <string.h>
#include <strings.h>
#include <stdint.h>
#include <nilorea/n_log.h>
#include <nilorea/n_enum.h>

#if defined(_WIN32) || defined(_WIN64)
#ifndef __windows__
#define __windows__
#endif
#ifndef WEXITSTATUS
#define WEXITSTATUS(w) (((w) >> 8) & 0xff)
#endif
#ifndef WIFEXITED
#define WIFEXITED(w) (((w) & 0xff) == 0)
#endif
#else
#include <alloca.h>
#include <signal.h>
#endif

#if defined(__GNUC__) && __GNUC__ >= 7
#define FALL_THROUGH __attribute__((fallthrough))
#else
#define FALL_THROUGH /* fall through */ \
    ((void)0)
#endif /* __GNUC__ >= 7 */

#if defined(_WIN32) || defined(_WIN64)
#if defined(_WIN64)
#define ENV_64BITS
#else
#define ENV_32BITS
#endif
#endif

#if !defined(ENV_32BITS) || !defined(ENV_64BITS)
#if defined(__GNUC__)
#if defined(__x86_64__) || defined(__ppc64__)
#define __ENVBITS __ENV_64BITS
#else
#define __ENVBITS __ENV_32BITS
#endif
#endif
#endif

#define BYTEORDER_LITTLE_ENDIAN 0  // Little endian machine.
#define BYTEORDER_BIG_ENDIAN 1  // Big endian machine.

#ifndef BYTEORDER_ENDIAN
// Detect with GCC 4.6's macro.
#if defined(__BYTE_ORDER__)
#if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
#define BYTEORDER_ENDIAN BYTEORDER_LITTLE_ENDIAN
#elif (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
#define BYTEORDER_ENDIAN BYTEORDER_BIG_ENDIAN
#else
#define BYTEORDER_ENDIAN BYTEORDER_LITTLE_ENDIAN
#warning "Unknown machine byteorder endianness detected. User needs to define BYTEORDER_ENDIAN."
#warning "Setting default to BYTEORDER_LITTLE_ENDIAN"
#endif
// Detect with GLIBC's endian.h.
#elif defined(__GLIBC__)
#include <endian.h>
#if (__BYTE_ORDER == __LITTLE_ENDIAN)
#define BYTEORDER_ENDIAN BYTEORDER_LITTLE_ENDIAN
#elif (__BYTE_ORDER == __BIG_ENDIAN)
#define BYTEORDER_ENDIAN BYTEORDER_BIG_ENDIAN
#else
#define BYTEORDER_ENDIAN BYTEORDER_LITTLE_ENDIAN
#warning "Unknown machine byteorder endianness detected. User needs to define BYTEORDER_ENDIAN."
#warning "Setting default to BYTEORDER_LITTLE_ENDIAN"
#endif
// Detect with _LITTLE_ENDIAN and _BIG_ENDIAN macro.
#elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
#define BYTEORDER_ENDIAN BYTEORDER_LITTLE_ENDIAN
#elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)
#define BYTEORDER_ENDIAN BYTEORDER_BIG_ENDIAN
// Detect with architecture macros.
#elif defined(__sparc) || defined(__sparc__) || defined(_POWER) || defined(__powerpc__) || defined(__ppc__) || defined(__hpux) || defined(__hppa) || defined(_MIPSEB) || defined(_POWER) || defined(__s390__)
#define BYTEORDER_ENDIAN BYTEORDER_BIG_ENDIAN
#elif defined(__i386__) || defined(__alpha__) || defined(__ia64) || defined(__ia64__) || defined(_M_IX86) || defined(_M_IA64) || defined(_M_ALPHA) || defined(__amd64) || defined(__amd64__) || defined(_M_AMD64) || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || defined(__bfin__)
#define BYTEORDER_ENDIAN BYTEORDER_LITTLE_ENDIAN
#elif defined(_MSC_VER) && (defined(_M_ARM) || defined(_M_ARM64))
#define BYTEORDER_ENDIAN BYTEORDER_LITTLE_ENDIAN
#else
#define BYTEORDER_ENDIAN BYTEORDER_LITTLE_ENDIAN
#warning "Unknown machine byteorder endianness detected. User needs to define BYTEORDER_ENDIAN."
#warning "Setting default to BYTEORDER_LITTLE_ENDIAN"
#endif
#endif

#if defined(__windows__)
/* typedefine for unsigned category for basic native types */
typedef unsigned int uint;
typedef unsigned long ulong;
typedef unsigned short ushort;
typedef unsigned char uchar;
#endif

#ifdef _MSVC_VER
#define FORCE_INLINE __forceinline
#elif defined(__linux__) || defined(__windows__)
#define FORCE_INLINE static inline __attribute__((always_inline))
#else
#define FORCE_INLINE static inline __attribute__((always_inline))
#endif

#ifndef true
#define true (1 == 1)
#endif

#ifndef TRUE
#define TRUE true
#endif

#ifndef false
#define false (1 == 0)
#endif

#ifndef FALSE
#define FALSE false
#endif

#ifndef EMPTY
#define EMPTY 2
#endif

#define _str(__PTR) ((__PTR) ? (__PTR) : "NULL")
#define _strp(__PTR) ((__PTR) ? (__PTR) : NULL)
#define _strw(__PTR) ((__PTR) ? (__PTR) : " ")
#define _nstr(__PTR) ((__PTR && __PTR->data) ? (__PTR->data) : "NULL")
#define _nstrp(__PTR) ((__PTR && __PTR->data) ? (__PTR->data) : NULL)

#define Malloc(__ptr, __struct, __size)                                                                                                                                                                  \
    {                                                                                                                                                                                                    \
        int __n_errno = 0;                                                                                                                                                                               \
        errno = 0;                                                                                                                                                                                       \
        __ptr = (__struct*)calloc(__size, sizeof(__struct));                                                                                                                                             \
        __n_errno = errno;                                                                                                                                                                               \
        if (!__ptr) {                                                                                                                                                                                    \
            n_log(LOG_ERR, "( %s *)calloc( %zu , sizeof( %s ) ) %s at line %d of %s", #__ptr, (size_t)(__size), #__struct, (__n_errno == 0) ? "malloc error" : strerror(__n_errno), __LINE__, __FILE__); \
        }                                                                                                                                                                                                \
    }

#define Alloca(__ptr, __size)                                                                                                                                              \
    {                                                                                                                                                                      \
        int __n_errno = 0;                                                                                                                                                 \
        errno = 0;                                                                                                                                                         \
        __ptr = alloca(__size);                                                                                                                                            \
        __n_errno = errno;                                                                                                                                                 \
        if (!__ptr) {                                                                                                                                                      \
            n_log(LOG_ERR, "%s=alloca( %zu ) %s at line %d of %s", #__ptr, (size_t)(__size), (__n_errno == 0) ? "alloca error" : strerror(__n_errno), __LINE__, __FILE__); \
        } else {                                                                                                                                                           \
            memset(__ptr, 0, __size);                                                                                                                                      \
        }                                                                                                                                                                  \
    }

#define Realloc(__ptr, __struct, __size)                                                                                                                                                                   \
    ({                                                                                                                                                                                                     \
        int __n_errno = 0;                                                                                                                                                                                 \
        errno = 0;                                                                                                                                                                                         \
        void* __new_ptr = ((__size) && (sizeof(__struct)) && ((__size) > SIZE_MAX / sizeof(__struct))) ? NULL : (__struct*)realloc(__ptr, (__size) * sizeof(__struct));                                    \
        __n_errno = errno;                                                                                                                                                                                 \
        if (!__new_ptr) {                                                                                                                                                                                  \
            n_log(LOG_ERR, "( %s *)realloc( %s * sizeof( %zu ) ) %s at line %d of %s", #__ptr, #__struct, (size_t)(__size), (__n_errno == 0) ? "realloc error" : strerror(__n_errno), __LINE__, __FILE__); \
        } else {                                                                                                                                                                                           \
            __ptr = __new_ptr;                                                                                                                                                                             \
        }                                                                                                                                                                                                  \
        (__new_ptr != NULL) ? TRUE : FALSE;                                                                                                                                                                \
    })

#define Reallocz(__ptr, __struct, __old_size, __size)                                                                                                                                                      \
    ({                                                                                                                                                                                                     \
        int __n_errno = 0;                                                                                                                                                                                 \
        errno = 0;                                                                                                                                                                                         \
        void* __new_ptr = ((__size) && (sizeof(__struct)) && ((__size) > SIZE_MAX / sizeof(__struct))) ? NULL : (__struct*)realloc(__ptr, __size);                                                         \
        __n_errno = errno;                                                                                                                                                                                 \
        if (!__new_ptr) {                                                                                                                                                                                  \
            n_log(LOG_ERR, "( %s *)realloc( %s * sizeof( %zu ) ) %s at line %d of %s", #__ptr, #__struct, (size_t)(__size), (__n_errno == 0) ? "realloc error" : strerror(__n_errno), __LINE__, __FILE__); \
        } else {                                                                                                                                                                                           \
            __ptr = __new_ptr;                                                                                                                                                                             \
            if (__size > __old_size) memset(((char*)__ptr + __old_size), 0, __size - __old_size);                                                                                                          \
        }                                                                                                                                                                                                  \
        (__new_ptr != NULL) ? TRUE : FALSE;                                                                                                                                                                \
    })

#define Free(__ptr)                                                                                       \
    if (__ptr) {                                                                                          \
        free(__ptr);                                                                                      \
        __ptr = NULL;                                                                                     \
    } else {                                                                                              \
        n_log(LOG_DEBUG, "Free( %s ) already done or NULL at line %d of %s", #__ptr, __LINE__, __FILE__); \
    }

#define FreeNoLog(__ptr) \
    if (__ptr) {         \
        free(__ptr);     \
        __ptr = NULL;    \
    }

#define __n_assert(__ptr, __ret)                                                             \
    if (!(__ptr)) {                                                                          \
        n_log(LOG_DEBUG, "if( !(%s) ) assert at line %d of %s", #__ptr, __LINE__, __FILE__); \
        __ret;                                                                               \
    }

#define CALL_RETRY(__retvar, __expression, __max_tries)                             \
    do {                                                                            \
        int __nb_retries = 0;                                                       \
        do {                                                                        \
            __retvar = (__expression);                                              \
            __nb_retries++;                                                         \
        } while (__retvar == -1 && errno == EINTR && __nb_retries < (__max_tries)); \
    } while (0)

#define next_odd(__val) (((__val) % 2 == 0) ? ((__val) + 1) : (__val))

#define next_even(__val) (((__val) % 2 == 0) ? (__val) : ((__val) + 1))

#define init_error_check() \
    static int ___error__check_flag = FALSE;

#define ifnull if( !

#define ifzero if( 0 ==

#define iffalse if( FALSE ==

#define iftrue if( TRUE ==

#define checkerror()                                                                    \
    if (___error__check_flag == TRUE) {                                                 \
        n_log(LOG_ERR, "checkerror return false at line %d of %s", __LINE__, __FILE__); \
        goto error;                                                                     \
    }

#define endif ){                                                              \
        ___error__check_flag = TRUE;                                          \
        n_log(LOG_ERR, "First err was at line %d of %s", __LINE__, __FILE__); \
    }

#define get_error() \
    (___error__check_flag == TRUE)

#define equal_if(__a, __cond, __b) \
    if ((__a)__cond(__b)) {        \
        __a = __b;                 \
    }

// #define RWLOCK_DEBUG 1
#ifdef RWLOCK_DEBUG
#define RWLOCK_LOGLEVEL LOG_DEBUG
#else
#define RWLOCK_LOGLEVEL LOG_NULL
#endif

#define init_lock(__rwlock_mutex)                                                                                                             \
    ({                                                                                                                                        \
        pthread_rwlockattr_t __attr;                                                                                                          \
        pthread_rwlockattr_init(&__attr);                                                                                                     \
        int __ret = 0;                                                                                                                        \
        do {                                                                                                                                  \
            n_log(RWLOCK_LOGLEVEL, "init_lock %s", #__rwlock_mutex);                                                                          \
            __rwlock_mutex = (pthread_rwlock_t)PTHREAD_RWLOCK_INITIALIZER;                                                                    \
            __ret = pthread_rwlock_init(&(__rwlock_mutex), &__attr);                                                                          \
            if (__ret != 0) {                                                                                                                 \
                n_log(LOG_ERR, "Error %s while initializing %s at %s:%s:%d", strerror(__ret), #__rwlock_mutex, __FILE__, __func__, __LINE__); \
            }                                                                                                                                 \
            pthread_rwlockattr_destroy(&__attr);                                                                                              \
        } while (0);                                                                                                                          \
        __ret;                                                                                                                                \
    })

#define read_lock(__rwlock_mutex)                                                                                                             \
    ({                                                                                                                                        \
        int __ret = 0;                                                                                                                        \
        do {                                                                                                                                  \
            n_log(RWLOCK_LOGLEVEL, "read lock %s", #__rwlock_mutex);                                                                          \
            __ret = pthread_rwlock_rdlock(&(__rwlock_mutex));                                                                                 \
            if (__ret != 0) {                                                                                                                 \
                n_log(LOG_ERR, "Error %s while read locking %s at %s:%s:%d", strerror(__ret), #__rwlock_mutex, __FILE__, __func__, __LINE__); \
            }                                                                                                                                 \
        } while (0);                                                                                                                          \
        __ret;                                                                                                                                \
    })

#define write_lock(__rwlock_mutex)                                                                                                             \
    ({                                                                                                                                         \
        int __ret = 0;                                                                                                                         \
        do {                                                                                                                                   \
            n_log(RWLOCK_LOGLEVEL, "write lock %s", #__rwlock_mutex);                                                                          \
            __ret = pthread_rwlock_wrlock(&(__rwlock_mutex));                                                                                  \
            if (__ret != 0) {                                                                                                                  \
                n_log(LOG_ERR, "Error %s while write locking %s at %s:%s:%d", strerror(__ret), #__rwlock_mutex, __FILE__, __func__, __LINE__); \
            }                                                                                                                                  \
        } while (0);                                                                                                                           \
        __ret;                                                                                                                                 \
    })

#define unlock(__rwlock_mutex)                                                                                                             \
    ({                                                                                                                                     \
        int __ret = 0;                                                                                                                     \
        do {                                                                                                                               \
            n_log(RWLOCK_LOGLEVEL, "unlock lock %s", #__rwlock_mutex);                                                                     \
            __ret = pthread_rwlock_unlock(&(__rwlock_mutex));                                                                              \
            if (__ret != 0) {                                                                                                              \
                n_log(LOG_ERR, "Error %s while unlocking %s at %s:%s:%d", strerror(__ret), #__rwlock_mutex, __FILE__, __func__, __LINE__); \
            }                                                                                                                              \
        } while (0);                                                                                                                       \
        __ret;                                                                                                                             \
    })
#define rw_lock_destroy(__rwlock_mutex)                                                                                                     \
    ({                                                                                                                                      \
        int __ret = 0;                                                                                                                      \
        do {                                                                                                                                \
            n_log(RWLOCK_LOGLEVEL, "destroy lock %s", #__rwlock_mutex);                                                                     \
            __ret = pthread_rwlock_destroy(&(__rwlock_mutex));                                                                              \
            if (__ret != 0) {                                                                                                               \
                n_log(LOG_ERR, "Error %s while destroying %s at %s:%s:%d", strerror(__ret), #__rwlock_mutex, __FILE__, __func__, __LINE__); \
            }                                                                                                                               \
        } while (0);                                                                                                                        \
        __ret;                                                                                                                              \
    })

#define SET 1234
#define GET 4321
#define DEFAULT 1000
#define RUNNING 1001
#define STOPWANTED 1002
#define STOPPED 1003
#define PAUSED 1004

#define randomize()                  \
    {                                \
        srand((unsigned)time(NULL)); \
        rand();                      \
    }

#ifndef MIN
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#endif
#ifndef MAX
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#endif

#define CONCAT_BUILDER(a, b) a##b
#define CONCAT(a, b) CONCAT_BUILDER(a, b)

/* On Windows, Winsock (winsock2.h) already declares htonll/ntohll as functions.
   Defining them as macros here makes those later function declarations fail to parse
   (the macro expands inside the prototype), so the 64-bit byte-order fallbacks are only
   defined on non-Windows platforms; Windows code uses Winsock's htonll/ntohll. */
#ifndef __windows__
#if (BYTEORDER_ENDIAN == BYTEORDER_BIG_ENDIAN)
#ifndef htonll
#define htonll(x) (x)
#endif
#ifndef ntohll
#define ntohll(x) (x)
#endif
#else
#ifndef htonll
#define htonll(x) (((uint64_t)htonl((x) & 0xFFFFFFFF) << 32) | htonl((x) >> 32))
#endif
#ifndef ntohll
#define ntohll(x) (((uint64_t)ntohl((x) & 0xFFFFFFFF) << 32) | ntohl((x) >> 32))
#endif
#endif
#endif /* __windows__ */

void n_abort(char const* format, ...) N_PRINTF_FORMAT(1, 2);

int get_computer_name(char* computer_name, size_t len);

char* get_prog_name(void);

char* get_prog_dir(void);

int file_exist(const char* filename);

int n_popen(char* cmd, size_t read_buf_size, void** nstr_output, int* ret);

int n_spawn_detached(const char* program, const char* const* args);

int n_spawn_wait(const char* program, const char* const* args, int* exit_code);

int n_spawn_wait_cancel(const char* program, const char* const* args, int* exit_code, const volatile int* cancel);

typedef struct N_SPAWN_PIPE N_SPAWN_PIPE;

N_SPAWN_PIPE* n_spawn_pipe_open(const char* program, const char* const* args, const char* log_path);

N_SPAWN_PIPE* n_spawn_pipe_open_read(const char* program, const char* const* args, const char* log_path);

size_t n_spawn_pipe_read(N_SPAWN_PIPE* pipe, void* data, size_t len);

int n_spawn_pipe_write(N_SPAWN_PIPE* pipe, const void* data, size_t len);

int n_spawn_pipe_close(N_SPAWN_PIPE** pipe, int stop, int* exit_code);

int n_open_with_default(const char* path);

void log_environment(int loglevel);

#ifndef __windows__
void sigchld_handler(int sig);
int sigchld_handler_installer(void);
#define N_DAEMON_NO_CLOSE 2
#define N_DAEMON_NO_STD_REDIRECT 4
#define N_DAEMON_NO_DOUBLE_FORK 8
#define N_DAEMON_NO_SETSID 16
#define N_DAEMON_NO_UMASK 32
#define N_DAEMON_NO_CHDIR 64
#define N_DAEMON_NO_SIGCHLD_IGN 128
#define N_DAEMON_NO_SIGCHLD_HANDLER 256
int n_daemonize(void);
int n_daemonize_ex(int mode);
pid_t system_nb(const char* command, int* infp, int* outfp);
#endif

void N_HIDE_STR(char* buf, ...);

char* n_get_file_extension(char path[]);

#ifdef __cplusplus
}
#endif

#endif  // header guard

Home

Modules