libGimbal 0.1.0
C17-Based Extended Standard Library and Cross-Language Runtime Framework
Loading...
Searching...
No Matches
Macros | Functions
gimbal_ctx.h File Reference
Core

Go to the source code of this file.

Macros

#define GBL_CTX_FRAME_DECLARE
 
#define GBL_CTX_FRAME()
 
#define GBL_CTX_CONTEXT()
 
#define GBL_CTX_OBJECT()
 
#define GBL_CTX_RECORD()
 
#define GBL_CTX_RESULT()
 
#define GBL_CTX_SOURCE()
 
#define GBL_CTX_LAST_RECORD()
 
#define GBL_CTX_LAST_RESULT()
 
#define GBL_SRC_FILE
 
#define GBL_SRC_FN
 
#define GBL_SRC_LN
 
#define GBL_SRC_LOC
 
#define GblSrcLoc
 
#define GBL_SOURCE_LOCATION(FILE, FUNCTION, LINE)
 
#define GBL_CTX_STACK_FRAME_SOURCE_PUSH(pStackFrame, current)
 
#define GBL_CTX_STACK_FRAME_SOURCE_POP(pStackFrame)
 
#define GBL_CTX_SOURCE_LOC_PUSH(srcLoc)
 
#define GBL_CTX_SOURCE_PUSH(FILE, FUNCTION, LINE)
 
#define GBL_CTX_SOURCE_POP()
 
#define GBL_CTX_SOURCE_SCOPED(CALL, loc, ...)
 
#define GBL_CTX_RECORD_SET_JMP_CND_(expr, result, label, srcLoc, ...)
 
#define GBL_CTX_RECORD_SET_JMP_CND(expr, result, label, ...)
 
#define GBL_CTX_VERIFY_(expr, result, srcLoc, ...)
 
#define GBL_CTX_VERIFY_N(srcLoc, expr, result, ...)
 
#define GBL_CTX_VERIFY_3(srcLoc, expr, result)
 
#define GBL_CTX_VERIFY(...)
 
#define GBL_CTX_VERIFY_EXPRESSION_N(srcLoc, expr, ...)
 
#define GBL_CTX_VERIFY_EXPRESSION_2(src, expr)
 
#define GBL_CTX_VERIFY_EXPRESSION(...)
 
#define GBL_CTX_VERIFY_POINTER_N(srcLoc, expr, ...)
 
#define GBL_CTX_VERIFY_POINTER_2(src, expr)
 
#define GBL_CTX_VERIFY_POINTER(...)
 
#define GBL_CTX_VERIFY_ARG_N(srcLoc, expr, ...)
 
#define GBL_CTX_VERIFY_ARG_2(src, expr)
 
#define GBL_CTX_VERIFY_ARG(...)
 
#define GBL_CTX_VERIFY_TYPE_N(srcLoc, actualType, expectedType, ...)
 
#define GBL_CTX_VERIFY_TYPE_3(srcLoc, actualType, expectedType)
 
#define GBL_CTX_VERIFY_TYPE_2(srcLoc, actualType)
 
#define GBL_CTX_VERIFY_TYPE(...)
 
#define GBL_CTX_VERIFY_LAST_RECORD()
 
#define GBL_CTX_CLEAR_LAST_RECORD()
 
#define GBL_CTX_ERRNO_CLEAR()
 
#define GBL_CTX_PERROR(...)
 
#define GBL_CTX_INLINE_RETVAL()
 
#define GBL_CTX_INLINE(MethodPrefix, ReturnType, ...)
 
#define GBL_CTX_INLINE_BEGIN(InitialRetValue)
 
#define GBL_CTX_INLINE_END()
 
#define GBL_CTX_INLINE_RETURN()
 
#define GBL_CTX_INLINE_CALL_(MethodPrefix, srcLoc, ...)
 
#define GBL_CTX_INLINE_CALL(MethodPrefix, ...)
 
#define GBL_CTX_EXT(prefix, ...)
 
#define GBL_CTX_MALLOC_4(src, size, align, dbgStr)
 
#define GBL_CTX_MALLOC_3(src, size, align)
 
#define GBL_CTX_MALLOC_2(src, size)
 
#define GBL_CTX_MALLOC(...)
 
#define GBL_CTX_NEW_4(src, type, count, dbgStr)
 
#define GBL_CTX_NEW_3(src, type, count)
 
#define GBL_CTX_NEW_2(src, type)
 
#define GBL_CTX_NEW(...)
 
#define GBL_CTX_REALLOC_4(src, pData, newSize, newAlign)
 
#define GBL_CTX_REALLOC_3(src, pData, newSize)
 
#define GBL_CTX_REALLOC(...)
 
#define GBL_CTX_RENEW_5(src, ptr, type, count, dbgStr)
 
#define GBL_CTX_RENEW_4(src, ptr, type, count)
 
#define GBL_CTX_RENEW_3(src, ptr, type)
 
#define GBL_CTX_RENEW(...)
 
#define GBL_CTX_FREE(pData)
 
#define GBL_CTX_PUSH_(srcLoc, ...)
 
#define GBL_CTX_PUSH()
 
#define GBL_CTX_PUSH_VERBOSE_N(srcLoc, pFmt, ...)
 
#define GBL_CTX_PUSH_VERBOSE(...)
 
#define GBL_CTX_POP_2(srcLoc, count)
 
#define GBL_CTX_POP_1(srcLoc)
 
#define GBL_CTX_POP(...)
 
#define GBL_CTX_LOG_(src, level, pFmt, ...)
 
#define GBL_CTX_LOG(level, pFmt, ...)
 
#define GBL_CTX_DEBUG(pFmt, ...)
 
#define GBL_CTX_VERBOSE(pFmt, ...)
 
#define GBL_CTX_INFO(pFmt, ...)
 
#define GBL_CTX_WARN(pFmt, ...)
 
#define GBL_CTX_ERROR(pFmt, ...)
 
#define GBL_CTX_EVENT(event)
 
#define GBL_CTX_RECORD_ASSERT_(record, test)
 
#define GBL_CTX_RECORD_ASSERT_CONDITIONAL_(enabled, record, test)
 
#define GBL_CTX_RECORD_ASSERT_PARTIAL(record)
 
#define GBL_CTX_RECORD_ASSERT_ERROR(record)
 
#define GBL_CTX_RECORD_ASSERT_UNKNOWN(record)
 
#define GBL_CTX_RECORD_ASSERT(record)
 
#define GBL_CTX_RECORD_LOG_(prefix, record)
 
#define GBL_CTX_RECORD_LOG_CONDITIONAL_(prefix, record)
 
#define GBL_CTX_RECORD_LOG_PARTIAL(record)
 
#define GBL_CTX_RECORD_LOG_ERROR(record)
 
#define GBL_CTX_RECORD_LOG_UNKNOWN(record)
 
#define GBL_CTX_RECORD_LOG(record)
 
#define GBL_CTX_RECORD_LAST_RECORD_(prefix, record)
 
#define GBL_CTX_RECORD_LAST_RECORD_PARTIAL(record)
 
#define GBL_CTX_RECORD_LAST_RECORD_ERROR(record)
 
#define GBL_CTX_RECORD_LAST_RECORD_UNKNOWN(record)
 
#define GBL_CTX_RECORD_LAST_RECORD(record)
 
#define GBL_CTX_RECORD_HANDLER(record)
 
#define GBL_CTX_RECORD_SET_N(file, func, line, result, ...)
 
#define GBL_CTX_RECORD_SET_5(file, func, line, result, pFmt)
 
#define GBL_CTX_RECORD_SET_4(file, func, line, result)
 
#define GBL_CTX_RECORD_SET(...)
 
#define GBL_CTX_CALL_N(src, funcCall, ...)
 
#define GBL_CTX_CALL_2(src, funcCall)
 
#define GBL_CTX_CALL(...)
 
#define GBL_CTX_VERIFY_CALL(...)
 
#define GBL_CTX_BEGIN_FRAME(file, func, line, pObject, frame)
 
#define GBL_CTX_BEGIN_LOG_4(file, func, line, hHandle)
 
#define GBL_CTX_BEGIN_LOG_N(file, func, line, hHandle, ...)
 
#define GBL_CTX_BEGIN(...)
 
#define GBL_CTX_DONE()
 
#define GBL_CTX_END_BLOCK()
 
#define GBL_CTX_END()
 
#define GBL_CTX_END_EMPTY()
 
#define GBL_CTX_BLOCK_6(file, func, line, hHandle, frame, block)
 
#define GBL_CTX_BLOCK_5(file, func, line, hHandle, block)
 
#define GBL_CTX_BLOCK_4(file, func, line, block)
 
#define GBL_CTX_BLOCK(...)
 

Functions

static GBL_RESULT GBL_ERRNO_RESULT (int ernum)
 
static void * GBL_CTX_INLINE_MALLOC_ (GblStackFrame *GBL_CTX_FRAME_NAME, size_t size, size_t align, const char *pDebugStr)
 
static void * GBL_CTX_INLINE_REALLOC_ (GblStackFrame *GBL_CTX_FRAME_NAME, void *pData, size_t newSize, size_t newAlign)
 
static GBL_RESULT GBL_CTX_INLINE_LOG_ (GblStackFrame *GBL_CTX_FRAME_NAME, GblFlags level, const char *pFmt,...)
 

Detailed Description

GblContext top-level debug and control-flow macros.

Deprecated
Internal helper macros which will soon be removed.
Author
Falco Girgis

Definition in file gimbal_ctx.h.

Macro Definition Documentation

◆ GBL_CTX_FRAME_DECLARE

#define GBL_CTX_FRAME_DECLARE

Definition at line 23 of file gimbal_ctx.h.

◆ GBL_CTX_FRAME

#define GBL_CTX_FRAME ( )

Definition at line 24 of file gimbal_ctx.h.

◆ GBL_CTX_CONTEXT

#define GBL_CTX_CONTEXT ( )

Definition at line 25 of file gimbal_ctx.h.

◆ GBL_CTX_OBJECT

#define GBL_CTX_OBJECT ( )

Definition at line 26 of file gimbal_ctx.h.

◆ GBL_CTX_RECORD

#define GBL_CTX_RECORD ( )

Definition at line 27 of file gimbal_ctx.h.

◆ GBL_CTX_RESULT

#define GBL_CTX_RESULT ( )

Definition at line 28 of file gimbal_ctx.h.

◆ GBL_CTX_SOURCE

#define GBL_CTX_SOURCE ( )

Definition at line 29 of file gimbal_ctx.h.

◆ GBL_CTX_LAST_RECORD

#define GBL_CTX_LAST_RECORD ( )

Definition at line 30 of file gimbal_ctx.h.

◆ GBL_CTX_LAST_RESULT

#define GBL_CTX_LAST_RESULT ( )

Definition at line 31 of file gimbal_ctx.h.

◆ GBL_SRC_FILE

#define GBL_SRC_FILE

Definition at line 35 of file gimbal_ctx.h.

◆ GBL_SRC_FN

#define GBL_SRC_FN

Definition at line 36 of file gimbal_ctx.h.

◆ GBL_SRC_LN

#define GBL_SRC_LN

Definition at line 37 of file gimbal_ctx.h.

◆ GBL_SRC_LOC

#define GBL_SRC_LOC

Definition at line 38 of file gimbal_ctx.h.

◆ GblSrcLoc

#define GblSrcLoc

Definition at line 39 of file gimbal_ctx.h.

◆ GBL_SOURCE_LOCATION

#define GBL_SOURCE_LOCATION ( FILE,
FUNCTION,
LINE )

Definition at line 41 of file gimbal_ctx.h.

◆ GBL_CTX_STACK_FRAME_SOURCE_PUSH

#define GBL_CTX_STACK_FRAME_SOURCE_PUSH ( pStackFrame,
current )

Definition at line 43 of file gimbal_ctx.h.

43#define GBL_CTX_STACK_FRAME_SOURCE_PUSH(pStackFrame, current) \
44 if(++pStackFrame->sourceCurrentCaptureDepth == 1) GBL_CTX_SOURCE() = current;

◆ GBL_CTX_STACK_FRAME_SOURCE_POP

#define GBL_CTX_STACK_FRAME_SOURCE_POP ( pStackFrame)

Definition at line 46 of file gimbal_ctx.h.

46#define GBL_CTX_STACK_FRAME_SOURCE_POP(pStackFrame) \
47 GBL_STMT_START { \
48 GBL_ASSERT(pStackFrame->sourceCurrentCaptureDepth); \
49 --pStackFrame->sourceCurrentCaptureDepth; \
50 } GBL_STMT_END

◆ GBL_CTX_SOURCE_LOC_PUSH

#define GBL_CTX_SOURCE_LOC_PUSH ( srcLoc)

Definition at line 52 of file gimbal_ctx.h.

52#define GBL_CTX_SOURCE_LOC_PUSH(srcLoc) \
53 GBL_CTX_STACK_FRAME_SOURCE_PUSH(GBL_CTX_FRAME_NAME, srcLoc)

◆ GBL_CTX_SOURCE_PUSH

#define GBL_CTX_SOURCE_PUSH ( FILE,
FUNCTION,
LINE )

Definition at line 55 of file gimbal_ctx.h.

55#define GBL_CTX_SOURCE_PUSH(FILE, FUNCTION, LINE) \
56 GBL_CTX_SOURCE_LOC_PUSH(GBL_SOURCE_LOCATION(FILE, FUNCTION, LINE))

◆ GBL_CTX_SOURCE_POP

#define GBL_CTX_SOURCE_POP ( )

Definition at line 58 of file gimbal_ctx.h.

58#define GBL_CTX_SOURCE_POP() \
59 GBL_CTX_STACK_FRAME_SOURCE_POP(GBL_CTX_FRAME_NAME)

◆ GBL_CTX_SOURCE_SCOPED

#define GBL_CTX_SOURCE_SCOPED ( CALL,
loc,
... )

Definition at line 61 of file gimbal_ctx.h.

61#define GBL_CTX_SOURCE_SCOPED(CALL, loc, ...) \
62 GBL_STMT_START { \
63 GBL_CTX_SOURCE_LOC_PUSH((loc)); \
64 GBL_IDENTITY(CALL)(__VA_ARGS__); \
65 GBL_CTX_SOURCE_POP(); \
66 } GBL_STMT_END

◆ GBL_CTX_RECORD_SET_JMP_CND_

#define GBL_CTX_RECORD_SET_JMP_CND_ ( expr,
result,
label,
srcLoc,
... )

Definition at line 70 of file gimbal_ctx.h.

70#define GBL_CTX_RECORD_SET_JMP_CND_(expr, result, label, srcLoc, ...) \
71 GBL_STMT_START { \
72 GBL_CTX_SOURCE_LOC_PUSH(srcLoc); \
73 if GBL_UNLIKELY(!(expr)) { \
74 GBL_CTX_RECORD_SET(result, __VA_ARGS__); \
75 GBL_CTX_SOURCE_POP(); \
76 label; \
77 } else { \
78 GBL_CTX_SOURCE_POP(); \
79 } \
80 } GBL_STMT_END

◆ GBL_CTX_RECORD_SET_JMP_CND

#define GBL_CTX_RECORD_SET_JMP_CND ( expr,
result,
label,
... )

Definition at line 82 of file gimbal_ctx.h.

82#define GBL_CTX_RECORD_SET_JMP_CND(expr, result, label, ...) \
83 GBL_CTX_RECORD_SET_JMP_CND_(expr, result, goto label, GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN), __VA_ARGS__);

◆ GBL_CTX_VERIFY_

#define GBL_CTX_VERIFY_ ( expr,
result,
srcLoc,
... )

Definition at line 87 of file gimbal_ctx.h.

87#define GBL_CTX_VERIFY_(expr, result, srcLoc, ...) \
88 GBL_CTX_RECORD_SET_JMP_CND_((expr), \
89 result, \
90 goto GBL_CTX_END_LABEL, \
91 srcLoc, __VA_ARGS__)

◆ GBL_CTX_VERIFY_N

#define GBL_CTX_VERIFY_N ( srcLoc,
expr,
result,
... )

Definition at line 93 of file gimbal_ctx.h.

93#define GBL_CTX_VERIFY_N(srcLoc, expr, result, ...) \
94 GBL_CTX_VERIFY_(expr, result, srcLoc, __VA_ARGS__)

◆ GBL_CTX_VERIFY_3

#define GBL_CTX_VERIFY_3 ( srcLoc,
expr,
result )

Definition at line 96 of file gimbal_ctx.h.

96#define GBL_CTX_VERIFY_3(srcLoc, expr, result) \
97 GBL_CTX_VERIFY_N(srcLoc, expr, result, gblResultString(result))

◆ GBL_CTX_VERIFY

#define GBL_CTX_VERIFY ( ...)

Definition at line 99 of file gimbal_ctx.h.

99#define GBL_CTX_VERIFY(...) \
100 GBL_STMT_START { \
101 const GblSrcLoc src_ = GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN); \
102 GBL_VA_OVERLOAD_SELECT(GBL_CTX_VERIFY, GBL_VA_OVERLOAD_SUFFIXER_3_N, src_, __VA_ARGS__)(src_, __VA_ARGS__); \
103 } GBL_STMT_END

◆ GBL_CTX_VERIFY_EXPRESSION_N

#define GBL_CTX_VERIFY_EXPRESSION_N ( srcLoc,
expr,
... )

Definition at line 107 of file gimbal_ctx.h.

107#define GBL_CTX_VERIFY_EXPRESSION_N(srcLoc, expr, ...) \
108 GBL_CTX_VERIFY_(expr, GBL_RESULT_ERROR_INVALID_EXPRESSION, srcLoc, __VA_ARGS__)

◆ GBL_CTX_VERIFY_EXPRESSION_2

#define GBL_CTX_VERIFY_EXPRESSION_2 ( src,
expr )

Definition at line 110 of file gimbal_ctx.h.

110#define GBL_CTX_VERIFY_EXPRESSION_2(src, expr) \
111 GBL_CTX_VERIFY_EXPRESSION_N(src, expr, "Invalid Expression: "#expr)

◆ GBL_CTX_VERIFY_EXPRESSION

#define GBL_CTX_VERIFY_EXPRESSION ( ...)

Definition at line 113 of file gimbal_ctx.h.

113#define GBL_CTX_VERIFY_EXPRESSION(...) \
114 GBL_STMT_START { \
115 const GblSrcLoc src_ = GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN); \
116 GBL_VA_OVERLOAD_SELECT(GBL_CTX_VERIFY_EXPRESSION, GBL_VA_OVERLOAD_SUFFIXER_2_N, src_, __VA_ARGS__)(src_, __VA_ARGS__); \
117 } GBL_STMT_END

◆ GBL_CTX_VERIFY_POINTER_N

#define GBL_CTX_VERIFY_POINTER_N ( srcLoc,
expr,
... )

Definition at line 120 of file gimbal_ctx.h.

120#define GBL_CTX_VERIFY_POINTER_N(srcLoc, expr, ...) \
121 GBL_CTX_VERIFY_(expr, GBL_RESULT_ERROR_INVALID_POINTER, srcLoc, __VA_ARGS__)

◆ GBL_CTX_VERIFY_POINTER_2

#define GBL_CTX_VERIFY_POINTER_2 ( src,
expr )

Definition at line 123 of file gimbal_ctx.h.

123#define GBL_CTX_VERIFY_POINTER_2(src, expr) \
124 GBL_CTX_VERIFY_POINTER_N(src, expr, "Invalid Pointer")

◆ GBL_CTX_VERIFY_POINTER

#define GBL_CTX_VERIFY_POINTER ( ...)

Definition at line 126 of file gimbal_ctx.h.

126#define GBL_CTX_VERIFY_POINTER(...) \
127 GBL_STMT_START { \
128 const GblSrcLoc src_ = GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN); \
129 GBL_VA_OVERLOAD_SELECT(GBL_CTX_VERIFY_POINTER, GBL_VA_OVERLOAD_SUFFIXER_2_N, src_, __VA_ARGS__)(src_, __VA_ARGS__); \
130 } GBL_STMT_END

◆ GBL_CTX_VERIFY_ARG_N

#define GBL_CTX_VERIFY_ARG_N ( srcLoc,
expr,
... )

Definition at line 133 of file gimbal_ctx.h.

133#define GBL_CTX_VERIFY_ARG_N(srcLoc, expr, ...) \
134 GBL_CTX_VERIFY_(expr, GBL_RESULT_ERROR_INVALID_ARG, srcLoc, __VA_ARGS__)

◆ GBL_CTX_VERIFY_ARG_2

#define GBL_CTX_VERIFY_ARG_2 ( src,
expr )

Definition at line 136 of file gimbal_ctx.h.

136#define GBL_CTX_VERIFY_ARG_2(src, expr) \
137 GBL_CTX_VERIFY_ARG_N(src, expr, "Invalid Arg: "#expr);

◆ GBL_CTX_VERIFY_ARG

#define GBL_CTX_VERIFY_ARG ( ...)

Definition at line 139 of file gimbal_ctx.h.

139#define GBL_CTX_VERIFY_ARG(...) \
140 GBL_STMT_START { \
141 const GblSrcLoc src_ = GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN); \
142 GBL_VA_OVERLOAD_SELECT(GBL_CTX_VERIFY_ARG, GBL_VA_OVERLOAD_SUFFIXER_2_N, src_, __VA_ARGS__)(src_, __VA_ARGS__); \
143 } GBL_STMT_END

◆ GBL_CTX_VERIFY_TYPE_N

#define GBL_CTX_VERIFY_TYPE_N ( srcLoc,
actualType,
expectedType,
... )

Definition at line 146 of file gimbal_ctx.h.

146#define GBL_CTX_VERIFY_TYPE_N(srcLoc, actualType, expectedType, ...) \
147 GBL_CTX_VERIFY_(GblType_check(actualType, expectedType), GBL_RESULT_ERROR_TYPE_MISMATCH, srcLoc, __VA_ARGS__)

◆ GBL_CTX_VERIFY_TYPE_3

#define GBL_CTX_VERIFY_TYPE_3 ( srcLoc,
actualType,
expectedType )

Definition at line 149 of file gimbal_ctx.h.

149#define GBL_CTX_VERIFY_TYPE_3(srcLoc, actualType, expectedType) \
150 GBL_CTX_VERIFY_TYPE_N(srcLoc, actualType, expectedType, "Type mismatch [Actual: %s, Expected: %s]", GblType_name(actualType), GblType_name(expectedType))

◆ GBL_CTX_VERIFY_TYPE_2

#define GBL_CTX_VERIFY_TYPE_2 ( srcLoc,
actualType )

Definition at line 152 of file gimbal_ctx.h.

152#define GBL_CTX_VERIFY_TYPE_2(srcLoc, actualType) \
153 GBL_CTX_VERIFY_(actualType != GBL_INVALID_TYPE, GBL_RESULT_ERROR_INVALID_TYPE, srcLoc, "Invalid Type");

◆ GBL_CTX_VERIFY_TYPE

#define GBL_CTX_VERIFY_TYPE ( ...)

Definition at line 155 of file gimbal_ctx.h.

155#define GBL_CTX_VERIFY_TYPE(...) \
156 GBL_STMT_START { \
157 const GblSrcLoc src_ = GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN); \
158 GBL_VA_OVERLOAD_SELECT(GBL_CTX_VERIFY_TYPE, GBL_VA_OVERLOAD_SUFFIXER_3_N, src_, __VA_ARGS__)(src_, __VA_ARGS__); \
159 } GBL_STMT_END

◆ GBL_CTX_VERIFY_LAST_RECORD

#define GBL_CTX_VERIFY_LAST_RECORD ( )

Definition at line 162 of file gimbal_ctx.h.

162#define GBL_CTX_VERIFY_LAST_RECORD() \
163 GBL_STMT_START { \
164 const GblCallRecord* pRecord = \
165 GblThd_callRecord(NULL); \
166 if(pRecord && GBL_RESULT_ERROR(pRecord->result)) { \
167 GBL_CTX_RESULT() = pRecord->result; \
168 GBL_CTX_DONE(); \
169 } \
170 } GBL_STMT_END

◆ GBL_CTX_CLEAR_LAST_RECORD

#define GBL_CTX_CLEAR_LAST_RECORD ( )

Definition at line 172 of file gimbal_ctx.h.

172#define GBL_CTX_CLEAR_LAST_RECORD() \
173 GblThd_setCallRecord(NULL, NULL)

◆ GBL_CTX_ERRNO_CLEAR

#define GBL_CTX_ERRNO_CLEAR ( )

Definition at line 180 of file gimbal_ctx.h.

◆ GBL_CTX_PERROR

#define GBL_CTX_PERROR ( ...)

Definition at line 196 of file gimbal_ctx.h.

◆ GBL_CTX_INLINE_RETVAL

#define GBL_CTX_INLINE_RETVAL ( )

Definition at line 207 of file gimbal_ctx.h.

◆ GBL_CTX_INLINE

#define GBL_CTX_INLINE ( MethodPrefix,
ReturnType,
... )

Definition at line 209 of file gimbal_ctx.h.

209#define GBL_CTX_INLINE(MethodPrefix, ReturnType, ...) \
210 GBL_INLINE ReturnType GBL_CTX_INLINE_##MethodPrefix##_(GBL_CTX_FRAME_DECLARE, ##__VA_ARGS__) { \
211 ReturnType GBL_CTX_INLINE_RETURN_VALUE_NAME;

◆ GBL_CTX_INLINE_BEGIN

#define GBL_CTX_INLINE_BEGIN ( InitialRetValue)

Definition at line 213 of file gimbal_ctx.h.

213#define GBL_CTX_INLINE_BEGIN(InitialRetValue) \
214 GBL_CTX_INLINE_RETVAL() = InitialRetValue;

◆ GBL_CTX_INLINE_END

#define GBL_CTX_INLINE_END ( )

Definition at line 217 of file gimbal_ctx.h.

217#define GBL_CTX_INLINE_END() \
218 goto GBL_CTX_END_LABEL; \
219 GBL_CTX_END_LABEL: GBL_STMT_START {;} GBL_STMT_END; \
220 }

◆ GBL_CTX_INLINE_RETURN

#define GBL_CTX_INLINE_RETURN ( )

Definition at line 222 of file gimbal_ctx.h.

222#define GBL_CTX_INLINE_RETURN() \
223 return GBL_CTX_INLINE_RETVAL()

◆ GBL_CTX_INLINE_CALL_

#define GBL_CTX_INLINE_CALL_ ( MethodPrefix,
srcLoc,
... )

Definition at line 226 of file gimbal_ctx.h.

226#define GBL_CTX_INLINE_CALL_(MethodPrefix, srcLoc, ...) \
227 GBL_CTX_INLINE_##MethodPrefix##_(GBL_CTX_FRAME() GBL_VA_ARGS(__VA_ARGS__))

◆ GBL_CTX_INLINE_CALL

#define GBL_CTX_INLINE_CALL ( MethodPrefix,
... )

Definition at line 229 of file gimbal_ctx.h.

229#define GBL_CTX_INLINE_CALL(MethodPrefix, ...) \
230 GBL_CTX_INLINE_CALL_(MethodPrefix, GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN) GBL_VA_ARG)

◆ GBL_CTX_EXT

#define GBL_CTX_EXT ( prefix,
... )

Definition at line 234 of file gimbal_ctx.h.

234#define GBL_CTX_EXT(prefix, ...) \
235 GBL_STMT_START { \
236 const GBL_RESULT localResult = GblContext_##prefix(GBL_CTX_CONTEXT(), \
237 GBL_CTX_FRAME_NAME, \
238 ##__VA_ARGS__); \
239 GBL_ASSERT(!(GBL_CONFIG_ASSERT_ERROR_ENABLED && \
240 GBL_RESULT_ERROR(localResult)), \
241 "Ext["#prefix"]: ERROR"); \
242 GBL_ASSERT(!(GBL_CONFIG_ASSERT_PARTIAL_ENABLED && \
243 GBL_RESULT_PARTIAL(localResult)), \
244 "Ext["#prefix"]: ERROR"); \
245 GBL_UNUSED(localResult); \
246 } GBL_STMT_END

◆ GBL_CTX_MALLOC_4

#define GBL_CTX_MALLOC_4 ( src,
size,
align,
dbgStr )

Definition at line 262 of file gimbal_ctx.h.

262#define GBL_CTX_MALLOC_4(src, size, align, dbgStr) \
263 GBL_CTX_INLINE_CALL_(MALLOC, src, size, align, dbgStr)

◆ GBL_CTX_MALLOC_3

#define GBL_CTX_MALLOC_3 ( src,
size,
align )

Definition at line 265 of file gimbal_ctx.h.

265#define GBL_CTX_MALLOC_3(src, size, align) \
266 GBL_CTX_MALLOC_4(src, size, align, GBL_NULL)

◆ GBL_CTX_MALLOC_2

#define GBL_CTX_MALLOC_2 ( src,
size )

Definition at line 268 of file gimbal_ctx.h.

268#define GBL_CTX_MALLOC_2(src, size) \
269 GBL_CTX_MALLOC_3(src, gblAlignedAllocSizeDefault(size), GBL_ALIGNOF(GBL_MAX_ALIGN_T))

◆ GBL_CTX_MALLOC

#define GBL_CTX_MALLOC ( ...)

Definition at line 271 of file gimbal_ctx.h.

271#define GBL_CTX_MALLOC(...) \
272 GBL_VA_OVERLOAD_SELECT(GBL_CTX_MALLOC, GBL_VA_OVERLOAD_SUFFIXER_ARGC, 1, __VA_ARGS__)(GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN), __VA_ARGS__)

◆ GBL_CTX_NEW_4

#define GBL_CTX_NEW_4 ( src,
type,
count,
dbgStr )

Definition at line 274 of file gimbal_ctx.h.

274#define GBL_CTX_NEW_4(src, type, count, dbgStr) \
275 (type*)GBL_CTX_INLINE_CALL_(MALLOC, src, gblAlignedAllocSizeDefault(sizeof(type)*count), 0, dbgStr)

◆ GBL_CTX_NEW_3

#define GBL_CTX_NEW_3 ( src,
type,
count )

Definition at line 277 of file gimbal_ctx.h.

277#define GBL_CTX_NEW_3(src, type, count) \
278 GBL_CTX_NEW_4(src, type, count, GBL_NULL)

◆ GBL_CTX_NEW_2

#define GBL_CTX_NEW_2 ( src,
type )

Definition at line 280 of file gimbal_ctx.h.

280#define GBL_CTX_NEW_2(src, type) \
281 GBL_CTX_NEW_3(src, type, 1)

◆ GBL_CTX_NEW

#define GBL_CTX_NEW ( ...)

Definition at line 283 of file gimbal_ctx.h.

283#define GBL_CTX_NEW(...) \
284 GBL_VA_OVERLOAD_SELECT(GBL_CTX_NEW, GBL_VA_OVERLOAD_SUFFIXER_ARGC, 1, __VA_ARGS__)(GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN), __VA_ARGS__)

◆ GBL_CTX_REALLOC_4

#define GBL_CTX_REALLOC_4 ( src,
pData,
newSize,
newAlign )

Definition at line 295 of file gimbal_ctx.h.

295#define GBL_CTX_REALLOC_4(src, pData, newSize, newAlign) \
296 GBL_CTX_INLINE_CALL_(REALLOC, src, pData, newSize, newAlign)

◆ GBL_CTX_REALLOC_3

#define GBL_CTX_REALLOC_3 ( src,
pData,
newSize )

Definition at line 298 of file gimbal_ctx.h.

298#define GBL_CTX_REALLOC_3(src, pData, newSize) \
299 GBL_CTX_REALLOC_4(src, pData, newSize, 1)

◆ GBL_CTX_REALLOC

#define GBL_CTX_REALLOC ( ...)

Definition at line 301 of file gimbal_ctx.h.

301#define GBL_CTX_REALLOC(...) \
302 GBL_VA_OVERLOAD_SELECT(GBL_CTX_REALLOC, GBL_VA_OVERLOAD_SUFFIXER_ARGC, 1, __VA_ARGS__)(GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN), __VA_ARGS__)

◆ GBL_CTX_RENEW_5

#define GBL_CTX_RENEW_5 ( src,
ptr,
type,
count,
dbgStr )

Definition at line 304 of file gimbal_ctx.h.

304#define GBL_CTX_RENEW_5(src, ptr, type, count, dbgStr) \
305 GBL_CTX_INLINE_CALL(REALLOC, src, ptr, sizeof(type)*count, dbgStr)

◆ GBL_CTX_RENEW_4

#define GBL_CTX_RENEW_4 ( src,
ptr,
type,
count )

Definition at line 307 of file gimbal_ctx.h.

307#define GBL_CTX_RENEW_4(src, ptr, type, count) \
308 GBL_CTX_RENEW_5(src, ptr, type, count, GBL_NULL)

◆ GBL_CTX_RENEW_3

#define GBL_CTX_RENEW_3 ( src,
ptr,
type )

Definition at line 310 of file gimbal_ctx.h.

310#define GBL_CTX_RENEW_3(src, ptr, type) \
311 GBL_CTX_RENEW_4(src, ptr, type, 1)

◆ GBL_CTX_RENEW

#define GBL_CTX_RENEW ( ...)

Definition at line 313 of file gimbal_ctx.h.

313#define GBL_CTX_RENEW(...) \
314 GBL_VA_OVERLOAD_SELECT(GBL_CTX_REALLOC, GBL_VA_OVERLOAD_SUFFIXER_ARGC, 1, __VA_ARGS__)(GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN), __VA_ARGS__)

◆ GBL_CTX_FREE

#define GBL_CTX_FREE ( pData)

Definition at line 316 of file gimbal_ctx.h.

316#define GBL_CTX_FREE(pData) \
317 GBL_CTX_SOURCE_SCOPED(GBL_CTX_EXT, (GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN)), memFree_, pData)

◆ GBL_CTX_PUSH_

#define GBL_CTX_PUSH_ ( srcLoc,
... )

Definition at line 319 of file gimbal_ctx.h.

319#define GBL_CTX_PUSH_(srcLoc, ...) \
320 GBL_STMT_START { \
321 GBL_CTX_SOURCE_LOC_PUSH(srcLoc); \
322 GblThd_logPush(NULL); \
323 GBL_CTX_EXT(logPush_); \
324 GBL_CTX_SOURCE_POP(); \
325 ++GBL_CTX_FRAME()->stackDepth; \
326 } GBL_STMT_END

◆ GBL_CTX_PUSH

#define GBL_CTX_PUSH ( )

Definition at line 328 of file gimbal_ctx.h.

328#define GBL_CTX_PUSH() \
329 GBL_STMT_START { \
330 const GblSrcLoc src_ = GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN); \
331 GBL_CTX_PUSH_(src_); \
332 } GBL_STMT_END

◆ GBL_CTX_PUSH_VERBOSE_N

#define GBL_CTX_PUSH_VERBOSE_N ( srcLoc,
pFmt,
... )

Definition at line 334 of file gimbal_ctx.h.

334#define GBL_CTX_PUSH_VERBOSE_N(srcLoc, pFmt, ...) \
335 GBL_STMT_START { \
336 GBL_CTX_SOURCE_SCOPED(GBL_CTX_VERBOSE, srcLoc, pFmt, ##__VA_ARGS__); \
337 GBL_CTX_PUSH_(srcLoc); \
338 } GBL_STMT_END

◆ GBL_CTX_PUSH_VERBOSE

#define GBL_CTX_PUSH_VERBOSE ( ...)

Definition at line 340 of file gimbal_ctx.h.

340#define GBL_CTX_PUSH_VERBOSE(...) \
341 GBL_STMT_START { \
342 const GblSrcLoc src_ = GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN); \
343 GBL_VA_OVERLOAD_SELECT(GBL_CTX_PUSH_VERBOSE, GBL_VA_OVERLOAD_SUFFIXER_1_N, src_, ##__VA_ARGS__)(src_, ##__VA_ARGS__); \
344 } GBL_STMT_END

◆ GBL_CTX_POP_2

#define GBL_CTX_POP_2 ( srcLoc,
count )

Definition at line 346 of file gimbal_ctx.h.

346#define GBL_CTX_POP_2(srcLoc, count) \
347 GblThd_logPop(NULL, count); \
348 GBL_CTX_SOURCE_SCOPED(GBL_CTX_EXT, srcLoc, logPop_, count); \
349 GBL_CTX_FRAME()->stackDepth -= count;

◆ GBL_CTX_POP_1

#define GBL_CTX_POP_1 ( srcLoc)

Definition at line 351 of file gimbal_ctx.h.

351#define GBL_CTX_POP_1(srcLoc) \
352 GBL_CTX_POP_2(srcLoc, 1)

◆ GBL_CTX_POP

#define GBL_CTX_POP ( ...)

Definition at line 354 of file gimbal_ctx.h.

354#define GBL_CTX_POP(...) \
355 GBL_STMT_START { \
356 const GblSrcLoc loc = GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN); \
357 GBL_VA_OVERLOAD_CALL(GBL_CTX_POP, GBL_VA_OVERLOAD_SUFFIXER_ARGC, loc, __VA_ARGS__); \
358 } GBL_STMT_END

◆ GBL_CTX_LOG_

#define GBL_CTX_LOG_ ( src,
level,
pFmt,
... )

Definition at line 371 of file gimbal_ctx.h.

371#define GBL_CTX_LOG_(src, level, pFmt, ...) \
372 GBL_CTX_INLINE_CALL_(LOG, src, level, pFmt, ##__VA_ARGS__)

◆ GBL_CTX_LOG

#define GBL_CTX_LOG ( level,
pFmt,
... )

Definition at line 373 of file gimbal_ctx.h.

373#define GBL_CTX_LOG(level, pFmt, ...) \
374 GBL_CTX_LOG_(GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN), level, pFmt, ##__VA_ARGS__)

◆ GBL_CTX_DEBUG

#define GBL_CTX_DEBUG ( pFmt,
... )

Definition at line 376 of file gimbal_ctx.h.

376#define GBL_CTX_DEBUG(pFmt, ...) \
377 GBL_CTX_LOG_(GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN), GBL_LOG_LEVEL_DEBUG, pFmt, ##__VA_ARGS__)

◆ GBL_CTX_VERBOSE

#define GBL_CTX_VERBOSE ( pFmt,
... )

Definition at line 379 of file gimbal_ctx.h.

379#define GBL_CTX_VERBOSE(pFmt, ...) \
380 GBL_CTX_LOG_(GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN), GBL_LOG_LEVEL_VERBOSE, pFmt, ##__VA_ARGS__)

◆ GBL_CTX_INFO

#define GBL_CTX_INFO ( pFmt,
... )

Definition at line 382 of file gimbal_ctx.h.

382#define GBL_CTX_INFO(pFmt, ...) \
383 GBL_CTX_LOG_(GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN), GBL_LOG_LEVEL_INFO, pFmt, ##__VA_ARGS__)

◆ GBL_CTX_WARN

#define GBL_CTX_WARN ( pFmt,
... )

Definition at line 385 of file gimbal_ctx.h.

385#define GBL_CTX_WARN(pFmt, ...) \
386 GBL_CTX_LOG_(GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN), GBL_LOG_LEVEL_WARNING, pFmt, ##__VA_ARGS__)

◆ GBL_CTX_ERROR

#define GBL_CTX_ERROR ( pFmt,
... )

Definition at line 388 of file gimbal_ctx.h.

388#define GBL_CTX_ERROR(pFmt, ...) \
389 GBL_CTX_LOG_(GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN), GBL_LOG_LEVEL_ERROR, pFmt, ##__VA_ARGS__)

◆ GBL_CTX_EVENT

#define GBL_CTX_EVENT ( event)

Definition at line 391 of file gimbal_ctx.h.

391#define GBL_CTX_EVENT(event) \
392 GBL_STMT_START { \
393 const GblSrcLoc src_ = GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN); \
394 GBL_UNUSED(src_); \
395 GblObject_sendEvent(GBL_CTX_OBJECT(), (GblEvent*)event); \
396 } GBL_STMT_END

◆ GBL_CTX_RECORD_ASSERT_

#define GBL_CTX_RECORD_ASSERT_ ( record,
test )

Definition at line 402 of file gimbal_ctx.h.

402#define GBL_CTX_RECORD_ASSERT_(record, test) \
403 GBL_STMT_START { \
404 GBL_ASSERT(!test(record->result), record->message); \
405 } GBL_STMT_END

◆ GBL_CTX_RECORD_ASSERT_CONDITIONAL_

#define GBL_CTX_RECORD_ASSERT_CONDITIONAL_ ( enabled,
record,
test )

Definition at line 408 of file gimbal_ctx.h.

408#define GBL_CTX_RECORD_ASSERT_CONDITIONAL_(enabled, record, test) \
409 GBL_MACRO_CONDITIONAL_CALL(enabled, GBL_CTX_RECORD_ASSERT_, record, test)

◆ GBL_CTX_RECORD_ASSERT_PARTIAL

#define GBL_CTX_RECORD_ASSERT_PARTIAL ( record)

Definition at line 412 of file gimbal_ctx.h.

412#define GBL_CTX_RECORD_ASSERT_PARTIAL(record) \
413 GBL_CTX_RECORD_ASSERT_CONDITIONAL_(GBL_CONFIG_ASSERT_PARTIAL_ENABLED, \
414 record, GBL_RESULT_PARTIAL)

◆ GBL_CTX_RECORD_ASSERT_ERROR

#define GBL_CTX_RECORD_ASSERT_ERROR ( record)

Definition at line 416 of file gimbal_ctx.h.

416#define GBL_CTX_RECORD_ASSERT_ERROR(record) \
417 GBL_CTX_RECORD_ASSERT_CONDITIONAL_(GBL_CONFIG_ASSERT_ERROR_ENABLED, \
418 record, GBL_RESULT_ERROR)

◆ GBL_CTX_RECORD_ASSERT_UNKNOWN

#define GBL_CTX_RECORD_ASSERT_UNKNOWN ( record)

Definition at line 421 of file gimbal_ctx.h.

421#define GBL_CTX_RECORD_ASSERT_UNKNOWN(record) \
422 GBL_CTX_RECORD_ASSERT_CONDITIONAL_(GBL_CONFIG_ASSERT_UNKNOWN_ENABLED, \
423 record, GBL_RESULT_UNKNOWN)

◆ GBL_CTX_RECORD_ASSERT

#define GBL_CTX_RECORD_ASSERT ( record)

Definition at line 425 of file gimbal_ctx.h.

425#define GBL_CTX_RECORD_ASSERT(record) \
426 GBL_STMT_START { \
427 GBL_CTX_RECORD_ASSERT_ERROR(record); \
428 GBL_CTX_RECORD_ASSERT_PARTIAL(record); \
429 GBL_CTX_RECORD_ASSERT_UNKNOWN(record); \
430 } GBL_STMT_END

◆ GBL_CTX_RECORD_LOG_

#define GBL_CTX_RECORD_LOG_ ( prefix,
record )

Definition at line 436 of file gimbal_ctx.h.

436#define GBL_CTX_RECORD_LOG_(prefix, record) \
437 GBL_STMT_START { \
438 if GBL_UNLIKELY(GBL_RESULT_##prefix(record->result)) { \
439 GBL_CTX_LOG(GBL_CONFIG_LOG_##prefix##_LEVEL, \
440 "%s: %s", \
441 gblResultString(record->result), record->message); \
442 } \
443 } GBL_STMT_END

◆ GBL_CTX_RECORD_LOG_CONDITIONAL_

#define GBL_CTX_RECORD_LOG_CONDITIONAL_ ( prefix,
record )

Definition at line 447 of file gimbal_ctx.h.

447#define GBL_CTX_RECORD_LOG_CONDITIONAL_(prefix, record) \
448 GBL_MACRO_CONDITIONAL_CALL(GBL_CONFIG_LOG_##prefix##_ENABLED, \
449 GBL_CTX_RECORD_LOG_, prefix, record)

◆ GBL_CTX_RECORD_LOG_PARTIAL

#define GBL_CTX_RECORD_LOG_PARTIAL ( record)

Definition at line 452 of file gimbal_ctx.h.

452#define GBL_CTX_RECORD_LOG_PARTIAL(record) \
453 GBL_CTX_RECORD_LOG_CONDITIONAL_(PARTIAL, record)

◆ GBL_CTX_RECORD_LOG_ERROR

#define GBL_CTX_RECORD_LOG_ERROR ( record)

Definition at line 456 of file gimbal_ctx.h.

456#define GBL_CTX_RECORD_LOG_ERROR(record) \
457 GBL_CTX_RECORD_LOG_CONDITIONAL_(ERROR, record)

◆ GBL_CTX_RECORD_LOG_UNKNOWN

#define GBL_CTX_RECORD_LOG_UNKNOWN ( record)

Definition at line 460 of file gimbal_ctx.h.

460#define GBL_CTX_RECORD_LOG_UNKNOWN(record) \
461 GBL_CTX_RECORD_LOG_CONDITIONAL_(UNKNOWN, record)

◆ GBL_CTX_RECORD_LOG

#define GBL_CTX_RECORD_LOG ( record)

Definition at line 464 of file gimbal_ctx.h.

464#define GBL_CTX_RECORD_LOG(record) \
465 GBL_STMT_START { \
466 GBL_CTX_RECORD_LOG_ERROR(record); \
467 GBL_CTX_RECORD_LOG_PARTIAL(record); \
468 GBL_CTX_RECORD_LOG_UNKNOWN(record); \
469 } GBL_STMT_END

◆ GBL_CTX_RECORD_LAST_RECORD_

#define GBL_CTX_RECORD_LAST_RECORD_ ( prefix,
record )

Definition at line 473 of file gimbal_ctx.h.

473#define GBL_CTX_RECORD_LAST_RECORD_(prefix, record) \
474 GBL_STMT_START { \
475 if(GBL_RESULT_##prefix(record->result)) { \
476 GblContext_callRecordSet_(GBL_CTX_CONTEXT(), GBL_CTX_FRAME_NAME, record); \
477 GblThd_setCallRecord(NULL, record); \
478 } \
479 } GBL_STMT_END

◆ GBL_CTX_RECORD_LAST_RECORD_PARTIAL

#define GBL_CTX_RECORD_LAST_RECORD_PARTIAL ( record)

Definition at line 481 of file gimbal_ctx.h.

481#define GBL_CTX_RECORD_LAST_RECORD_PARTIAL(record) \
482 GBL_CTX_RECORD_LAST_RECORD_(PARTIAL, record)

◆ GBL_CTX_RECORD_LAST_RECORD_ERROR

#define GBL_CTX_RECORD_LAST_RECORD_ERROR ( record)

Definition at line 484 of file gimbal_ctx.h.

484#define GBL_CTX_RECORD_LAST_RECORD_ERROR(record) \
485 GBL_CTX_RECORD_LAST_RECORD_(ERROR, record)

◆ GBL_CTX_RECORD_LAST_RECORD_UNKNOWN

#define GBL_CTX_RECORD_LAST_RECORD_UNKNOWN ( record)

Definition at line 487 of file gimbal_ctx.h.

487#define GBL_CTX_RECORD_LAST_RECORD_UNKNOWN(record) \
488 GBL_CTX_RECORD_LAST_RECORD_(UNKNOWN, record)

◆ GBL_CTX_RECORD_LAST_RECORD

#define GBL_CTX_RECORD_LAST_RECORD ( record)

Definition at line 490 of file gimbal_ctx.h.

490#define GBL_CTX_RECORD_LAST_RECORD(record) \
491 GBL_STMT_START { \
492 GBL_CTX_RECORD_LAST_RECORD_ERROR(record); \
493 GBL_CTX_RECORD_LAST_RECORD_PARTIAL(record); \
494 GBL_CTX_RECORD_LAST_RECORD_UNKNOWN(record); \
495 } GBL_STMT_END

◆ GBL_CTX_RECORD_HANDLER

#define GBL_CTX_RECORD_HANDLER ( record)

Definition at line 498 of file gimbal_ctx.h.

498#define GBL_CTX_RECORD_HANDLER(record) \
499 GBL_STMT_START { \
500 GBL_CTX_RECORD_LOG((record)); \
501 GBL_CTX_RECORD_LAST_RECORD((record)); \
502 GBL_CTX_RECORD_ASSERT((record)); \
503 } GBL_STMT_END

◆ GBL_CTX_RECORD_SET_N

#define GBL_CTX_RECORD_SET_N ( file,
func,
line,
result,
... )

Definition at line 505 of file gimbal_ctx.h.

505#define GBL_CTX_RECORD_SET_N(file, func, line, result, ...) \
506 GBL_STMT_START { \
507 GBL_CTX_SOURCE_LOC_PUSH(GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN)); \
508 GblCallRecord_construct(&GBL_CTX_RECORD(), result, GBL_CTX_SOURCE(), __VA_ARGS__); \
509 GBL_CTX_RECORD_HANDLER(&GBL_CTX_RECORD()); \
510 GBL_CTX_SOURCE_POP(); \
511 } GBL_STMT_END

◆ GBL_CTX_RECORD_SET_5

#define GBL_CTX_RECORD_SET_5 ( file,
func,
line,
result,
pFmt )

Definition at line 513 of file gimbal_ctx.h.

513#define GBL_CTX_RECORD_SET_5(file, func, line, result, pFmt) \
514 GBL_CTX_RECORD_SET_N(file, func, line, result, "%s", pFmt)

◆ GBL_CTX_RECORD_SET_4

#define GBL_CTX_RECORD_SET_4 ( file,
func,
line,
result )

Definition at line 516 of file gimbal_ctx.h.

516#define GBL_CTX_RECORD_SET_4(file, func, line, result) \
517 GBL_CTX_RECORD_SET_5(file, func, line, result, gblResultString(result))

◆ GBL_CTX_RECORD_SET

#define GBL_CTX_RECORD_SET ( ...)

Definition at line 519 of file gimbal_ctx.h.

519#define GBL_CTX_RECORD_SET(...) \
520 GBL_VA_OVERLOAD_CALL(GBL_CTX_RECORD_SET, GBL_VA_OVERLOAD_SUFFIXER_5_N, GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN, __VA_ARGS__)

◆ GBL_CTX_CALL_N

#define GBL_CTX_CALL_N ( src,
funcCall,
... )

Definition at line 522 of file gimbal_ctx.h.

522#define GBL_CTX_CALL_N(src, funcCall, ...) \
523 GBL_STMT_START { \
524 GBL_CTX_SOURCE_LOC_PUSH(src); \
525 GBL_MAYBE_UNUSED const GBL_RESULT localResult = (funcCall); \
526 if GBL_UNLIKELY(!GBL_RESULT_SUCCESS(localResult)) { \
527 GBL_CTX_RESULT() = localResult; \
528 } \
529 GBL_CTX_SOURCE_POP(); \
530 } GBL_STMT_END

◆ GBL_CTX_CALL_2

#define GBL_CTX_CALL_2 ( src,
funcCall )

Definition at line 532 of file gimbal_ctx.h.

532#define GBL_CTX_CALL_2(src, funcCall) \
533 GBL_CTX_CALL_N(src, funcCall, #funcCall);

◆ GBL_CTX_CALL

#define GBL_CTX_CALL ( ...)

Definition at line 535 of file gimbal_ctx.h.

535#define GBL_CTX_CALL(...) \
536 GBL_STMT_START { \
537 const GblSrcLoc src_ = GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN); \
538 GBL_VA_OVERLOAD_SELECT(GBL_CTX_CALL, GBL_VA_OVERLOAD_SUFFIXER_2_N, src_, __VA_ARGS__)(src_, __VA_ARGS__); \
539 } GBL_STMT_END

◆ GBL_CTX_VERIFY_CALL

#define GBL_CTX_VERIFY_CALL ( ...)

Definition at line 541 of file gimbal_ctx.h.

541#define GBL_CTX_VERIFY_CALL(...) \
542 GBL_STMT_START { \
543 const GblSrcLoc src_ = GBL_SRC_LOC(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN); \
544 GBL_VA_OVERLOAD_SELECT(GBL_CTX_CALL, GBL_VA_OVERLOAD_SUFFIXER_2_N, src_, __VA_ARGS__)(src_, __VA_ARGS__); \
545 if(!GBL_RESULT_SUCCESS(GBL_CTX_RESULT())) goto GBL_CTX_END_LABEL; \
546 } GBL_STMT_END

◆ GBL_CTX_BEGIN_FRAME

#define GBL_CTX_BEGIN_FRAME ( file,
func,
line,
pObject,
frame )

Definition at line 551 of file gimbal_ctx.h.

551#define GBL_CTX_BEGIN_FRAME(file, func, line, pObject, frame) \
552 GBL_CTX_FRAME_DECLARE = frame; \
553 GblStackFrame_construct(GBL_CTX_FRAME_NAME, (GblObject*)pObject, GBL_RESULT_SUCCESS); \
554 GblThd_stackFramePush(NULL, GBL_CTX_FRAME_NAME)

◆ GBL_CTX_BEGIN_LOG_4

#define GBL_CTX_BEGIN_LOG_4 ( file,
func,
line,
hHandle )

Definition at line 556 of file gimbal_ctx.h.

556#define GBL_CTX_BEGIN_LOG_4(file, func, line, hHandle) \
557 GBL_CTX_BEGIN_FRAME(file, func, line, hHandle, ((GblStackFrame*)GBL_ALLOCA(sizeof(GblStackFrame))))

◆ GBL_CTX_BEGIN_LOG_N

#define GBL_CTX_BEGIN_LOG_N ( file,
func,
line,
hHandle,
... )

Definition at line 559 of file gimbal_ctx.h.

559#define GBL_CTX_BEGIN_LOG_N(file, func, line, hHandle, ...) \
560 GBL_CTX_BEGIN_LOG_5(file, func, line, hHandle); \
561 GBL_CTX_PUSH_VERBOSE(__VA_ARGS__);

◆ GBL_CTX_BEGIN

#define GBL_CTX_BEGIN ( ...)

Definition at line 563 of file gimbal_ctx.h.

563#define GBL_CTX_BEGIN(...) \
564 GBL_VA_OVERLOAD_CALL(GBL_CTX_BEGIN_LOG, GBL_VA_OVERLOAD_SUFFIXER_4_N, GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN, __VA_ARGS__)

◆ GBL_CTX_DONE

#define GBL_CTX_DONE ( )

Definition at line 566 of file gimbal_ctx.h.

566#define GBL_CTX_DONE() \
567 goto GBL_CTX_END_LABEL

◆ GBL_CTX_END_BLOCK

#define GBL_CTX_END_BLOCK ( )

Definition at line 569 of file gimbal_ctx.h.

569#define GBL_CTX_END_BLOCK() \
570 goto GBL_CTX_END_LABEL; \
571 GBL_LABEL_EMPTY(GBL_CTX_END_LABEL); \
572 if(GBL_CTX_FRAME_NAME->stackDepth) \
573 GBL_CTX_POP(GBL_CTX_FRAME_NAME->stackDepth); \
574 GblThd_stackFramePop(NULL)

◆ GBL_CTX_END

#define GBL_CTX_END ( )

Definition at line 576 of file gimbal_ctx.h.

576#define GBL_CTX_END() \
577 GBL_CTX_END_BLOCK(); \
578 return GBL_CTX_FRAME_NAME->record.result

◆ GBL_CTX_END_EMPTY

#define GBL_CTX_END_EMPTY ( )

Definition at line 580 of file gimbal_ctx.h.

580#define GBL_CTX_END_EMPTY() \
581 GBL_LABEL_EMPTY(GBL_CTX_END_LABEL)

◆ GBL_CTX_BLOCK_6

#define GBL_CTX_BLOCK_6 ( file,
func,
line,
hHandle,
frame,
block )

Definition at line 583 of file gimbal_ctx.h.

583#define GBL_CTX_BLOCK_6(file, func, line, hHandle, frame, block) \
584 GBL_CTX_BEGIN_FRAME(file, func, line, hHandle, frame); \
585 block; \
586 GBL_CTX_END_BLOCK()

◆ GBL_CTX_BLOCK_5

#define GBL_CTX_BLOCK_5 ( file,
func,
line,
hHandle,
block )

Definition at line 588 of file gimbal_ctx.h.

588#define GBL_CTX_BLOCK_5(file, func, line, hHandle, block) \
589 GBL_CTX_BLOCK_7(file, func, line, hHandle, ((GblStackFrame*)GBL_ALLOCA(sizeof(GblStackFrame))), block)

◆ GBL_CTX_BLOCK_4

#define GBL_CTX_BLOCK_4 ( file,
func,
line,
block )

Definition at line 591 of file gimbal_ctx.h.

591#define GBL_CTX_BLOCK_4(file, func, line, block) \
592 GBL_CTX_BLOCK_6(file, func, line, NULL, block)

◆ GBL_CTX_BLOCK

#define GBL_CTX_BLOCK ( ...)

Definition at line 594 of file gimbal_ctx.h.

594#define GBL_CTX_BLOCK(...) \
595 GBL_VA_OVERLOAD_SELECT(GBL_CTX_BLOCK, GBL_VA_OVERLOAD_SUFFIXER_ARGC, GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN, __VA_ARGS__)(GBL_SRC_FILE, GBL_SRC_FN, GBL_SRC_LN, __VA_ARGS__)

Function Documentation

◆ GBL_ERRNO_RESULT()

static GBL_RESULT GBL_ERRNO_RESULT ( int ernum)
inlinestatic

Definition at line 199 of file gimbal_ctx.h.

199 {
200 switch(ernum) {
201 case 0: return GBL_RESULT_SUCCESS;
202 default: return GBL_RESULT_ERROR;
203 }
204}

◆ GBL_CTX_INLINE_MALLOC_()

static void * GBL_CTX_INLINE_MALLOC_ ( GblStackFrame * GBL_CTX_FRAME_NAME,
size_t size,
size_t align,
const char * pDebugStr )
inlinestatic

Definition at line 249 of file gimbal_ctx.h.

249 {
250 GBL_CTX_INLINE_BEGIN(GBL_NULL);
251 if(align == 0) {
252 align = GBL_ALIGNOF(GBL_MAX_ALIGN_T);
253 size = gblAlignedAllocSizeDefault(size);
254 }
255 GBL_ASSERT(size % align == 0);
256 GBL_CTX_EXT(memAlloc_, size, align, pDebugStr, &GBL_CTX_INLINE_RETVAL());
257 GBL_CTX_INLINE_END();
258 // modify/set return value based on result
259 GBL_CTX_INLINE_RETURN();
260}

◆ GBL_CTX_INLINE_REALLOC_()

static void * GBL_CTX_INLINE_REALLOC_ ( GblStackFrame * GBL_CTX_FRAME_NAME,
void * pData,
size_t newSize,
size_t newAlign )
inlinestatic

Definition at line 286 of file gimbal_ctx.h.

286 {
287 GBL_CTX_INLINE_BEGIN(NULL);
288
289 GBL_CTX_EXT(memRealloc_, pData, newSize, newAlign, &GBL_CTX_INLINE_RETVAL());
290 GBL_CTX_INLINE_END();
291 // modify/set return value based on result
292 GBL_CTX_INLINE_RETURN();
293}

◆ GBL_CTX_INLINE_LOG_()

static GBL_RESULT GBL_CTX_INLINE_LOG_ ( GblStackFrame * GBL_CTX_FRAME_NAME,
GblFlags level,
const char * pFmt,
... )
inlinestatic

Definition at line 360 of file gimbal_ctx.h.

360 {
361 GBL_CTX_INLINE_BEGIN(GBL_RESULT_SUCCESS);
362 va_list varArgs;
363 va_start(varArgs, pFmt);
364
365 GBL_CTX_EXT(logWrite_, level, pFmt, varArgs);
366 va_end(varArgs);
367 GBL_CTX_INLINE_END();
368 GBL_CTX_INLINE_RETURN();
369}