From 63016ce5c71019de315434de3e91adbf535d4986 Mon Sep 17 00:00:00 2001
From: Nathanael Sensfelder <SpamShield0@MultiAgentSystems.org>
Date: Tue, 31 Dec 2019 15:51:05 +0100
Subject: Still working on it...

---
 src/client.c                                 |  25 +-
 src/config/config_file.c                     | 149 ++--------
 src/config/parameters.c                      | 344 -----------------------
 src/config/parameters/parameters.c           | 406 +++++++++++++++++++++++++++
 src/config/parameters/parameters_accessors.c |  60 ++++
 src/device/axis/axis.c                       |  34 +++
 src/device/axis/axis_filter.c                | 131 +++++++++
 src/server/server.c                          |  45 ++-
 8 files changed, 689 insertions(+), 505 deletions(-)
 delete mode 100644 src/config/parameters.c
 create mode 100644 src/config/parameters/parameters.c
 create mode 100644 src/config/parameters/parameters_accessors.c
 create mode 100644 src/device/axis/axis.c
 create mode 100644 src/device/axis/axis_filter.c

(limited to 'src')

diff --git a/src/client.c b/src/client.c
index d03a768..b0459af 100644
--- a/src/client.c
+++ b/src/client.c
@@ -20,8 +20,8 @@
 /******************************************************************************/
 static int open_socket
 (
-   FILE * s [const restrict static 1],
-   const char socket_name [const restrict static 1]
+   const char socket_name [const restrict static 1],
+   FILE * s [const restrict static 1]
 )
 {
    const int old_errno = errno;
@@ -113,9 +113,16 @@ static int send_commands
          // TODO: error
       }
 
+      if (relabsd_parameters_argument_count_for(argv[i], &j) < 0)
+      {
+         RELABSD_FATAL("Unknown option '%s'.", argv[i]);
+         relabsd_parameters_print_usage(argv[0]);
+
+         return -1;
+      }
+
       for
       (
-         j = relabsd_parameters_argument_count_for(argv[i]),
          i++;
          ((j > 0) && (i < argc));
          j++, i--
@@ -161,14 +168,22 @@ int relabsd_client
 (
    const int argc,
    const char * argv [const restrict static argc],
-   struct relabsd_parameters params [const restrict static 1]
+   struct relabsd_parameters parameters [const restrict static 1]
 )
 {
    FILE * socket;
 
    RELABSD_S_DEBUG(RELABSD_DEBUG_PROGRAM_FLOW, "Started client mode.");
 
-   if (open_socket(&socket, relabsd_parameters_get_node(params)) < 0)
+   if
+   (
+      open_socket
+      (
+         relabsd_parameters_get_communication_node_name(parameters),
+         &socket
+      )
+      < 0
+   )
    {
       return -1;
    }
diff --git a/src/config/config_file.c b/src/config/config_file.c
index ad060a5..2e5ef0c 100644
--- a/src/config/config_file.c
+++ b/src/config/config_file.c
@@ -1,3 +1,4 @@
+/**** POSIX *******************************************************************/
 #include <errno.h>
 #include <string.h>
 #include <stdio.h>
@@ -6,38 +7,27 @@
 
 #include <sys/time.h>
 
-#include "error.h"
-#include "pervasive.h"
-#include "axis.h"
-#include "config.h"
+/**** RELABSD *****************************************************************/
+#include <relabsd/debug.h>
+
+#include <relabsd/config/config_file.h>
 
 #ifndef RELABSD_OPTION_MAX_SIZE
    #define RELABSD_OPTION_MAX_SIZE 64
 #endif
-/*
- * "errno is never set to zero by any system call or library function."
- * This file makes use of this, by setting it to zero and checking if
- * it was modified after calling an function (I'm guessing this is common
- * practice, but I think it's worth explaining).
- * Following the principle of least astonishment, if a function sets errno to
- * zero, it will not return before setting it back either to its previous
- * value or to a arbitrary nonzero value.
- */
 
+/******************************************************************************/
+/**** LOCAL FUNCTIONS *********************************************************/
+/******************************************************************************/
 /*
  * Returns -1 on (fatal) error,
  *          0 on EOF,
  *          1 on newline.
  */
-static int reach_next_line_or_eof (FILE * const f)
+static int reach_next_line_or_eof (FILE f [const restrict static 1])
 {
-   int prev_errno;
    char c;
 
-   prev_errno = errno;
-
-   errno = 0;
-
    c = (char) getc(f);
 
    while ((c != '\n') && c != EOF)
@@ -45,21 +35,22 @@ static int reach_next_line_or_eof (FILE * const f)
       c = (char) getc(f);
    }
 
-   if (errno != 0)
+   if (ferror(f))
    {
-      RELABSD_FATAL
+      /*
+       * The 'ferror' function's manual specifically states that it does not
+       * sets errno. There is no mention of errno in the 'getc' function's
+       * either, so I am assuming that errno cannot be used to indicate the
+       * error.
+       */
+      RELABSD_S_FATAL
       (
-         "[CONFIG] Error while attempting to reach EOF or next line: %s.",
-         strerror(errno)
+         "[CONFIG] Error while attempting to reach EOF or next line: %s."
       );
 
-      errno = prev_errno;
-
       return -1;
    }
 
-   errno = prev_errno;
-
    if (c == EOF)
    {
       return 0;
@@ -643,6 +634,7 @@ static int parse_options
 
    return 0;
 }
+
 int relabsd_config_parse
 (
    struct relabsd_config * const conf,
@@ -681,106 +673,6 @@ int relabsd_config_parse
    return 0;
 }
 
-static int direct_filter
-(
-   struct relabsd_config_axis * const axis,
-   int * const value
-)
-{
-   if (abs(*value - axis->previous_value) <= axis->fuzz)
-   {
-      if (axis->option[RELABSD_REAL_FUZZ_OPTION])
-      {
-         axis->previous_value = *value;
-      }
-
-      return -1;
-   }
-
-   if (*value < axis->min)
-   {
-      *value = axis->min;
-   }
-   else if (*value > axis->max)
-   {
-      *value = axis->max;
-   }
-   else if (abs(*value) <= axis->flat)
-   {
-      *value = 0;
-   }
-
-   if (*value == axis->previous_value)
-   {
-      return -1;
-   }
-
-   axis->previous_value = *value;
-
-   return 1;
-}
-
-static int rel_to_abs_filter
-(
-   struct relabsd_config_axis * const axis,
-   int * const value
-)
-{
-   long int guard;
-
-   guard = (((long int) axis->previous_value) + ((long int) *value));
-
-   if (guard < ((long int) INT_MIN))
-   {
-      guard = ((long int) INT_MIN);
-   }
-   else if (guard > ((long int) INT_MAX))
-   {
-      guard = ((long int) INT_MAX);
-   }
-
-   *value = (int) guard;
-
-   if (axis->option[RELABSD_FRAMED_OPTION])
-   {
-      if (*value < axis->min)
-      {
-         *value = axis->min;
-      }
-      else if (*value > axis->max)
-      {
-         *value = axis->max;
-      }
-
-      if (*value == axis->previous_value)
-      {
-         return 0;
-      }
-
-      axis->previous_value = *value;
-
-      return 1;
-   }
-   else
-   {
-      if (*value == axis->previous_value)
-      {
-         return 0;
-      }
-
-      axis->previous_value = *value;
-
-      if ((*value < axis->min) || (*value > axis->max))
-      {
-         return 0;
-      }
-      else
-      {
-         return 1;
-      }
-   }
-}
-
 int relabsd_config_filter
 (
    struct relabsd_config * const conf,
@@ -805,6 +697,9 @@ int relabsd_config_filter
    }
 }
 
+/******************************************************************************/
+/**** EXPORTED FUNCTIONS ******************************************************/
+/******************************************************************************/
 void relabsd_config_get_absinfo
 (
    const struct relabsd_config * const conf,
diff --git a/src/config/parameters.c b/src/config/parameters.c
deleted file mode 100644
index 5e79fa2..0000000
--- a/src/config/parameters.c
+++ /dev/null
@@ -1,344 +0,0 @@
-/**** POSIX *******************************************************************/
-#include <limits.h>
-
-/**** RELABSD *****************************************************************/
-#include <relabsd/config.h>
-#include <relabsd/debug.h>
-
-#include <relabsd/device/axis.h>
-
-#include <relabsd/util/string.h>
-
-#include <relabsd/config/parameters.h>
-
-/******************************************************************************/
-/**** LOCAL FUNCTIONS *********************************************************/
-/******************************************************************************/
-static void print_usage (const char exec [const restrict static 1])
-{
-   printf
-   (
-      "USAGE: %s <MODE> [<OPTION>+]\n\n"
-
-      "<MODE>:\n"
-      "\t[-? | --compatible] <physical_device_file>:\n"
-         "\t\tDevice compatibility test.\n\n"
-
-      "\t[-c | --client] <server_file>:\n"
-         "\t\tSends the commands to a given server instance.\n\n"
-
-      "\t[-s | --server] <server_file> <physical_device_file>:\n"
-         "\t\tCreates a named server instance.\n\n"
-
-      "\t[-1 | --self] <physical_device_file>:\n"
-         "\t\tCreates a unnamed server instance.\n\n"
-
-      "<OPTION>:\n"
-      "\t[-d | --daemon]:\n"
-         "\t\tRuns server instance in the background.\n\n"
-
-      "\t[-n | --name] <relabsd_device_name>:\n"
-         "\t\tNames the virtual device.\n\n"
-
-      "\t[-t | --timeout] <timeout_in_ms>:\n"
-         "\t\tSets a zeroing timeout (0 to disable).\n\n"
-
-      "\t[-a | --axis] <name> <min> <max> <fuzz> <flat> <resolution> "
-         "<options>:\n"
-         "\t\t(Re)defines an axis.\n\n"
-
-      "\t[-m | --mod-axis] <name> <min> <max> <fuzz> <flat> <resolution> "
-         "<signed_options>:\n"
-         "\t\tModifies an axis (use + and - signs for the options).\n\n"
-
-      "\t[-f | --config] <config_file>"
-         "<options>:\n"
-         "\t\t(Re)defines an axis.\n",
-      exec
-   );
-}
-
-static int parse_axis
-(
-   const int argc,
-   const char * argv [const restrict static argc],
-   struct relabsd_axis axes [const restrict static RELABSD_AXIS_AXES_COUNT]
-)
-{
-   enum relabsd_axis_name axis_name;
-   struct relabsd_axis *axis;
-
-   if (argc < 7)
-   {
-      RELABSD_S_FATAL("7 parameters must be provided for axis definition.");
-
-      return -1;
-   }
-
-   axis_index = relabsd_axis_from_name(argv[0]);
-
-   if (axis_index == RELABSD_UNKNOWN)
-   {
-      RELABSD_FATAL("Unknown axis \"%s\".", argv[0]);
-
-      return -1;
-   }
-
-   axis = (axes + axis_index);
-
-   if (relabsd_util_parse_int(argv[1], INT_MIN, INT_MAX, &(axis->min)) < 0)
-   {
-      RELABSD_FATAL("Invalid <min> value for axis \"%s\".", argv[0]);
-
-      return -1;
-   }
-
-   if (relabsd_util_parse_int(argv[2], INT_MIN, INT_MAX, &(axis->max)) < 0)
-   {
-      RELABSD_FATAL("Invalid <max> value for axis \"%s\".", argv[0]);
-
-      return -1;
-   }
-
-   if (relabsd_util_parse_int(argv[3], INT_MIN, INT_MAX, &(axis->fuzz)) < 0)
-   {
-      RELABSD_FATAL("Invalid <fuzz> value for axis \"%s\".", argv[0]);
-
-      return -1;
-   }
-
-   if (relabsd_util_parse_int(argv[4], INT_MIN, INT_MAX, &(axis->flat)) < 0)
-   {
-      RELABSD_FATAL("Invalid <flat> value for axis \"%s\".", argv[0]);
-
-      return -1;
-   }
-
-   if
-   (
-      relabsd_util_parse_int(argv[5], INT_MIN, INT_MAX, &(axis->resolution))
-      < 0
-   )
-   {
-      RELABSD_FATAL("Invalid <resolution> value for axis \"%s\".", argv[0]);
-
-      return -1;
-   }
-
-   return 0;
-}
-
-/******************************************************************************/
-/**** EXPORTED FUNCTIONS ******************************************************/
-/******************************************************************************/
-int relabsd_parameters_parse_execution_mode
-(
-   const int argc,
-   const char * argv [const restrict static argc],
-   struct relabsd_parameters params [const restrict static 1]
-)
-{
-   RELABSD_S_DEBUG(RELABSD_DEBUG_PROGRAM_FLOW, "Parsing exec mode...");
-
-   if (argc < 3)
-   {
-      print_usage(argv[0]);
-
-      return -1;
-   }
-
-   if
-   (
-      RELABSD_STRING_EQUALS("-?", argv[1])
-      || RELABSD_STRING_EQUALS("--compatibility", argv[1])
-   )
-   {
-      params->mode = RELABSD_PARAMETERS_COMPATIBILITY_TEST_MODE;
-      params->physical_device_name = argv[2];
-      params->read_argc = 2;
-   }
-   else if
-   (
-      RELABSD_STRING_EQUALS("-c", argv[1])
-      || RELABSD_STRING_EQUALS("--client", argv[1])
-   )
-   {
-      params->mode = RELABSD_PARAMETERS_CLIENT_MODE;
-      params->communication_node_name = argv[2];
-      params->physical_device_name = (char *) NULL;
-      params->read_argc = 2;
-   }
-   else if
-   (
-      RELABSD_STRING_EQUALS("-s", argv[1])
-      || RELABSD_STRING_EQUALS("--server", argv[1])
-   )
-   {
-      params->mode = RELABSD_PARAMETERS_SERVER_MODE;
-      params->communication_node_name = argv[2];
-      params->physical_device_name = argv[3];
-      params->read_argc = 3;
-   }
-   else if
-   (
-      RELABSD_STRING_EQUALS("-1", argv[1])
-      || RELABSD_STRING_EQUALS("--self", argv[1])
-   )
-   {
-      params->mode = RELABSD_PARAMETERS_SERVER_MODE;
-      params->communication_node_name = (char *) NULL;
-      params->physical_device_name = argv[2];
-      params->read_argc = 2;
-   }
-   else
-   {
-      print_usage(argv[0]);
-
-      return -1;
-   }
-
-   RELABSD_S_DEBUG(RELABSD_DEBUG_PROGRAM_FLOW, "Parsed exec mode.");
-
-   return 0;
-}
-
-int relabsd_parameters_parse_options
-(
-   const int argc,
-   const char * argv [const restrict static argc],
-   struct relabsd_parameters params [const restrict static 1]
-)
-{
-   int i;
-
-   RELABSD_S_DEBUG(RELABSD_DEBUG_PROGRAM_FLOW, "Parsing options...");
-
-   set_default_options(params);
-
-   /*
-    * i = (params->read_argc + 1) because reading 2 params is actually reaching
-    * the [2] element of the array, since the [0] element is the executable
-    * name.
-    */
-   for (i = (params->read_argc + 1); i < argc; ++i)
-   {
-      if
-      (
-         RELABSD_STRING_EQUALS("-d", argv[i])
-         || RELABSD_STRING_EQUALS("--daemon", argv[i])
-      )
-      {
-         params->run_as_daemon = 1;
-
-         if (params->node == ((char *) NULL))
-         {
-            RELABSD_S_WARNING
-            (
-               "Running as a daemon without any communication file."
-            );
-         }
-      }
-      else if
-      (
-         RELABSD_STRING_EQUALS("-n", argv[i])
-         || RELABSD_STRING_EQUALS("--name", argv[i])
-      )
-      {
-         if (argc == i)
-         {
-            RELABSD_FATAL("Missing value for \"%s\" <OPTION>.", argv[i]);
-
-            return -1;
-         }
-
-         ++i;
-         params->name = argv[i];
-      }
-      else if
-      (
-         RELABSD_STRING_EQUALS("-t", argv[i])
-         || RELABSD_STRING_EQUALS("--timeout", argv[i])
-      )
-      {
-         if (argc == i)
-         {
-            RELABSD_FATAL("Missing value for \"%s\" <OPTION>.", argv[i]);
-            print_usage(argv[0]);
-
-            return -1;
-         }
-
-         ++i;
-
-         if
-         (
-            relabsd_util_parse_int(argv[i], 0, INT_MAX, &(params->timeout))
-            < 0
-         )
-         {
-            RELABSD_FATAL
-            (
-               "Invalid value for \"%s\" <OPTION> (valid range is [%d, %d]).",
-               argv[i - 1],
-               0,
-               INT_MAX
-            );
-
-            print_usage(argv[0]);
-
-            return -1;
-         }
-      }
-      else if
-      (
-         RELABSD_STRING_EQUALS("-a", argv[i])
-         || RELABSD_STRING_EQUALS("--axis", argv[i])
-      )
-      {
-         if (argc == i)
-         {
-            RELABSD_FATAL("Missing values for \"%s\" <OPTION>.", argv[i]);
-            print_usage(argv[0]);
-
-            return -1;
-         }
-
-         ++i;
-
-         if (parse_axis((argc - i), (argv + i), params->axes) < 0)
-         {
-            print_usage(argv[0]);
-
-            return -1;
-         }
-      }
-      else if
-      (
-         RELABSD_STRING_EQUALS("-f", argv[i])
-         || RELABSD_STRING_EQUALS("--config", argv[i])
-      )
-      {
-         if (argc == i)
-         {
-            RELABSD_FATAL("Missing value for \"%s\" <OPTION>.", argv[i]);
-            print_usage(argv[0]);
-
-            return -1;
-         }
-
-         ++i;
-         params->config_file = argv[i];
-      }
-      else
-      {
-         RELABSD_FATAL("Unknown <OPTION> \"%s\".", argv[i]);
-         print_usage(argv[0]);
-
-         return -1;
-      }
-   }
-
-   RELABSD_S_DEBUG(RELABSD_DEBUG_PROGRAM_FLOW, "Parsed options.");
-
-   return 0;
-}
diff --git a/src/config/parameters/parameters.c b/src/config/parameters/parameters.c
new file mode 100644
index 0000000..c8db4fa
--- /dev/null
+++ b/src/config/parameters/parameters.c
@@ -0,0 +1,406 @@
+/**** POSIX *******************************************************************/
+#include <limits.h>
+
+/**** RELABSD *****************************************************************/
+#include <relabsd/config.h>
+#include <relabsd/debug.h>
+
+#include <relabsd/device/axis.h>
+
+#include <relabsd/util/string.h>
+
+#include <relabsd/config/parameters.h>
+
+/******************************************************************************/
+/**** LOCAL FUNCTIONS *********************************************************/
+/******************************************************************************/
+static int parse_axis
+(
+   const int argc,
+   const char * argv [const restrict static argc],
+   struct relabsd_axis axes [const restrict static RELABSD_AXIS_AXES_COUNT]
+)
+{
+   enum relabsd_axis_name axis_name;
+   struct relabsd_axis *axis;
+
+   if (argc < 7)
+   {
+      RELABSD_S_FATAL("7 parameters must be provided for axis definition.");
+
+      return -1;
+   }
+
+   axis_index = relabsd_axis_from_name(argv[0]);
+
+   if (axis_index == RELABSD_UNKNOWN)
+   {
+      RELABSD_FATAL("Unknown axis \"%s\".", argv[0]);
+
+      return -1;
+   }
+
+   axis = (axes + axis_index);
+
+   if (relabsd_util_parse_int(argv[1], INT_MIN, INT_MAX, &(axis->min)) < 0)
+   {
+      RELABSD_FATAL("Invalid <min> value for axis \"%s\".", argv[0]);
+
+      return -1;
+   }
+
+   if (relabsd_util_parse_int(argv[2], INT_MIN, INT_MAX, &(axis->max)) < 0)
+   {
+      RELABSD_FATAL("Invalid <max> value for axis \"%s\".", argv[0]);
+
+      return -1;
+   }
+
+   if (relabsd_util_parse_int(argv[3], INT_MIN, INT_MAX, &(axis->fuzz)) < 0)
+   {
+      RELABSD_FATAL("Invalid <fuzz> value for axis \"%s\".", argv[0]);
+
+      return -1;
+   }
+
+   if (relabsd_util_parse_int(argv[4], INT_MIN, INT_MAX, &(axis->flat)) < 0)
+   {
+      RELABSD_FATAL("Invalid <flat> value for axis \"%s\".", argv[0]);
+
+      return -1;
+   }
+
+   if
+   (
+      relabsd_util_parse_int(argv[5], INT_MIN, INT_MAX, &(axis->resolution))
+      < 0
+   )
+   {
+      RELABSD_FATAL("Invalid <resolution> value for axis \"%s\".", argv[0]);
+
+      return -1;
+   }
+
+   return 0;
+}
+
+/******************************************************************************/
+/**** EXPORTED FUNCTIONS ******************************************************/
+/******************************************************************************/
+int relabsd_parameters_parse_execution_mode
+(
+   const int argc,
+   const char * argv [const restrict static argc],
+   struct relabsd_parameters parameters [const restrict static 1]
+)
+{
+   RELABSD_S_DEBUG(RELABSD_DEBUG_PROGRAM_FLOW, "Parsing exec mode...");
+
+   if (argc < 3)
+   {
+      relabsd_parameters_print_usage(argv[0]);
+
+      return -1;
+   }
+
+   if
+   (
+      RELABSD_STRING_EQUALS("-?", argv[1])
+      || RELABSD_STRING_EQUALS("--compatibility", argv[1])
+   )
+   {
+      parameters->mode = RELABSD_PARAMETERS_COMPATIBILITY_TEST_MODE;
+      parameters->physical_device_name = argv[2];
+      parameters->read_argc = 2;
+   }
+   else if
+   (
+      RELABSD_STRING_EQUALS("-c", argv[1])
+      || RELABSD_STRING_EQUALS("--client", argv[1])
+   )
+   {
+      parameters->mode = RELABSD_PARAMETERS_CLIENT_MODE;
+      parameters->communication_node_name = argv[2];
+      parameters->physical_device_name = (const char *) NULL;
+      parameters->read_argc = 2;
+   }
+   else if
+   (
+      RELABSD_STRING_EQUALS("-s", argv[1])
+      || RELABSD_STRING_EQUALS("--server", argv[1])
+   )
+   {
+      parameters->mode = RELABSD_PARAMETERS_SERVER_MODE;
+      parameters->communication_node_name = argv[2];
+      parameters->physical_device_name = argv[3];
+      parameters->read_argc = 3;
+   }
+   else if
+   (
+      RELABSD_STRING_EQUALS("-1", argv[1])
+      || RELABSD_STRING_EQUALS("--self", argv[1])
+   )
+   {
+      parameters->mode = RELABSD_PARAMETERS_SERVER_MODE;
+      parameters->communication_node_name = (char *) NULL;
+      parameters->physical_device_name = argv[2];
+      parameters->read_argc = 2;
+   }
+   else
+   {
+      relabsd_parameters_print_usage(argv[0]);
+
+      return -1;
+   }
+
+   RELABSD_S_DEBUG(RELABSD_DEBUG_PROGRAM_FLOW, "Parsed exec mode.");
+
+   return 0;
+}
+
+int relabsd_parameters_parse_options
+(
+   const int argc,
+   const char * const argv [const restrict static argc],
+   struct relabsd_parameters parameters [const restrict static 1]
+)
+{
+   int i;
+
+   RELABSD_S_DEBUG(RELABSD_DEBUG_PROGRAM_FLOW, "Parsing options...");
+
+   relabsd_parameters_initialize_options(parameters);
+
+   /*
+    * i = (params->read_argc + 1) because reading 2 params is actually reaching
+    * the [2] element of the array, since the [0] element is the executable
+    * name.
+    */
+   for (i = (params->read_argc + 1); i < argc; ++i)
+   {
+      if
+      (
+         RELABSD_STRING_EQUALS("-d", argv[i])
+         || RELABSD_STRING_EQUALS("--daemon", argv[i])
+      )
+      {
+         params->run_as_daemon = 1;
+
+         if (params->node == ((char *) NULL))
+         {
+            RELABSD_S_WARNING
+            (
+               "Running as a daemon without any communication file."
+            );
+         }
+      }
+      else if
+      (
+         RELABSD_STRING_EQUALS("-n", argv[i])
+         || RELABSD_STRING_EQUALS("--name", argv[i])
+      )
+      {
+         if (argc == i)
+         {
+            RELABSD_FATAL("Missing value for \"%s\" <OPTION>.", argv[i]);
+
+            return -1;
+         }
+
+         ++i;
+         params->device_name = argv[i];
+      }
+      else if
+      (
+         RELABSD_STRING_EQUALS("-t", argv[i])
+         || RELABSD_STRING_EQUALS("--timeout", argv[i])
+      )
+      {
+         if (argc == i)
+         {
+            RELABSD_FATAL("Missing value for \"%s\" <OPTION>.", argv[i]);
+            relabsd_parameters_print_usage(argv[0]);
+
+            return -1;
+         }
+
+         ++i;
+
+         if
+         (
+            relabsd_util_parse_int(argv[i], 0, INT_MAX, &(params->timeout))
+            < 0
+         )
+         {
+            RELABSD_FATAL
+            (
+               "Invalid value for \"%s\" <OPTION> (valid range is [%d, %d]).",
+               argv[i - 1],
+               0,
+               INT_MAX
+            );
+
+            relabsd_parameters_print_usage(argv[0]);
+
+            return -1;
+         }
+      }
+      else if
+      (
+         RELABSD_STRING_EQUALS("-a", argv[i])
+         || RELABSD_STRING_EQUALS("--axis", argv[i])
+      )
+      {
+         if (argc == i)
+         {
+            RELABSD_FATAL("Missing values for \"%s\" <OPTION>.", argv[i]);
+            relabsd_parameters_print_usage(argv[0]);
+
+            return -1;
+         }
+
+         ++i;
+
+         if (parse_axis((argc - i), (argv + i), params->axes) < 0)
+         {
+            relabsd_parameters_print_usage(argv[0]);
+
+            return -1;
+         }
+      }
+      else if
+      (
+         RELABSD_STRING_EQUALS("-f", argv[i])
+         || RELABSD_STRING_EQUALS("--config", argv[i])
+      )
+      {
+         if (argc == i)
+         {
+            RELABSD_FATAL("Missing value for \"%s\" <OPTION>.", argv[i]);
+            relabsd_parameters_print_usage(argv[0]);
+
+            return -1;
+         }
+
+         ++i;
+         params->configuration_file = argv[i];
+      }
+      else
+      {
+         RELABSD_FATAL("Unknown <OPTION> \"%s\".", argv[i]);
+         relabsd_parameters_print_usage(argv[0]);
+
+         return -1;
+      }
+   }
+
+   RELABSD_S_DEBUG(RELABSD_DEBUG_PROGRAM_FLOW, "Parsed options.");
+
+   return 0;
+}
+
+int relabsd_parameters_argument_count_for
+(
+   const char option [const restrict static 1],
+   int result [const restrict static 1]
+)
+{
+   if
+   (
+      RELABSD_STRING_EQUALS("-n", option)
+      || RELABSD_STRING_EQUALS("--name", option)
+   )
+   {
+      *result = 0;
+   }
+   else if
+   (
+      RELABSD_STRING_EQUALS("-n", option)
+      || RELABSD_STRING_EQUALS("--name", option)
+   )
+   {
+      *result = 1;
+   }
+   else if
+   (
+      RELABSD_STRING_EQUALS("-t", option)
+      || RELABSD_STRING_EQUALS("--timeout", option)
+   )
+   {
+      *result = 1;
+   }
+   else if
+   (
+      RELABSD_STRING_EQUALS("-a", option)
+      || RELABSD_STRING_EQUALS("--axis", option)
+   )
+   {
+      *result = 7;
+   }
+   else if
+   (
+      RELABSD_STRING_EQUALS("-m", option)
+      || RELABSD_STRING_EQUALS("--mod-axis", option)
+   )
+   {
+      *result = 7;
+   }
+   else if
+   (
+      RELABSD_STRING_EQUALS("-f", option)
+      || RELABSD_STRING_EQUALS("--config", option)
+   )
+   {
+      *result = 1;
+   }
+   else
+   {
+      return -1;
+   }
+
+   return 0;
+}
+
+void relabsd_parameters_print_usage (const char exec [const restrict static 1])
+{
+   printf
+   (
+      "USAGE: %s <MODE> [<OPTION>+]\n\n"
+
+      "<MODE>:\n"
+      "\t[-? | --compatible] <physical_device_file>:\n"
+         "\t\tDevice compatibility test.\n\n"
+
+      "\t[-c | --client] <server_file>:\n"
+         "\t\tSends the commands to a given server instance.\n\n"
+
+      "\t[-s | --server] <server_file> <physical_device_file>:\n"
+         "\t\tCreates a named server instance.\n\n"
+
+      "\t[-1 | --self] <physical_device_file>:\n"
+         "\t\tCreates a unnamed server instance.\n\n"
+
+      "<OPTION>:\n"
+      "\t[-d | --daemon]:\n"
+         "\t\tRuns server instance in the background.\n\n"
+
+      "\t[-n | --name] <relabsd_device_name>:\n"
+         "\t\tNames the virtual device.\n\n"
+
+      "\t[-t | --timeout] <timeout_in_ms>:\n"
+         "\t\tSets a zeroing timeout (0 to disable).\n\n"
+
+      "\t[-a | --axis] <name> <min> <max> <fuzz> <flat> <resolution> "
+         "<options>:\n"
+         "\t\t(Re)defines an axis.\n\n"
+
+      "\t[-m | --mod-axis] <name> <min> <max> <fuzz> <flat> <resolution> "
+         "<signed_options>:\n"
+         "\t\tModifies an axis (use + and - signs for the options).\n\n"
+
+      "\t[-f | --config] <config_file>"
+         "<options>:\n"
+         "\t\t(Re)defines an axis.\n",
+      exec
+   );
+}
diff --git a/src/config/parameters/parameters_accessors.c b/src/config/parameters/parameters_accessors.c
new file mode 100644
index 0000000..e53cfe0
--- /dev/null
+++ b/src/config/parameters/parameters_accessors.c
@@ -0,0 +1,60 @@
+#include <relabsd/config/parameters.h>
+
+/******************************************************************************/
+/**** LOCAL FUNCTIONS *********************************************************/
+/******************************************************************************/
+
+/******************************************************************************/
+/**** EXPORTED FUNCTIONS ******************************************************/
+/******************************************************************************/
+void relabsd_parameters_initialize_options
+(
+   const struct relabsd_parameters parameters [const restrict static 1]
+)
+{
+   parameters->run_as_daemon = 0;
+   parameters->communication_node_name = (const char *) NULL;
+   parameters->device_name = (const char *) NULL;
+   parameters->physical_device_file_name = (const char *) NULL;
+   parameters->configuration_file = (const char *) NULL;
+}
+
+int relabsd_parameters_get_run_as_daemon
+(
+   const struct relabsd_parameters parameters [const restrict static 1]
+)
+{
+   return parameters->run_as_daemon;
+}
+
+const char * relabsd_parameters_get_communication_node_name
+(
+   const struct relabsd_parameters parameters [const restrict static 1]
+)
+{
+   return parameters->communication_node_name;
+}
+
+const char * relabsd_parameters_get_device_name
+(
+   const struct relabsd_parameters parameters [const restrict static 1]
+)
+{
+   return parameters->device_name;
+}
+
+const char * relabsd_parameters_get_physical_device_file_name
+(
+   const struct relabsd_parameters parameters [const restrict static 1]
+)
+{
+   return parameters->physical_device_file_name;
+}
+
+enum relabsd_parameters_run_mode relabsd_parameters_get_execution_mode
+(
+   const struct relabsd_parameters parameters [const restrict static 1]
+)
+{
+   return parameters->mode;
+}
diff --git a/src/device/axis/axis.c b/src/device/axis/axis.c
new file mode 100644
index 0000000..75afad8
--- /dev/null
+++ b/src/device/axis/axis.c
@@ -0,0 +1,34 @@
+/**** POSIX *******************************************************************/
+#include <string.h>
+
+/**** RELABSD *****************************************************************/
+#include <relabsd/device/axis.h>
+
+/******************************************************************************/
+/**** LOCAL FUNCTIONS *********************************************************/
+/******************************************************************************/
+
+/******************************************************************************/
+/**** EXPORTED FUNCTIONS ******************************************************/
+/******************************************************************************/
+void relabsd_axis_initialize
+(
+   struct relabsd_axis axis [const restrict static 1]
+)
+{
+   (void) memset(axis, 0, sizeof(struct relabsd_axis));
+}
+
+void relabsd_axis_to_absinfo
+(
+   struct relabsd_axis axis [const restrict static 1]
+   struct input_absinfo absinfo [const restrict static 1]
+)
+{
+   absinfo->value = (__s32) 0;
+   absinfo->minimum = (__s32) axis->min;
+   absinfo->maximum = (__s32) axis->max;
+   absinfo->fuzz = (__s32) axis->fuzz;
+   absinfo->flat = (__s32) axis->flat;
+   absinfo->resolution = (__s32) axis->resolution;
+}
diff --git a/src/device/axis/axis_filter.c b/src/device/axis/axis_filter.c
new file mode 100644
index 0000000..295a7f6
--- /dev/null
+++ b/src/device/axis/axis_filter.c
@@ -0,0 +1,131 @@
+/**** RELABSD *****************************************************************/
+#include <relabsd/device/axis.h>
+
+/******************************************************************************/
+/**** LOCAL FUNCTIONS *********************************************************/
+/******************************************************************************/
+static int direct_filter
+(
+   struct relabsd_config_axis * const axis,
+   int * const value
+)
+{
+   if (abs(*value - axis->previous_value) <= axis->fuzz)
+   {
+      if (axis->option[RELABSD_REAL_FUZZ_OPTION])
+      {
+         axis->previous_value = *value;
+      }
+
+      return -1;
+   }
+
+   if (*value < axis->min)
+   {
+      *value = axis->min;
+   }
+   else if (*value > axis->max)
+   {
+      *value = axis->max;
+   }
+   else if (abs(*value) <= axis->flat)
+   {
+      *value = 0;
+   }
+
+   if (*value == axis->previous_value)
+   {
+      return -1;
+   }
+
+   axis->previous_value = *value;
+
+   return 1;
+}
+
+static int rel_to_abs_filter
+(
+   struct relabsd_config_axis * const axis,
+   int * const value
+)
+{
+   long int guard;
+
+   guard = (((long int) axis->previous_value) + ((long int) *value));
+
+   if (guard < ((long int) INT_MIN))
+   {
+      guard = ((long int) INT_MIN);
+   }
+   else if (guard > ((long int) INT_MAX))
+   {
+      guard = ((long int) INT_MAX);
+   }
+
+   *value = (int) guard;
+
+   if (axis->option[RELABSD_FRAMED_OPTION])
+   {
+      if (*value < axis->min)
+      {
+         *value = axis->min;
+      }
+      else if (*value > axis->max)
+      {
+         *value = axis->max;
+      }
+
+      if (*value == axis->previous_value)
+      {
+         return 0;
+      }
+
+      axis->previous_value = *value;
+
+      return 1;
+   }
+   else
+   {
+      if (*value == axis->previous_value)
+      {
+         return 0;
+      }
+
+      axis->previous_value = *value;
+
+      if ((*value < axis->min) || (*value > axis->max))
+      {
+         return 0;
+      }
+      else
+      {
+         return 1;
+      }
+   }
+}
+
+/******************************************************************************/
+/**** EXPORTED FUNCTIONS ******************************************************/
+/******************************************************************************/
+int relabsd_axis_filter_new_value
+(
+   struct relabsd_axis axis [const restrict static 1],
+   int value [const restrict static 1]
+)
+{
+   if (!(axis->is_enabled))
+   {
+      return;
+   }
+
+   /* TODO: handle conf->axis[axis].resolution */
+
+   if (axis->flag[RELABSD_DIRECT_OPTION])
+   {
+      return direct_filter(axis, value);
+   }
+   else
+   {
+      return rel_to_abs_filter(axis, value);
+   }
+}
diff --git a/src/server/server.c b/src/server/server.c
index ddd9bdf..d6678d2 100644
--- a/src/server/server.c
+++ b/src/server/server.c
@@ -8,19 +8,19 @@
 /******************************************************************************/
 /**** LOCAL FUNCTIONS *********************************************************/
 /******************************************************************************/
-int initialize
+static int initialize
 (
    struct relabsd_server server [const restrict static 1],
-   struct relabsd_parameters params [const static 1]
+   struct relabsd_parameters parameters [const static 1]
 )
 {
-   server->parameters = params;
+   server->parameters = parameters;
 
    if
    (
       relabsd_physical_device_open
       (
-         relabsd_parameters_get_physical_device_name(params),
+         relabsd_parameters_get_physical_device_name(parameters),
          &(server->physical_device)
       )
       < 0
@@ -29,15 +29,7 @@ int initialize
       return -1;
    }
 
-   if
-   (
-      relabsd_virtual_device_create
-      (
-         relabsd_parameters_get_virtual_device_name(params),
-         &(server->virtual_device)
-      )
-      < 0
-   )
+   if (relabsd_virtual_device_create(parameters, &(server->virtual_device)) < 0)
    {
       relabsd_physical_device_close(&(server->physical_device));
 
@@ -46,8 +38,11 @@ int initialize
 
    if
    (
-      (relabsd_parameters_get_communication_node(params) != ((...) NULL))
-      && (relabsd_server_spawn_communication_node(server) < 0)
+      (
+         relabsd_parameters_get_communication_node_name(parameters)
+         != ((char *) NULL)
+      )
+      && (relabsd_server_create_communication_thread(&server) < 0)
    )
    {
       relabsd_virtual_device_destroy(&(server->virtual_device));
@@ -56,19 +51,14 @@ int initialize
       return -3;
    }
 
-   if (relabsd_parameters_get_communication_node(params) != ((char *) NULL))
-   {
-      relabsd_server_create_communication_thread(&server);
-   }
-
    return 0;
 }
 
-void finalize (struct relabsd_server server [const static 1])
+static void finalize (struct relabsd_server server [const static 1])
 {
    if
    (
-      relabsd_parameters_get_communication_node(server->parameters)
+      relabsd_parameters_get_communication_node_name(server->parameters)
       != ((char *) NULL)
    )
    {
@@ -77,8 +67,6 @@ void finalize (struct relabsd_server server [const static 1])
 
    relabsd_virtual_device_destroy(&(server->virtual_device));
    relabsd_physical_device_close(&(server->physical_device));
-
-   return 0;
 }
 
 /******************************************************************************/
@@ -88,34 +76,33 @@ int relabsd_server
 (
    const int argc,
    const char * const argv [const restrict static argc],
-   struct relabsd_parameters params [const static 1]
+   struct relabsd_parameters parameters [const static 1]
 )
 {
    struct relabsd_server server;
 
    RELABSD_S_DEBUG(RELABSD_DEBUG_PROGRAM_FLOW, "Started server mode.");
 
-   if (relabsd_parameters_parse_options(argc, argv, params) < 0)
+   if (relabsd_parameters_parse_options(argc, argv, parameters) < 0)
    {
       return -1;
    }
 
    if
    (
-      (relabsd_parameters_run_as_daemon(params))
+      relabsd_parameters_get_run_as_daemon(parameters)
       && (relabsd_server_create_daemon() < 0)
    )
    {
       return -2;
    }
 
-   (void) initialize(&server, params);
+   (void) initialize(&server, parameters);
 
    (void) relabsd_server_conversion_loop(&server);
 
    finalize(&server);
 
-
    RELABSD_S_DEBUG(RELABSD_DEBUG_PROGRAM_FLOW, "Completed server mode.");
 
    return 0;
-- 
cgit v1.2.3-70-g09d2