├── README.md
├── lcl.c
├── lcl.h
├── lcl.m
├── lcl_config_components.template.h
├── lcl_config_extensions.template.h
└── lcl_config_logger.template.h


/README.md:
--------------------------------------------------------------------------------
  1 | 
  2 | # LibComponentLogging-Core
  3 | 
  4 | [http://0xc0.de/LibComponentLogging](http://0xc0.de/LibComponentLogging)    
  5 | [http://github.com/aharren/LibComponentLogging-Core](http://github.com/aharren/LibComponentLogging-Core)
  6 | 
  7 | 
  8 | ## Overview
  9 | 
 10 | LibComponentLogging is a small logging library for Objective-C on Mac OS X and
 11 | iOS which provides log levels, log components, and pluggable logging back-ends,
 12 | e.g. writing log messages to a file, or sending them to the system log.
 13 | 
 14 | LibComponentLogging is available under the terms of the MIT license.
 15 | 
 16 | This Git repository contains the library's Core part.
 17 | 
 18 | 
 19 | ## Example
 20 | 
 21 | After configuring a logging back-end, e.g. the LogFile back-end, you can simply
 22 | start logging (to the log file) by using LibComponentLogging's standard logging
 23 | macro lcl_log(...), e.g.
 24 | 
 25 |     lcl_log(lcl_cMyComponent, lcl_vError, @"message ...");
 26 | 
 27 | The LogFile logger uses the format
 28 | 
 29 |     <date> <time> <pid>:<tid> <level> <component>:<file>:<line>:<function> <message>
 30 | 
 31 | and produces the output
 32 | 
 33 |     2009-02-01 12:38:32.796 4964:10b D component1:main.m:28:-[Class method] Message
 34 |     2009-02-01 12:38:32.798 4964:10b D component2:main.m:32:-[Class method] Message
 35 |     2009-02-01 12:38:32.799 4964:10b D component3:main.m:36:-[Class method] Message
 36 | 
 37 | See [http://0xc0.de/LibComponentLogging](http://0xc0.de/LibComponentLogging)
 38 | for more information about LibComponentLogging and more examples.
 39 | 
 40 | 
 41 | ## Installation
 42 | 
 43 | Download the files of the library Core and a logging back-end, e.g. the
 44 | LogFile logger, from their repositories on GitHub:
 45 | 
 46 | * [Library Core](http://github.com/aharren/LibComponentLogging-Core/)
 47 | 
 48 | * [LogFile Logger](http://github.com/aharren/LibComponentLogging-LogFile/)
 49 | 
 50 | * [SystemLog Logger](http://github.com/aharren/LibComponentLogging-SystemLog/)
 51 | 
 52 | * [NSLog Logger](http://github.com/aharren/LibComponentLogging-NSLog/)
 53 | 
 54 | * [NSLogger Logger](http://github.com/aharren/LibComponentLogging-NSLogger/)
 55 | 
 56 | Extract the files and copy the extracted files to your application's source
 57 | directory.
 58 | 
 59 | Open Xcode and add all files of the library to your application's project.
 60 | Xcode will automatically add the library's implementation files to your
 61 | project's target.
 62 | 
 63 | Create a lcl_config_logger.h file and set up the logger, e.g. set the maximum
 64 | file size and the name of the log file for the LogFile logger.
 65 | 
 66 | Create a lcl_config_extensions.h file and optionally add #import statements
 67 | for logging extensions.
 68 | 
 69 | Create your application's lcl_config_components.h file.
 70 | 
 71 | Add a #import statement for lcl.h to your application files, e.g. to your
 72 | application's prefix header file.
 73 | 
 74 | Define your log components in lcl_config_components.h.
 75 | 
 76 | Add lcl_log(...) log statements to your application.
 77 | 
 78 | See [http://0xc0.de/LibComponentLogging#Installation](http://0xc0.de/LibComponentLogging#Installation)
 79 | for more information about installing and configuring LibComponentLogging.
 80 | 
 81 | 
 82 | ## Repository Branches
 83 | 
 84 | The Git repository contains the following branches:
 85 | 
 86 | * [master](http://github.com/aharren/LibComponentLogging-Core/tree/master):
 87 |   The *master* branch contains stable builds of the main logging code
 88 |   which are tagged with version numbers.
 89 | 
 90 | * [devel](http://github.com/aharren/LibComponentLogging-Core/tree/devel):
 91 |   The *devel* branch is the development branch for the logging code
 92 |   which contains an Xcode project and unit tests. The code in this branch is
 93 |   not stable.
 94 | 
 95 | 
 96 | ## Related Repositories
 97 | 
 98 | The following Git repositories are related to this repository: 
 99 | 
100 | * [LibComponentLogging-LogFile](http://github.com/aharren/LibComponentLogging-LogFile):
101 |   A file logging class which writes log messages to an application-specific log
102 |   file.
103 | 
104 | * [LibComponentLogging-SystemLog](http://github.com/aharren/LibComponentLogging-SystemLog):
105 |   A logging class which sends log messages to the Apple System Log facility (ASL).
106 | 
107 | * [LibComponentLogging-NSLog](http://github.com/aharren/LibComponentLogging-NSLog):
108 |   A very simple logger which redirects log messages to NSLog, but adds
109 |   information about the log level, the log component, and the log statement's
110 |   location (file name and line number).
111 | 
112 | * [LibComponentLogging-NSLogger](http://github.com/aharren/LibComponentLogging-NSLogger):
113 |   A logger which integrates the logging client from Florent Pillet's NSLogger project.    
114 |   See [http://github.com/fpillet/NSLogger](http://github.com/fpillet/NSLogger) for more details about NSLogger.
115 | 
116 | * [LibComponentLogging-qlog](http://github.com/aharren/LibComponentLogging-qlog):
117 |   An extension which provides a set of quick logging macros.
118 | 
119 | * [LibComponentLogging-UserDefaults](http://github.com/aharren/LibComponentLogging-UserDefaults)
120 |   An extension which stores/restores log level settings to/from the user defaults.
121 | 
122 | 
123 | ## Copyright and License
124 | 
125 | Copyright (c) 2008-2015 Arne Harren <ah@0xc0.de>
126 | 
127 | Permission is hereby granted, free of charge, to any person obtaining a copy
128 | of this software and associated documentation files (the "Software"), to deal
129 | in the Software without restriction, including without limitation the rights
130 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
131 | copies of the Software, and to permit persons to whom the Software is
132 | furnished to do so, subject to the following conditions:
133 | 
134 | The above copyright notice and this permission notice shall be included in
135 | all copies or substantial portions of the Software.
136 | 
137 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
138 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
139 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
140 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
141 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
142 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
143 | THE SOFTWARE.
144 | 
145 | 


--------------------------------------------------------------------------------
/lcl.c:
--------------------------------------------------------------------------------
 1 | //
 2 | //
 3 | // lcl.c -- LibComponentLogging
 4 | //
 5 | //
 6 | // Copyright (c) 2008-2015 Arne Harren <ah@0xc0.de>
 7 | //
 8 | // Permission is hereby granted, free of charge, to any person obtaining a copy
 9 | // of this software and associated documentation files (the "Software"), to deal
10 | // in the Software without restriction, including without limitation the rights
11 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 | // copies of the Software, and to permit persons to whom the Software is
13 | // furnished to do so, subject to the following conditions:
14 | //
15 | // The above copyright notice and this permission notice shall be included in
16 | // all copies or substantial portions of the Software.
17 | //
18 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 | // THE SOFTWARE.
25 | 
26 | 
27 | // C variant of lcl.m
28 | #include "lcl.m"
29 | 
30 | 


--------------------------------------------------------------------------------
/lcl.h:
--------------------------------------------------------------------------------
  1 | //
  2 | //
  3 | // lcl.h -- LibComponentLogging
  4 | //
  5 | //
  6 | // Copyright (c) 2008-2015 Arne Harren <ah@0xc0.de>
  7 | //
  8 | // Permission is hereby granted, free of charge, to any person obtaining a copy
  9 | // of this software and associated documentation files (the "Software"), to deal
 10 | // in the Software without restriction, including without limitation the rights
 11 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 12 | // copies of the Software, and to permit persons to whom the Software is
 13 | // furnished to do so, subject to the following conditions:
 14 | //
 15 | // The above copyright notice and this permission notice shall be included in
 16 | // all copies or substantial portions of the Software.
 17 | //
 18 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 19 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 20 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 21 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 22 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 23 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 24 | // THE SOFTWARE.
 25 | 
 26 | #ifndef __LCL_H__
 27 | #define __LCL_H__
 28 | 
 29 | #define _LCL_VERSION_MAJOR  1
 30 | #define _LCL_VERSION_MINOR  4
 31 | #define _LCL_VERSION_BUILD  1
 32 | #define _LCL_VERSION_SUFFIX ""
 33 | 
 34 | //
 35 | // lcl -- LibComponentLogging
 36 | //
 37 | // LibComponentLogging is a logging library for Objective-C applications
 38 | // with the following characteristics:
 39 | //
 40 | // - Log levels
 41 | //   The library provides log levels for distinguishing between error messages,
 42 | //   informational messages, and fine-grained trace messages for debugging.
 43 | //
 44 | // - Log components
 45 | //   The library provides log components for identifying different parts of an
 46 | //   application. A log component contains a unique identifier, a short name
 47 | //   which is used as a header in a log message, and a full name which can be
 48 | //   used in a user interface.
 49 | //
 50 | // - Active log level per log component
 51 | //   At runtime, the library provides an active log level for each log
 52 | //   component in order to enable/disable logging for certain parts of an
 53 | //   application.
 54 | //
 55 | // - Grouping of log components
 56 | //   Log components which have the same name prefix form a group of log
 57 | //   components and logging can be enabled/disabled for the whole group with
 58 | //   a single command.
 59 | //
 60 | // - Low runtime-overhead when logging is disabled
 61 | //   Logging is based on a log macro which checks the active log level before
 62 | //   constructing the log message and before evaluating log message arguments.
 63 | //
 64 | // - Code completion support
 65 | //   The library provides symbols for log components and log levels which work
 66 | //   with Xcode's code completion. All symbols, e.g. values or functions, which
 67 | //   are relevant when using the logging library in an application, are prefixed
 68 | //   with 'lcl_'. Internal symbols, which are needed when working with meta
 69 | //   data, when defining log components, or when writing a logging back-end, are
 70 | //   prefixed with '_lcl_'. Internal symbols, which are only used by the logging
 71 | //   library itself, are prefixed with '__lcl_'.
 72 | //
 73 | // - Meta data
 74 | //   The library provides public data structures which contain information about
 75 | //   log levels and log components, e.g. headers and names.
 76 | //
 77 | // - Pluggable loggers
 78 | //   The library does not contain a concrete logger, but provides a simple
 79 | //   delegation mechanism for plugging-in a concrete logger based on the
 80 | //   application's requirements, e.g. a logger which writes to the system log,
 81 | //   or a logger which writes to a log file. The concrete logger is configured
 82 | //   at build-time.
 83 | //
 84 | // Note: If the preprocessor symbol _LCL_NO_LOGGING is defined, the log macro
 85 | // will be defined to an empty effect.
 86 | //
 87 | // Note: Define _LCL_C_MODE to force LibComponentLogging into plain C mode.
 88 | //
 89 | 
 90 | 
 91 | #if (!defined(__OBJC__)) || defined(_LCL_C_MODE)
 92 | #   define __lcl_c_mode
 93 | #endif
 94 | 
 95 | #ifdef __lcl_c_mode
 96 |     // Use C headers.
 97 | #   include <stdint.h>
 98 | #   include <string.h>
 99 | #   include <stdio.h>
100 | #else
101 |     // Use Objective-C Foundation headers.
102 | #   import <Foundation/Foundation.h>
103 | #endif
104 | 
105 | 
106 | // Use C linkage.
107 | #ifdef __cplusplus
108 | extern "C" {
109 | #endif
110 | 
111 | 
112 | //
113 | // Settings for configuration files.
114 | //
115 | 
116 | 
117 | #ifndef _LCL_NO_USE_CONFIG_INCLUDES
118 |     // By default, use all config includes.
119 | #   define __lcl_use_config_include_lcl_config_components_h
120 | #   define __lcl_use_config_include_lcl_config_logger_h
121 | #   define __lcl_use_config_include_lcl_config_extensions_h
122 | #endif
123 | 
124 | #ifndef _LCL_NO_CHECK_HAS_CONFIG_INCLUDES
125 | #   if defined(__has_include)
126 |         // Skip non-existing includes and use defaults instead.
127 | #       if !(__has_include("lcl_config_components.h"))
128 | #           undef __lcl_use_config_include_lcl_config_components_h
129 | #       endif
130 | #       if !(__has_include("lcl_config_logger.h"))
131 | #           undef __lcl_use_config_include_lcl_config_logger_h
132 | #       endif
133 | #       if !(__has_include("lcl_config_extensions.h"))
134 | #           undef __lcl_use_config_include_lcl_config_extensions_h
135 | #       endif
136 | #   endif
137 | #endif
138 | 
139 | 
140 | //
141 | // Log levels.
142 | //
143 | 
144 | 
145 | #ifndef _LCL_NO_IGNORE_WARNINGS
146 | #   ifdef __clang__
147 |     // Ignore warnings about duplicate enum values when using '-Weverything'.
148 | #   pragma clang diagnostic push
149 | #   pragma clang diagnostic ignored "-Wduplicate-enum"
150 | #   endif
151 | #endif
152 | 
153 | // Log levels, prefixed with 'lcl_v'.
154 | enum _lcl_enum_level_t {
155 |     lcl_vOff = 0,
156 | 
157 |     lcl_vCritical,              // critical situation
158 |     lcl_vError,                 // error situation
159 |     lcl_vWarning,               // warning
160 |     lcl_vInfo,                  // informational message
161 |     lcl_vDebug,                 // coarse-grained debugging information
162 |     lcl_vTrace,                 // fine-grained debugging information
163 |     
164 |    _lcl_level_t_count,
165 |    _lcl_level_t_first = 0,
166 |    _lcl_level_t_last  = _lcl_level_t_count-1
167 | };
168 | 
169 | #ifndef _LCL_NO_IGNORE_WARNINGS
170 | #   ifdef __clang__
171 | #   pragma clang diagnostic pop
172 | #   endif
173 | #endif
174 | 
175 | // Log level type.
176 | typedef uint32_t _lcl_level_t;
177 | typedef uint8_t  _lcl_level_narrow_t;
178 | 
179 | 
180 | //
181 | // Log components.
182 | //
183 | 
184 | 
185 | #ifndef _LCL_NO_IGNORE_WARNINGS
186 | #   ifdef __clang__
187 |     // Ignore warnings about duplicate enum values when using '-Weverything'.
188 | #   pragma clang diagnostic push
189 | #   pragma clang diagnostic ignored "-Wduplicate-enum"
190 | #   endif
191 | #endif
192 | 
193 | // Log components, prefixed with 'lcl_c'.
194 | enum _lcl_enum_component_t {
195 | #   define  _lcl_component(_identifier, _header, _name)                        \
196 |     lcl_c##_identifier,                                                        \
197 |   __lcl_log_symbol_lcl_c##_identifier = lcl_c##_identifier,
198 | #ifdef __lcl_use_config_include_lcl_config_components_h
199 | #   include "lcl_config_components.h"
200 | #else
201 |     _lcl_component(Main, "main", "Main")
202 | #endif
203 | #   undef   _lcl_component
204 | 
205 |    _lcl_component_t_count,
206 |    _lcl_component_t_first = 0,
207 |    _lcl_component_t_last  = _lcl_component_t_count-1
208 | };
209 | 
210 | #ifndef _LCL_NO_IGNORE_WARNINGS
211 | #   ifdef __clang__
212 | #   pragma clang diagnostic pop
213 | #   endif
214 | #endif
215 | 
216 | // Log component type.
217 | typedef uint32_t _lcl_component_t;
218 | 
219 | 
220 | //
221 | // Functions and macros.
222 | //
223 | 
224 | #ifndef _LCL_NO_IGNORE_WARNINGS
225 | #   ifdef __clang__
226 |     // Ignore some warnings about variadic macros when using '-Weverything'.
227 | #   pragma clang diagnostic push
228 | #   pragma clang diagnostic ignored "-Wunknown-pragmas"
229 | #   pragma clang diagnostic ignored "-Wvariadic-macros"
230 | #   pragma clang diagnostic ignored "-Wpedantic"
231 | #   endif
232 | #endif
233 | 
234 | // lcl_log(<component>, <level>, <format>[, <arg1>[, <arg2>[, ...]]])
235 | //
236 | // <component>: a log component with prefix 'lcl_c'
237 | // <level>    : a log level with prefix 'lcl_v'
238 | // <format>   : a format string of type NSString (may include %@)
239 | // <arg..>    : optional arguments required by the format string
240 | //
241 | // Logs a message for the given log component at the given log level if the
242 | // log level is active for the log component.
243 | //
244 | // The actual logging is done by _lcl_logger which must be defined by a concrete
245 | // logging back-end. _lcl_logger has the same signature as lcl_log.
246 | //
247 | #ifdef _LCL_NO_LOGGING
248 | #   define lcl_log(_component, _level, _format, ...)                           \
249 |         do {                                                                   \
250 |         } while (0)
251 | #else
252 | #   define lcl_log(_component, _level, _format, ...)                           \
253 |         do {                                                                   \
254 |             if (_lcl_component_is_active_at_level(_component, _level)          \
255 |                ) {                                                             \
256 |                     _lcl_logger(_component,                                    \
257 |                                 _level,                                        \
258 |                                 _format,                                       \
259 |                                 ##__VA_ARGS__);                                \
260 |             }                                                                  \
261 |         } while (0)
262 | #endif
263 | 
264 | // lcl_log_if(<component>, <level>, <predicate>, <format>[, <arg1>[, ...]])
265 | //
266 | // <component>: a log component with prefix 'lcl_c'
267 | // <level>    : a log level with prefix 'lcl_v'
268 | // <predicate>: a predicate for conditional logging
269 | // <format>   : a format string of type NSString (may include %@)
270 | // <arg..>    : optional arguments required by the format string
271 | //
272 | // Logs a message for the given log component at the given log level if the
273 | // log level is active for the log component and if the predicate evaluates
274 | // to true.
275 | //
276 | // The predicate is only evaluated if the given log level is active.
277 | //
278 | // The actual logging is done by _lcl_logger which must be defined by a concrete
279 | // logging back-end. _lcl_logger has the same signature as lcl_log.
280 | //
281 | #ifdef _LCL_NO_LOGGING
282 | #   define lcl_log_if(_component, _level, _predicate, _format, ...)            \
283 |         do {                                                                   \
284 |         } while (0)
285 | #else
286 | #   define lcl_log_if(_component, _level, _predicate, _format, ...)            \
287 |         do {                                                                   \
288 |             if (_lcl_component_is_active_at_level(_component, _level)          \
289 |                 &&                                                             \
290 |                 (_predicate)                                                   \
291 |                ) {                                                             \
292 |                     _lcl_logger(_component,                                    \
293 |                                 _level,                                        \
294 |                                 _format,                                       \
295 |                                 ##__VA_ARGS__);                                \
296 |             }                                                                  \
297 |         } while (0)
298 | #endif
299 | 
300 | #ifndef _LCL_NO_IGNORE_WARNINGS
301 | #   ifdef __clang__
302 | #   pragma clang diagnostic pop
303 | #   endif
304 | #endif
305 | 
306 | // lcl_configure_by_component(<component>, <level>)
307 | //
308 | // <component>: a log component with prefix 'lcl_c'
309 | // <level>    : a log level with prefix 'lcl_v'
310 | //
311 | // Configures the given log level for the given log component.
312 | // Returns the number of configured log components, or 0 on failure.
313 | //
314 | uint32_t lcl_configure_by_component(_lcl_component_t component, _lcl_level_t level);
315 | 
316 | // lcl_configure_by_identifier(<identifier>, <level>)
317 | //
318 | // <identifier>: a log component's identifier with optional '*' wildcard suffix
319 | // <level>     : a log level with prefix 'lcl_v'
320 | //
321 | // Configures the given log level for the given log component(s).
322 | // Returns the number of configured log components, or 0 on failure.
323 | //
324 | uint32_t lcl_configure_by_identifier(const char *identifier, _lcl_level_t level);
325 | 
326 | // lcl_configure_by_header(<header>, <level>)
327 | //
328 | // <header>    : a log component's header with optional '*' wildcard suffix
329 | // <level>     : a log level with prefix 'lcl_v'
330 | //
331 | // Configures the given log level for the given log component(s).
332 | // Returns the number of configured log components, or 0 on failure.
333 | //
334 | uint32_t lcl_configure_by_header(const char *header, _lcl_level_t level);
335 | 
336 | // lcl_configure_by_name(<name>, <level>)
337 | //
338 | // <name>     : a log component's name with optional '*' wildcard suffix
339 | // <level>    : a log level with prefix 'lcl_v'
340 | //
341 | // Configures the given log level for the given log component(s).
342 | // Returns the number of configured log components, or 0 on failure.
343 | //
344 | uint32_t lcl_configure_by_name(const char *name, _lcl_level_t level);
345 | 
346 | 
347 | //
348 | // Internals.
349 | //
350 | 
351 | 
352 | // Active log levels, indexed by log component.
353 | extern _lcl_level_narrow_t _lcl_component_level[_lcl_component_t_count];
354 | 
355 | // Checks whether the given log component is active at the given log level.
356 | #define _lcl_component_is_active_at_level(_component, _level)                  \
357 |     (                                                                          \
358 |         (_lcl_component_level[(__lcl_log_symbol(_component))])                 \
359 |         >=                                                                     \
360 |         (__lcl_log_symbol(_level))                                             \
361 |     )
362 | 
363 | // Log component identifiers, indexed by log component.
364 | extern const char * const _lcl_component_identifier[_lcl_component_t_count];
365 | 
366 | // Log component headers, indexed by log component.
367 | extern const char * const _lcl_component_header[_lcl_component_t_count];
368 | 
369 | // Log component names, indexed by log component.
370 | extern const char * const _lcl_component_name[_lcl_component_t_count];
371 | 
372 | // Log level headers, indexed by log level.
373 | extern const char * const _lcl_level_header[_lcl_level_t_count];   // full header
374 | extern const char * const _lcl_level_header_1[_lcl_level_t_count]; // header with 1 character
375 | extern const char * const _lcl_level_header_3[_lcl_level_t_count]; // header with 3 characters
376 | 
377 | // Log level names, indexed by log level.
378 | extern const char * const _lcl_level_name[_lcl_level_t_count];
379 | 
380 | // Version.
381 | extern const char * const _lcl_version;
382 | 
383 | // Log level symbols used by lcl_log, prefixed with '__lcl_log_symbol_lcl_v'.
384 | enum {
385 |   __lcl_log_symbol_lcl_vCritical = lcl_vCritical,
386 |   __lcl_log_symbol_lcl_vError    = lcl_vError,
387 |   __lcl_log_symbol_lcl_vWarning  = lcl_vWarning,
388 |   __lcl_log_symbol_lcl_vInfo     = lcl_vInfo,
389 |   __lcl_log_symbol_lcl_vDebug    = lcl_vDebug,
390 |   __lcl_log_symbol_lcl_vTrace    = lcl_vTrace
391 | };
392 | 
393 | // Macro for appending the '__lcl_log_symbol_' prefix to a given symbol.
394 | #define __lcl_log_symbol(_symbol)                                              \
395 |     __lcl_log_symbol_##_symbol
396 | 
397 | 
398 | // End C linkage.
399 | #ifdef __cplusplus
400 | }
401 | #endif
402 | 
403 | 
404 | // Macro for getting the filename; can be constant-folded by some compilers.
405 | #ifndef _lcl_filename
406 | #   define _lcl_filename                                                       \
407 |         (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
408 | #endif
409 | 
410 | 
411 | // Include logging back-end and definition of _lcl_logger.
412 | #ifdef __lcl_use_config_include_lcl_config_logger_h
413 | #   ifdef __lcl_c_mode
414 |         // In C mode, _lcl_logger should not require Objective-C arguments.
415 | #       include "lcl_config_logger.h"
416 | #   else
417 | #       import "lcl_config_logger.h"
418 | #   endif
419 | #endif
420 | 
421 | 
422 | // For simple configurations where 'lcl_config_logger.h' is empty or does not
423 | // exist, define a default _lcl_logger here.
424 | 
425 | #ifndef _lcl_logger
426 | 
427 | #ifndef _LCL_NO_IGNORE_WARNINGS
428 | #   ifdef __clang__
429 |     // Ignore some warnings about variadic macros when using '-Weverything'.
430 | #   pragma clang diagnostic push
431 | #   pragma clang diagnostic ignored "-Wunknown-pragmas"
432 | #   pragma clang diagnostic ignored "-Wvariadic-macros"
433 | #   pragma clang diagnostic ignored "-Wpedantic"
434 | #   endif
435 | #endif
436 | 
437 | #ifdef __lcl_c_mode
438 |     // For C, write to stdout.
439 | 
440 | #   ifndef _lcl_c_logger_printf
441 | #       define _lcl_c_logger_printf fprintf
442 | #   endif
443 | #   ifndef _lcl_c_logger_stream
444 | #       define _lcl_c_logger_stream stdout
445 | #   endif
446 | #   define _lcl_logger(_component, _level, _format, ...) {                     \
447 |         _lcl_c_logger_printf(_lcl_c_logger_stream, "%s %s:%s:%d " _format,     \
448 |                              _lcl_level_header_1[_level],                      \
449 |                              _lcl_component_header[_component],                \
450 |                              _lcl_filename,                                    \
451 |                              __LINE__,                                         \
452 |                              ## __VA_ARGS__);                                  \
453 |     }
454 | 
455 | #else
456 |     // For Objective-C, use NSLog().
457 | 
458 |     // ARC/non-ARC autorelease pool
459 | #   define _lcl_logger_autoreleasepool_arc 0
460 | #   if defined(__has_feature)
461 | #       if __has_feature(objc_arc)
462 | #       undef  _lcl_logger_autoreleasepool_arc
463 | #       define _lcl_logger_autoreleasepool_arc 1
464 | #       endif
465 | #   endif
466 | #   if _lcl_logger_autoreleasepool_arc
467 | #       define _lcl_logger_autoreleasepool_begin                               \
468 |             @autoreleasepool {
469 | #       define _lcl_logger_autoreleasepool_end                                 \
470 |             }
471 | #   else
472 | #       define _lcl_logger_autoreleasepool_begin                               \
473 |             NSAutoreleasePool *_lcl_logger_autoreleasepool = [[NSAutoreleasePool alloc] init];
474 | #       define _lcl_logger_autoreleasepool_end                                 \
475 |             [_lcl_logger_autoreleasepool release];
476 | #   endif
477 | 
478 |     // A simple default logger, which redirects to NSLog().
479 | #   define _lcl_logger(_component, _level, _format, ...) {                     \
480 |         _lcl_logger_autoreleasepool_begin                                      \
481 |         NSLog(@"%s %s:%s:%d " _format,                                         \
482 |               _lcl_level_header_1[_level],                                     \
483 |               _lcl_component_header[_component],                               \
484 |               _lcl_filename,                                                   \
485 |               __LINE__,                                                        \
486 |               ## __VA_ARGS__);                                                 \
487 |         _lcl_logger_autoreleasepool_end                                        \
488 |     }
489 | 
490 | #endif
491 | 
492 | #ifndef _LCL_NO_IGNORE_WARNINGS
493 | #   ifdef __clang__
494 | #   pragma clang diagnostic pop
495 | #   endif
496 | #endif
497 | 
498 | #endif
499 | 
500 | 
501 | // Include extensions.
502 | #ifdef __lcl_use_config_include_lcl_config_extensions_h
503 | #   ifdef __lcl_c_mode
504 | #       include "lcl_config_extensions.h"
505 | #   else
506 | #       import "lcl_config_extensions.h"
507 | #   endif
508 | #endif
509 | 
510 | 
511 | #endif // __LCL_H__
512 | 
513 | 


--------------------------------------------------------------------------------
/lcl.m:
--------------------------------------------------------------------------------
  1 | //
  2 | //
  3 | // lcl.m -- LibComponentLogging
  4 | //
  5 | //
  6 | // Copyright (c) 2008-2015 Arne Harren <ah@0xc0.de>
  7 | //
  8 | // Permission is hereby granted, free of charge, to any person obtaining a copy
  9 | // of this software and associated documentation files (the "Software"), to deal
 10 | // in the Software without restriction, including without limitation the rights
 11 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 12 | // copies of the Software, and to permit persons to whom the Software is
 13 | // furnished to do so, subject to the following conditions:
 14 | //
 15 | // The above copyright notice and this permission notice shall be included in
 16 | // all copies or substantial portions of the Software.
 17 | //
 18 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 19 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 20 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 21 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 22 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 23 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 24 | // THE SOFTWARE.
 25 | 
 26 | #include "lcl.h"
 27 | #include <string.h>
 28 | 
 29 | 
 30 | // Active log levels, indexed by log component.
 31 | _lcl_level_narrow_t _lcl_component_level[_lcl_component_t_count];
 32 | 
 33 | // Log component identifiers, indexed by log component.
 34 | const char * const _lcl_component_identifier[_lcl_component_t_count] = {
 35 | #   define  _lcl_component(_identifier, _header, _name)                        \
 36 |     #_identifier,
 37 | #ifdef __lcl_use_config_include_lcl_config_components_h
 38 | #   include "lcl_config_components.h"
 39 | #else
 40 |     _lcl_component(Main, "main", "Main")
 41 | #endif
 42 | #   undef   _lcl_component
 43 | };
 44 | 
 45 | // Log component headers, indexed by log component.
 46 | const char * const _lcl_component_header[_lcl_component_t_count] = {
 47 | #   define  _lcl_component(_identifier, _header, _name)                        \
 48 |     _header,
 49 | #ifdef __lcl_use_config_include_lcl_config_components_h
 50 | #   include "lcl_config_components.h"
 51 | #else
 52 |     _lcl_component(Main, "main", "Main")
 53 | #endif
 54 | #   undef   _lcl_component
 55 | };
 56 | 
 57 | // Log component names, indexed by log component.
 58 | const char * const _lcl_component_name[_lcl_component_t_count] = {
 59 | #   define  _lcl_component(_identifier, _header, _name)                        \
 60 |     _name,
 61 | #ifdef __lcl_use_config_include_lcl_config_components_h
 62 | #   include "lcl_config_components.h"
 63 | #else
 64 |     _lcl_component(Main, "main", "Main")
 65 | #endif
 66 | #   undef   _lcl_component
 67 | };
 68 | 
 69 | // Log level headers, indexed by log level.
 70 | const char * const _lcl_level_header[_lcl_level_t_count] = {
 71 |     "-",
 72 |     "CRITICAL",
 73 |     "ERROR",
 74 |     "WARNING",
 75 |     "INFO",
 76 |     "DEBUG",
 77 |     "TRACE"
 78 | };
 79 | const char * const _lcl_level_header_1[_lcl_level_t_count] = {
 80 |     "-",
 81 |     "C",
 82 |     "E",
 83 |     "W",
 84 |     "I",
 85 |     "D",
 86 |     "T"
 87 | };
 88 | const char * const _lcl_level_header_3[_lcl_level_t_count] = {
 89 |     "---",
 90 |     "CRI",
 91 |     "ERR",
 92 |     "WRN",
 93 |     "INF",
 94 |     "DBG",
 95 |     "TRC"
 96 | };
 97 | 
 98 | // Log level names, indexed by log level.
 99 | const char * const _lcl_level_name[_lcl_level_t_count] = {
100 |     "Off",
101 |     "Critical",
102 |     "Error",
103 |     "Warning",
104 |     "Info",
105 |     "Debug",
106 |     "Trace"
107 | };
108 | 
109 | // Version.
110 | #define __lcl_version_to_string( _text) __lcl_version_to_string0(_text)
111 | #define __lcl_version_to_string0(_text) #_text
112 | const char * const _lcl_version = __lcl_version_to_string(_LCL_VERSION_MAJOR) 
113 |                               "." __lcl_version_to_string(_LCL_VERSION_MINOR)
114 |                               "." __lcl_version_to_string(_LCL_VERSION_BUILD)
115 |                               ""  _LCL_VERSION_SUFFIX;
116 | 
117 | // Configures the given log level for the given log component.
118 | uint32_t lcl_configure_by_component(_lcl_component_t component, _lcl_level_t level) {
119 |     // unsupported level, clip to last level
120 |     if (level > _lcl_level_t_last) {
121 |         level = _lcl_level_t_last;
122 |     }
123 |     
124 |     // configure the component
125 |     if (component <= _lcl_component_t_last) {
126 |         _lcl_component_level[component] = level;
127 |         return 1;
128 |     }
129 |     
130 |     return 0;
131 | }
132 | 
133 | // Configures the given log level for the given log component(s).
134 | static uint32_t _lcl_configure_by_text(uint32_t count, const char * const *texts,
135 |                                        _lcl_level_narrow_t *levels, const char *text,
136 |                                        _lcl_level_t level) {
137 |     // no text given, quit
138 |     if (text == NULL || text[0] == '\0') {
139 |         return 0;
140 |     }
141 |     
142 |     // unsupported level, clip to last level
143 |     if (level > _lcl_level_t_last) {
144 |         level = _lcl_level_t_last;
145 |     }
146 |     
147 |     // configure the components
148 |     uint32_t num_configured = 0;
149 |     size_t text_len = strlen(text);
150 |     if (text[text_len-1] == '*') {
151 |         // text ends with '*', wildcard suffix was specified
152 |         text_len--;
153 |         for (uint32_t c = 0; c < count; c++) {
154 |             if (strncmp(text, texts[c], text_len) == 0) {
155 |                 levels[c] = level;
156 |                 num_configured++;
157 |             }
158 |         }
159 |     } else {
160 |         // no wildcard suffix was specified
161 |         for (uint32_t c = 0; c < count; c++) {
162 |             if (strcmp(text, texts[c]) == 0) {
163 |                 levels[c] = level;
164 |                 num_configured++;
165 |             }
166 |         }
167 |     }
168 |     return num_configured;
169 | }
170 | 
171 | // Configures the given log level for the given log component(s) by identifier.
172 | uint32_t lcl_configure_by_identifier(const char *identifier, _lcl_level_t level) {
173 |     return _lcl_configure_by_text(_lcl_component_t_count, _lcl_component_identifier,
174 |                                   _lcl_component_level, identifier, level);
175 | }
176 | 
177 | // Configures the given log level for the given log component(s) by header.
178 | uint32_t lcl_configure_by_header(const char *header, _lcl_level_t level) {
179 |     return _lcl_configure_by_text(_lcl_component_t_count, _lcl_component_header,
180 |                                   _lcl_component_level, header, level);
181 | }
182 | 
183 | // Configures the given log level for the given log component(s) by name.
184 | uint32_t lcl_configure_by_name(const char *name, _lcl_level_t level) {
185 |     return _lcl_configure_by_text(_lcl_component_t_count, _lcl_component_name,
186 |                                   _lcl_component_level, name, level);
187 | }
188 | 
189 | 


--------------------------------------------------------------------------------
/lcl_config_components.template.h:
--------------------------------------------------------------------------------
 1 | //
 2 | //
 3 | // lcl_config_components.h
 4 | //
 5 | //
 6 | // Copyright (c) 2008-2015 Arne Harren <ah@0xc0.de>
 7 | //
 8 | // Permission is hereby granted, free of charge, to any person obtaining a copy
 9 | // of this software and associated documentation files (the "Software"), to deal
10 | // in the Software without restriction, including without limitation the rights
11 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 | // copies of the Software, and to permit persons to whom the Software is
13 | // furnished to do so, subject to the following conditions:
14 | //
15 | // The above copyright notice and this permission notice shall be included in
16 | // all copies or substantial portions of the Software.
17 | //
18 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 | // THE SOFTWARE.
25 | 
26 | //
27 | // lcl_config_components.h template.
28 | //
29 | 
30 | 
31 | //
32 | // The lcl_config_components.h file is used to define the application's log
33 | // components.
34 | //
35 | // Use the code
36 | //
37 | //   _lcl_component(<identifier>, <header>, <name>)
38 | //
39 | // for defining a log component, where
40 | //
41 | // - <identifier> is the unique name of a log component which is used in calls
42 | //   to lcl_log etc. A symbol 'lcl_c<identifier>' is automatically created for
43 | //   each log component.
44 | //
45 | // - <header> is a C string in UTF-8 which should be used by a logging back-end
46 | //   when writing a log message for the log component. The header is a technical
47 | //   key for identifying a log component's messages. It is recommended to use
48 | //   a 'Reverse ICANN' naming scheme when the header contains grouping
49 | //   information, e.g. 'example.main.component1'.
50 | //
51 | // - <name> is a C string in UTF-8 which contains the name of the log component
52 | //   and its grouping information in a non-technical, human-readable way
53 | //   which could be used by a user interface. Groups should be separated by the
54 | //   path separator '/', e.g. 'Example/Main/Component 1'.
55 | // 
56 | 
57 | 
58 | //
59 | // Examples
60 | //
61 | 
62 | _lcl_component(Main,            "main",             "Main")
63 | _lcl_component(MainComponent1,  "main.component1",  "Main/Component1")
64 | _lcl_component(MainComponent2,  "main.component2",  "Main/Component2")
65 | 
66 | _lcl_component(Main2,           "main2",            "Main2")
67 | 
68 | _lcl_component(Main3,           "main3",            "Main3")
69 | 
70 | 


--------------------------------------------------------------------------------
/lcl_config_extensions.template.h:
--------------------------------------------------------------------------------
 1 | //
 2 | //
 3 | // lcl_config_extensions.h
 4 | //
 5 | //
 6 | // Copyright (c) 2008-2015 Arne Harren <ah@0xc0.de>
 7 | //
 8 | // Permission is hereby granted, free of charge, to any person obtaining a copy
 9 | // of this software and associated documentation files (the "Software"), to deal
10 | // in the Software without restriction, including without limitation the rights
11 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 | // copies of the Software, and to permit persons to whom the Software is
13 | // furnished to do so, subject to the following conditions:
14 | //
15 | // The above copyright notice and this permission notice shall be included in
16 | // all copies or substantial portions of the Software.
17 | //
18 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 | // THE SOFTWARE.
25 | 
26 | //
27 | // lcl_config_extensions.h template.
28 | //
29 | 
30 | 
31 | //
32 | // The lcl_config_extensions.h file can be used to #include, #import, or define
33 | // log extensions.
34 | //
35 | 
36 | 


--------------------------------------------------------------------------------
/lcl_config_logger.template.h:
--------------------------------------------------------------------------------
 1 | //
 2 | //
 3 | // lcl_config_logger.h
 4 | //
 5 | //
 6 | // Copyright (c) 2008-2015 Arne Harren <ah@0xc0.de>
 7 | //
 8 | // Permission is hereby granted, free of charge, to any person obtaining a copy
 9 | // of this software and associated documentation files (the "Software"), to deal
10 | // in the Software without restriction, including without limitation the rights
11 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 | // copies of the Software, and to permit persons to whom the Software is
13 | // furnished to do so, subject to the following conditions:
14 | //
15 | // The above copyright notice and this permission notice shall be included in
16 | // all copies or substantial portions of the Software.
17 | //
18 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 | // THE SOFTWARE.
25 | 
26 | //
27 | // lcl_config_logger.h template.
28 | //
29 | 
30 | 
31 | //
32 | // The lcl_config_logger.h file is used to define the logging back-end which
33 | // is used by the lcl_log() logging macro.
34 | //
35 | // For integration with the logging macro, a back-end simply defines the
36 | // _lcl_logger macro which has the following signature:
37 | //
38 | //   #define _lcl_logger(_component, _level, _format, ...) <logging action>
39 | //
40 | 
41 | 
42 | //
43 | // Example
44 | //
45 | 
46 | 
47 | // ARC/non-ARC autorelease pool
48 | #define _lcl_logger_autoreleasepool_arc 0
49 | #if defined(__has_feature)
50 | #   if __has_feature(objc_arc)
51 | #   undef  _lcl_logger_autoreleasepool_arc
52 | #   define _lcl_logger_autoreleasepool_arc 1
53 | #   endif
54 | #endif
55 | #if _lcl_logger_autoreleasepool_arc
56 | #   define _lcl_logger_autoreleasepool_begin                                   \
57 |         @autoreleasepool {
58 | #   define _lcl_logger_autoreleasepool_end                                     \
59 |         }
60 | #else
61 | #   define _lcl_logger_autoreleasepool_begin                                   \
62 |         NSAutoreleasePool *_lcl_logger_autoreleasepool = [[NSAutoreleasePool alloc] init];
63 | #   define _lcl_logger_autoreleasepool_end                                     \
64 |         [_lcl_logger_autoreleasepool release];
65 | #endif
66 | 
67 | #ifndef _LCL_NO_IGNORE_WARNINGS
68 | #   ifdef __clang__
69 |     // Ignore some warnings about variadic macros when using '-Weverything'.
70 | #   pragma clang diagnostic push
71 | #   pragma clang diagnostic ignored "-Wunknown-pragmas"
72 | #   pragma clang diagnostic ignored "-Wvariadic-macros"
73 | #   pragma clang diagnostic ignored "-Wpedantic"
74 | #   endif
75 | #endif
76 | 
77 | // A very simple logger, which redirects to NSLog().
78 | #define _lcl_logger(_component, _level, _format, ...) {                        \
79 |     _lcl_logger_autoreleasepool_begin                                          \
80 |     NSLog(@"%s %s:%s:%d:%s " _format,                                          \
81 |           _lcl_level_header_1[_level],                                         \
82 |           _lcl_component_header[_component],                                   \
83 |           _lcl_filename,                                                       \
84 |           __LINE__,                                                            \
85 |           __PRETTY_FUNCTION__,                                                 \
86 |           ## __VA_ARGS__);                                                     \
87 |     _lcl_logger_autoreleasepool_end                                            \
88 | }
89 | 
90 | #ifndef _LCL_NO_IGNORE_WARNINGS
91 | #   ifdef __clang__
92 | #   pragma clang diagnostic pop
93 | #   endif
94 | #endif
95 | 
96 | 


--------------------------------------------------------------------------------