GLib is a lower-level library that provides many useful definitions and functions, portable across different Architectures and Operating Systems:

• Definitions for basic types and their limits, standard macros, type conversions, byte order.
• Data structures and their related operations
• Memory allocation
• Warnings and assertions and message logging
• Thread abstraction
• Event Loop
• Dynamic Loading of Modules

Links:

• GLib Reference Manual
• GLib sources
• The Official GNOME 2 Developer's Guide

All the GLib basic types are included with the main header:

#include <glib.h>

The advantage of these functions over those in the standard C library is the built-in error handling. If a problem occurs during runtime, g_error() can step in to examine it.

It is also provided a useful macro to allocate a desired number of data structures:

g_new(struct_type, n_structs)

my_data = (dummy_data_type*) malloc(sizeof(dummy_data_type) * DATA_LENGTH);
if (my_data == NULL) {
    fprintf(stderr, "Couldn't allocate memory\n");
    exit(EXIT_FAILURE); // Should be called a system wide error handling routine.
}

my_data = g_new(dummy_data_type, DATA_LENGTH);

GLib has utility functions to handle two types of strings:

• Classical C Strings: gchar*
• GLib string type: GStrings

gchar strings can be passed as argument to all the string.h functions. Additionally, GLib provide the following functions:

• String Utility Functions

GString is a data type containing a pointer to the memory area containing the string chars, the length of the string and the length of the area of memory allocated for the string:

typedef struct _GString	  GString;
struct _GString {
  gchar  *str;
  gsize len;    
  gsize allocated_len;
};

• GStrings

GLib uses four runtime error logging functions, in order of the priority levels:

This utilities take parameters like printf() (a format string followed by a list of substitution parameters). There's no need to put a '\n' at the end of the format, though.

To add a signature (compile time) of the application to the log messages, it has to be used the G_LOG_DOMAIN macro.

#undef  G_LOG_DOMAIN
#define G_LOG_DOMAIN   "GLibTest"
[...]
g_message("Info message");
g_warning("Warning message");
g_critical("Critical message");
g_error("Error message");

GLibTest-Message: Info message

(process:18977): GLibTest-WARNING **: Warning message

(process:18977): GLibTest-CRITICAL **: Critical message

GLibTest-ERROR **: Error message
aborting...

In the default configuration, g_error is fatal. The function g_log_set_always_fatal can set other logging level as fatal, ie to set all warnings and critical messages as fatal:

g_log_set_always_fatal(G_LOG_LEVEL_WARNING|G_LOG_LEVEL_CRITICAL)

To facilitate an uniform logging through all the library there are also two wrapper functions to the classical print functions:

g_print()
g_printerr()

All these functions have ways to set different handlers.

g_log_set_handler()
g_set_print_handler()
g_set_printerr_handler()

The prototype of a log handler function is:

void (*GLogFunc)(const gchar    *log_domain,
                 GLogLevelFlags log_level,
                 const gchar    *message,
                 gpointer       user_data);

The Gtimer is nothing more than a stopwatch that is as accurate as your system clock. Here is a demonstration:

#include <glib.h> 
#define DURATION 200000 
 
int main(int argc, char **argv) { 
    GTimer *clock = NULL; 
    gint i; 
    gdouble elapsed_time; 
    gulong us;  /* microseconds */ 
 
    clock = g_timer_new(); 
    g_timer_start(clock); 
    g_print("Timer started.\n"); 
 
    g_print("Loop started.. "); 
    /* wasting CPU time like this is only allowed in programming examples */ 
    for (i = 0; i < DURATION; i++) { ; } 
 
    g_print("and finished.\n"); 
    g_timer_stop(clock); 
    g_print("Timer stopped.\n"); 
 
    elapsed_time = g_timer_elapsed(clock, &us); 
    g_print("Elapsed: %g s\n", elapsed_time); 
    g_print("         %ld us\n", us); 
 
    g_timer_destroy(clock); 
 
    return 0; 
}

# C Compiler settings
CC=gcc
CC_FLAGS=-O2 -g -Wall -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations 

# Header files needed by the compiler
CC_INCLUDES=-I.             \
-pthread                    \
-I/usr/include/glib-2.0     \
-I/usr/lib/glib-2.0/include

# Libraries needed by the linker 
LD_LIBS=-pthread    \
-L/usr/lib          \
-Wl,-rpath,/usr/lib \
-lglib-2.0 

# Project Files
MODULES=./main.o

# Target executable file
TARGET=exec

all: $(TARGET)

clean:
	rm -f $(TARGET) $(MODULES)

$(TARGET): $(MODULES)
	$(CC) $(CC_INCLUDES) $(CC_FLAGS) -o $@ $(MODULES) $(LD_LIBS)
	
%.o: %.c
	$(CC) $(CC_INCLUDES) $(CC_FLAGS) -c -o $*.o  $<