1 /* 2 * Copyright (c) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef HKS_TEMPLATE_H 17 #define HKS_TEMPLATE_H 18 19 #include <errno.h> 20 #include <string.h> 21 22 #include "hks_log.h" 23 24 #undef HKS_NULL_POINTER 25 26 #ifdef __cplusplus 27 #define HKS_NULL_POINTER nullptr 28 #else 29 #define HKS_NULL_POINTER NULL 30 #endif 31 32 #define HKS_IF_NOT_SUCC_LOGE_RETURN(RESULT, ERROR_CODE, LOG_MESSAGE, ...) \ 33 if ((RESULT) != HKS_SUCCESS) { \ 34 HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ 35 return (ERROR_CODE); \ 36 } 37 38 #define HKS_IF_NOT_SUCC_LOGI_RETURN(RESULT, ERROR_CODE, LOG_MESSAGE, ...) \ 39 if ((RESULT) != HKS_SUCCESS) { \ 40 HKS_LOG_I(LOG_MESSAGE, ##__VA_ARGS__); \ 41 return (ERROR_CODE); \ 42 } 43 44 #define HKS_IF_NOT_SUCC_LOGE_BREAK(RESULT, LOG_MESSAGE, ...) \ 45 if ((RESULT) != HKS_SUCCESS) { \ 46 HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ 47 break; \ 48 } 49 50 #define HKS_IF_NOT_SUCC_LOGI_RETURN(RESULT, ERROR_CODE, LOG_MESSAGE, ...) \ 51 if ((RESULT) != HKS_SUCCESS) { \ 52 HKS_LOG_I(LOG_MESSAGE, ##__VA_ARGS__); \ 53 return (ERROR_CODE); \ 54 } 55 56 #define HKS_IF_NOT_SUCC_LOGI_BREAK(RESULT, LOG_MESSAGE, ...) \ 57 if ((RESULT) != HKS_SUCCESS) { \ 58 HKS_LOG_I(LOG_MESSAGE, ##__VA_ARGS__); \ 59 break; \ 60 } 61 62 #define HKS_IF_NOT_SUCC_BREAK(RESULT, ...) \ 63 if ((RESULT) != HKS_SUCCESS) { \ 64 break; \ 65 } 66 67 #define HKS_IF_NOT_SUCC_LOGE(RESULT, LOG_MESSAGE, ...) \ 68 if ((RESULT) != HKS_SUCCESS) { \ 69 HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ 70 } 71 72 #define HKS_IF_NOT_SUCC_LOGI(RESULT, LOG_MESSAGE, ...) \ 73 if ((RESULT) != HKS_SUCCESS) { \ 74 HKS_LOG_I(LOG_MESSAGE, ##__VA_ARGS__); \ 75 } 76 77 #define HKS_IF_NOT_SUCC_RETURN(RESULT, ERROR_CODE) \ 78 if ((RESULT) != HKS_SUCCESS) { \ 79 return (ERROR_CODE); \ 80 } 81 82 #define HKS_IF_NOT_SUCC_RETURN_VOID(RESULT) \ 83 if ((RESULT) != HKS_SUCCESS) { \ 84 return; \ 85 } 86 87 #define HKS_IF_NOT_SUCC_LOGE_RETURN_VOID(RESULT, LOG_MESSAGE, ...) \ 88 if ((RESULT) != HKS_SUCCESS) { \ 89 HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ 90 return; \ 91 } 92 93 #define HKS_IF_NULL_LOGE_RETURN(OBJECT, ERROR_CODE, LOG_MESSAGE, ...) \ 94 if ((OBJECT) == HKS_NULL_POINTER) { \ 95 HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ 96 return (ERROR_CODE); \ 97 } 98 99 #define HKS_IF_NULL_LOGI_RETURN(OBJECT, ERROR_CODE, LOG_MESSAGE, ...) \ 100 if ((OBJECT) == HKS_NULL_POINTER) { \ 101 HKS_LOG_I(LOG_MESSAGE, ##__VA_ARGS__); \ 102 return (ERROR_CODE); \ 103 } 104 105 #define HKS_IF_NULL_LOGE_RETURN_VOID(OBJECT, LOG_MESSAGE, ...) \ 106 if ((OBJECT) == HKS_NULL_POINTER) { \ 107 HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ 108 return; \ 109 } 110 111 #define HKS_IF_NULL_LOGE_BREAK(OBJECT, LOG_MESSAGE, ...) \ 112 if ((OBJECT) == HKS_NULL_POINTER) { \ 113 HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ 114 break; \ 115 } 116 117 #define HKS_IF_NULL_RETURN(OBJECT, ERROR_CODE) \ 118 if ((OBJECT) == HKS_NULL_POINTER) { \ 119 return (ERROR_CODE); \ 120 } 121 122 #define HKS_IF_NULL_RETURN_VOID(OBJECT) \ 123 if ((OBJECT) == HKS_NULL_POINTER) { \ 124 return; \ 125 } 126 127 #define HKS_IF_NULL_BREAK(OBJECT) \ 128 if ((OBJECT) == HKS_NULL_POINTER) { \ 129 break; \ 130 } 131 132 #define HKS_IF_TRUE_RETURN(BOOL_FUNC, ERROR_CODE) \ 133 if (BOOL_FUNC) { \ 134 return (ERROR_CODE); \ 135 } 136 137 #define HKS_IF_TRUE_CONTINUE(BOOL_FUNC) \ 138 if (BOOL_FUNC) { \ 139 continue; \ 140 } 141 142 #define HKS_IF_TRUE_RETURN_VOID(BOOL_FUNC) \ 143 if ((BOOL_FUNC)) { \ 144 return; \ 145 } 146 147 #define HKS_IF_TRUE_LOGE_RETURN(BOOL_FUNC, ERROR_CODE, LOG_MESSAGE, ...) \ 148 if (BOOL_FUNC) { \ 149 HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ 150 return (ERROR_CODE); \ 151 } 152 153 #define HKS_IF_TRUE_LOGE_CONTINUE(BOOL_FUNC, LOG_MESSAGE, ...) \ 154 if ((BOOL_FUNC)) { \ 155 HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ 156 continue; \ 157 } 158 159 #define HKS_IF_TRUE_LOGE_RETURN_VOID(BOOL_FUNC, LOG_MESSAGE, ...) \ 160 if ((BOOL_FUNC)) { \ 161 HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ 162 return; \ 163 } 164 165 #define HKS_IF_TRUE_LOGI_RETURN_VOID(BOOL_FUNC, LOG_MESSAGE, ...) \ 166 if ((BOOL_FUNC)) { \ 167 HKS_LOG_I(LOG_MESSAGE, ##__VA_ARGS__); \ 168 return; \ 169 } 170 171 #define HKS_IF_TRUE_LOGI_RETURN(BOOL_FUNC, ERROR_CODE, LOG_MESSAGE, ...) \ 172 if (BOOL_FUNC) { \ 173 HKS_LOG_I(LOG_MESSAGE, ##__VA_ARGS__); \ 174 return (ERROR_CODE); \ 175 } 176 177 #define HKS_IF_TRUE_LOGI_BREAK(BOOL_FUNC, LOG_MESSAGE, ...) \ 178 if ((BOOL_FUNC)) { \ 179 HKS_LOG_I(LOG_MESSAGE, ##__VA_ARGS__); \ 180 break; \ 181 } 182 183 #define HKS_IF_TRUE_LOGE(BOOL_FUNC, LOG_MESSAGE, ...) \ 184 if (BOOL_FUNC) { \ 185 HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ 186 } 187 188 #define HKS_IF_NOT_TRUE_LOGE(BOOL_FUNC, LOG_MESSAGE, ...) \ 189 if (!(BOOL_FUNC)) { \ 190 HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ 191 } 192 193 #define HKS_IF_NOT_TRUE_RETURN(BOOL_FUNC, ERROR_CODE) \ 194 if (!(BOOL_FUNC)) { \ 195 return (ERROR_CODE); \ 196 } 197 198 #define HKS_IF_NOT_TRUE_LOGE_BREAK(BOOL_FUNC, LOG_MESSAGE, ...) \ 199 if (!(BOOL_FUNC)) { \ 200 HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ 201 break; \ 202 } 203 204 #define HKS_IF_NOT_TRUE_LOGE_RETURN(BOOL_FUNC, ERROR_CODE, LOG_MESSAGE, ...) \ 205 if (!(BOOL_FUNC)) { \ 206 HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ 207 return (ERROR_CODE); \ 208 } 209 210 #define HKS_IF_NOT_EOK_LOGE_RETURN(BOOL_FUNC, ERROR_CODE, LOG_MESSAGE, ...) \ 211 if ((BOOL_FUNC) != EOK) { \ 212 HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ 213 return (ERROR_CODE); \ 214 } 215 216 #define HKS_IF_NOT_EOK_LOGE_BREAK(BOOL_FUNC, LOG_MESSAGE, ...) \ 217 if ((BOOL_FUNC) != EOK) { \ 218 HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ 219 break; \ 220 } 221 222 #define HKS_IF_NOT_EOK_BREAK(BOOL_FUNC) \ 223 if ((BOOL_FUNC) != EOK) { \ 224 break; \ 225 } 226 227 #define HKS_IF_TRUE_LOGE_BREAK(BOOL_FUNC, LOG_MESSAGE, ...) \ 228 if (BOOL_FUNC) { \ 229 HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ 230 break; \ 231 } 232 233 #define HKS_IF_TRUE_BREAK(BOOL_FUNC) \ 234 if (BOOL_FUNC) { \ 235 break; \ 236 } 237 238 #define HKS_IF_NOT_TRUE_RETURN_VOID(BOOL_FUNC) \ 239 if (!(BOOL_FUNC)) { \ 240 return; \ 241 } \ 242 243 #define HKS_IF_NOT_TRUE_LOGE_RETURN_VOID(BOOL_FUNC, LOG_MESSAGE, ...) \ 244 if (!(BOOL_FUNC)) { \ 245 HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ 246 return; \ 247 } 248 249 #define HKS_LOG_ERRNO(msg, ret) ({ int currentErrno = errno; \ 250 HKS_LOG_E_IMPORTANT(msg " ret: %" LOG_PUBLIC "d, errno: %" LOG_PUBLIC "d, strerror: %" LOG_PUBLIC "s", \ 251 (ret), currentErrno, strerror(currentErrno)); }) 252 253 #define HKS_LOG_FILE_OP_ERRNO(msg, type) ({ int currentErrno = errno; \ 254 HKS_LOG_E_IMPORTANT(msg " pathType: %" LOG_PUBLIC "d, errno: %" LOG_PUBLIC "d, strerror: %" LOG_PUBLIC "s", \ 255 (type), currentErrno, strerror(currentErrno)); }) 256 257 #define HKS_IF_NOT_SUCC_LOG_ERRNO_RETURN(msg, ret) ({ int currentErrno = errno; \ 258 if ((ret) != 0) { \ 259 HKS_LOG_E(msg " %" LOG_PUBLIC "d, errno: %" LOG_PUBLIC "d, strerror: %" LOG_PUBLIC "s", \ 260 (ret), currentErrno, strerror(currentErrno)); \ 261 return HKS_FAILURE; \ 262 }}) 263 264 #define HKS_IF_NOT_TRUE_LOGI(RESULT, LOG_MESSAGE, ...) \ 265 do { \ 266 if (!(RESULT)) { \ 267 HKS_LOG_I(LOG_MESSAGE, ##__VA_ARGS__); \ 268 } \ 269 } while (0) 270 271 #define HKS_IF_NOT_TRUE_LOGI_RETURN(RESULT, ERROR_CODE, LOG_MESSAGE, ...) \ 272 if (!(RESULT)) { \ 273 HKS_LOG_I(LOG_MESSAGE, ##__VA_ARGS__); \ 274 return (ERROR_CODE); \ 275 } 276 277 #endif /* HKS_TEMPLATE_H */