qmckl/org/qmckl_error.org

#+TITLE: Error handling
#+SETUPFILE: ../tools/theme.setup
#+INCLUDE: ../tools/lib.org

* Headers                                                         :noexport:

   #+begin_src c :tangle (eval h_private_type)
#ifndef QMCKL_ERROR_HPT
#define QMCKL_ERROR_HPT
   #+end_src

   #+begin_src c :tangle (eval c)
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef HAVE_STDINT_H
#include <stdint.h>
#elif HAVE_INTTYPES_H
#include <inttypes.h>
#endif

#include <string.h>
#include <assert.h>
#include <pthread.h>
#include <errno.h>

#include "qmckl.h"
#include "qmckl_context_private_type.h"
   #+end_src

   #+begin_src c :tangle (eval c_test) :noweb yes
#include <string.h>
#include <stdio.h>
#include "qmckl.h"
#include "assert.h"
#include "qmckl_error_private_type.h"
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
int main() {
  qmckl_context context;
  context = qmckl_context_create();

   #+end_src

   #+end_src

* -
:PROPERTIES:
:UNNUMBERED: t
:END:

   The library should never make the calling programs abort, nor
   perform any input/output operations. This decision has to be taken
   by the developer of the code calling the library.

   All the functions return with an exit code, defined as
   #+NAME: type-exit-code
   #+begin_src c :comments org :tangle (eval h_type)
typedef int32_t qmckl_exit_code;
   #+end_src


  #+begin_src f90 :comments org :tangle (eval fh_type) :exports none
      integer  , parameter :: qmckl_exit_code = c_int32_t
  #+end_src

   The exit code returns the completion status of the function to the
   calling program. When a function call completed successfully,
 ~QMCKL_SUCCESS~ is returned. If one of the functions of
   the library fails to complete the requested task, an appropriate
   error code is returned to the program.

   Here is the complete list of exit codes.

   #+NAME: table-exit-codes
   | Macro                       | Code | Description            |
   |-----------------------------+------+------------------------|
   | ~QMCKL_SUCCESS~             |    0 | 'Success'              |
   | ~QMCKL_INVALID_ARG_1~       |    1 | 'Invalid argument 1'   |
   | ~QMCKL_INVALID_ARG_2~       |    2 | 'Invalid argument 2'   |
   | ~QMCKL_INVALID_ARG_3~       |    3 | 'Invalid argument 3'   |
   | ~QMCKL_INVALID_ARG_4~       |    4 | 'Invalid argument 4'   |
   | ~QMCKL_INVALID_ARG_5~       |    5 | 'Invalid argument 5'   |
   | ~QMCKL_INVALID_ARG_6~       |    6 | 'Invalid argument 6'   |
   | ~QMCKL_INVALID_ARG_7~       |    7 | 'Invalid argument 7'   |
   | ~QMCKL_INVALID_ARG_8~       |    8 | 'Invalid argument 8'   |
   | ~QMCKL_INVALID_ARG_9~       |    9 | 'Invalid argument 9'   |
   | ~QMCKL_INVALID_ARG_10~      |   10 | 'Invalid argument 10'  |
   | ~QMCKL_INVALID_ARG_11~      |   11 | 'Invalid argument 11'  |
   | ~QMCKL_INVALID_ARG_12~      |   12 | 'Invalid argument 12'  |
   | ~QMCKL_INVALID_ARG_13~      |   13 | 'Invalid argument 13'  |
   | ~QMCKL_INVALID_ARG_14~      |   14 | 'Invalid argument 14'  |
   | ~QMCKL_INVALID_ARG_15~      |   15 | 'Invalid argument 15'  |
   | ~QMCKL_INVALID_ARG_16~      |   16 | 'Invalid argument 16'  |
   | ~QMCKL_INVALID_ARG_17~      |   17 | 'Invalid argument 17'  |
   | ~QMCKL_INVALID_ARG_18~      |   18 | 'Invalid argument 18'  |
   | ~QMCKL_INVALID_ARG_19~      |   19 | 'Invalid argument 19'  |
   | ~QMCKL_INVALID_ARG_20~      |   20 | 'Invalid argument 20'  |
   | ~QMCKL_FAILURE~             |  101 | 'Failure'              |
   | ~QMCKL_ERRNO~               |  102 | strerror(errno)        |
   | ~QMCKL_INVALID_CONTEXT~     |  103 | 'Invalid context'      |
   | ~QMCKL_ALLOCATION_FAILED~   |  104 | 'Allocation failed'    |
   | ~QMCKL_DEALLOCATION_FAILED~ |  105 | 'De-allocation failed' |
   | ~QMCKL_NOT_PROVIDED~        |  106 | 'Not provided'         |
   | ~QMCKL_OUT_OF_BOUNDS~       |  107 | 'Index out of bounds'  |
   | ~QMCKL_ALREADY_SET~         |  108 | 'Already set'          |
   | ~QMCKL_INVALID_EXIT_CODE~   |  109 | 'Invalid exit code'    |

   # We need to force Emacs not to indent the Python code:
   # -*- org-src-preserve-indentation: t

   #+begin_src python :var table=table-exit-codes :results drawer :exports none
""" This script generates the C and Fortran constants for the error
    codes from the org-mode table.
"""

result = [ "#+begin_src c :comments org :tangle (eval h_type) :exports none" ]
for (text, code,_) in table:
    text=text.replace("~","")
    result += [ f"#define  {text:30s} ((qmckl_exit_code) {code:d})" ]
result += [ "#+end_src" ]

result += [ "" ]

result += [ "#+begin_src f90 :comments org :tangle (eval fh_type) :exports none" ]
for (text, code,_) in table:
    text=text.replace("~","")
    result += [ f"   integer(qmckl_exit_code), parameter :: {text:30s} = {code:d}" ]
result += [ "#+end_src" ]

return '\n'.join(result)

   #+end_src

   #+RESULTS:
   :results:
   #+begin_src c :comments org :tangle (eval h_type) :exports none
   #define  QMCKL_SUCCESS                  ((qmckl_exit_code) 0)
   #define  QMCKL_INVALID_ARG_1            ((qmckl_exit_code) 1)
   #define  QMCKL_INVALID_ARG_2            ((qmckl_exit_code) 2)
   #define  QMCKL_INVALID_ARG_3            ((qmckl_exit_code) 3)
   #define  QMCKL_INVALID_ARG_4            ((qmckl_exit_code) 4)
   #define  QMCKL_INVALID_ARG_5            ((qmckl_exit_code) 5)
   #define  QMCKL_INVALID_ARG_6            ((qmckl_exit_code) 6)
   #define  QMCKL_INVALID_ARG_7            ((qmckl_exit_code) 7)
   #define  QMCKL_INVALID_ARG_8            ((qmckl_exit_code) 8)
   #define  QMCKL_INVALID_ARG_9            ((qmckl_exit_code) 9)
   #define  QMCKL_INVALID_ARG_10           ((qmckl_exit_code) 10)
   #define  QMCKL_INVALID_ARG_11           ((qmckl_exit_code) 11)
   #define  QMCKL_INVALID_ARG_12           ((qmckl_exit_code) 12)
   #define  QMCKL_INVALID_ARG_13           ((qmckl_exit_code) 13)
   #define  QMCKL_INVALID_ARG_14           ((qmckl_exit_code) 14)
   #define  QMCKL_INVALID_ARG_15           ((qmckl_exit_code) 15)
   #define  QMCKL_INVALID_ARG_16           ((qmckl_exit_code) 16)
   #define  QMCKL_INVALID_ARG_17           ((qmckl_exit_code) 17)
   #define  QMCKL_INVALID_ARG_18           ((qmckl_exit_code) 18)
   #define  QMCKL_INVALID_ARG_19           ((qmckl_exit_code) 19)
   #define  QMCKL_INVALID_ARG_20           ((qmckl_exit_code) 20)
   #define  QMCKL_FAILURE                  ((qmckl_exit_code) 101)
   #define  QMCKL_ERRNO                    ((qmckl_exit_code) 102)
   #define  QMCKL_INVALID_CONTEXT          ((qmckl_exit_code) 103)
   #define  QMCKL_ALLOCATION_FAILED        ((qmckl_exit_code) 104)
   #define  QMCKL_DEALLOCATION_FAILED      ((qmckl_exit_code) 105)
   #define  QMCKL_NOT_PROVIDED             ((qmckl_exit_code) 106)
   #define  QMCKL_OUT_OF_BOUNDS            ((qmckl_exit_code) 107)
   #define  QMCKL_ALREADY_SET              ((qmckl_exit_code) 108)
   #define  QMCKL_INVALID_EXIT_CODE        ((qmckl_exit_code) 109)
   #+end_src

   #+begin_src f90 :comments org :tangle (eval fh_type) :exports none
      integer(qmckl_exit_code), parameter :: QMCKL_SUCCESS                  = 0
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_1            = 1
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_2            = 2
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_3            = 3
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_4            = 4
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_5            = 5
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_6            = 6
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_7            = 7
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_8            = 8
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_9            = 9
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_10           = 10
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_11           = 11
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_12           = 12
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_13           = 13
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_14           = 14
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_15           = 15
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_16           = 16
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_17           = 17
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_18           = 18
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_19           = 19
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_ARG_20           = 20
      integer(qmckl_exit_code), parameter :: QMCKL_FAILURE                  = 101
      integer(qmckl_exit_code), parameter :: QMCKL_ERRNO                    = 102
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_CONTEXT          = 103
      integer(qmckl_exit_code), parameter :: QMCKL_ALLOCATION_FAILED        = 104
      integer(qmckl_exit_code), parameter :: QMCKL_DEALLOCATION_FAILED      = 105
      integer(qmckl_exit_code), parameter :: QMCKL_NOT_PROVIDED             = 106
      integer(qmckl_exit_code), parameter :: QMCKL_OUT_OF_BOUNDS            = 107
      integer(qmckl_exit_code), parameter :: QMCKL_ALREADY_SET              = 108
      integer(qmckl_exit_code), parameter :: QMCKL_INVALID_EXIT_CODE        = 109
   #+end_src
   :end:

   The ~qmckl_string_of_error~ converts an exit code into a string. The
   string is assumed to be large enough to contain the error message
   (typically 128 characters).

* hidden                                                           :noexport:

   #+NAME: MAX_STRING_LENGTH
   : 128

* Decoding errors

   To decode the error messages, ~qmckl_string_of_error~ converts an
   error code into a string.

   #+begin_src c :comments org :tangle (eval h_func) :noweb yes
const char*
qmckl_string_of_error (const qmckl_exit_code error);
   #+end_src

   #+begin_src c :comments org :tangle (eval h_private_func) :exports none :noweb yes
void
qmckl_string_of_error_f(const qmckl_exit_code error,
                        char result[<<MAX_STRING_LENGTH()>>]);
   #+end_src

   The text strings are extracted from the previous table.

   #+NAME:cases
   #+begin_src python :var table=table-exit-codes :exports none :noweb yes
""" This script extracts the text associated with the error codes
    from the table.
"""

result = []
for (text, code, message) in table:
    text = text.replace("~","")
    message = message.replace("'",'"')
    result += [ f"""case {text}:
      return {message};
    """ ]
return '\n'.join(result)

   #+end_src

   #+RESULTS: cases
   #+begin_example
   case QMCKL_SUCCESS:
         return "Success";

   case QMCKL_INVALID_ARG_1:
         return "Invalid argument 1";

   case QMCKL_INVALID_ARG_2:
         return "Invalid argument 2";

   case QMCKL_INVALID_ARG_3:
         return "Invalid argument 3";

   case QMCKL_INVALID_ARG_4:
         return "Invalid argument 4";

   case QMCKL_INVALID_ARG_5:
         return "Invalid argument 5";

   case QMCKL_INVALID_ARG_6:
         return "Invalid argument 6";

   case QMCKL_INVALID_ARG_7:
         return "Invalid argument 7";

   case QMCKL_INVALID_ARG_8:
         return "Invalid argument 8";

   case QMCKL_INVALID_ARG_9:
         return "Invalid argument 9";

   case QMCKL_INVALID_ARG_10:
         return "Invalid argument 10";

   case QMCKL_INVALID_ARG_11:
         return "Invalid argument 11";

   case QMCKL_INVALID_ARG_12:
         return "Invalid argument 12";

   case QMCKL_INVALID_ARG_13:
         return "Invalid argument 13";

   case QMCKL_INVALID_ARG_14:
         return "Invalid argument 14";

   case QMCKL_INVALID_ARG_15:
         return "Invalid argument 15";

   case QMCKL_INVALID_ARG_16:
         return "Invalid argument 16";

   case QMCKL_INVALID_ARG_17:
         return "Invalid argument 17";

   case QMCKL_INVALID_ARG_18:
         return "Invalid argument 18";

   case QMCKL_INVALID_ARG_19:
         return "Invalid argument 19";

   case QMCKL_INVALID_ARG_20:
         return "Invalid argument 20";

   case QMCKL_FAILURE:
         return "Failure";

   case QMCKL_ERRNO:
         return strerror(errno);

   case QMCKL_INVALID_CONTEXT:
         return "Invalid context";

   case QMCKL_ALLOCATION_FAILED:
         return "Allocation failed";

   case QMCKL_DEALLOCATION_FAILED:
         return "De-allocation failed";

   case QMCKL_NOT_PROVIDED:
         return "Not provided";

   case QMCKL_OUT_OF_BOUNDS:
         return "Index out of bounds";

   case QMCKL_ALREADY_SET:
         return "Already set";

   case QMCKL_INVALID_EXIT_CODE:
         return "Invalid exit code";
   #+end_example

   # Source
   #+begin_src c :comments org :tangle (eval c) :noweb yes :exports none
const char* qmckl_string_of_error(const qmckl_exit_code error) {
  switch (error) {
  <<cases()>>
  }
  return "Unknown error";
}

void qmckl_string_of_error_f(const qmckl_exit_code error, char result[<<MAX_STRING_LENGTH()>>]) {
  strncpy(result, qmckl_string_of_error(error), <<MAX_STRING_LENGTH()>>-1);
}
   #+end_src

  # Fortran interface
  #+begin_src f90 :tangle (eval fh_func) :exports none :noweb yes
  interface
     subroutine qmckl_string_of_error (error, string) bind(C, name='qmckl_string_of_error_f')
       use, intrinsic :: iso_c_binding
       import
       implicit none
       integer (qmckl_exit_code), intent(in), value :: error
       character, intent(out) :: string(<<MAX_STRING_LENGTH()>>)
     end subroutine qmckl_string_of_error
  end interface
  #+end_src

* Data structure in context

  The strings are declared internally with a maximum fixed size to avoid
  dynamic memory allocation.

   #+begin_src c :comments org :tangle (eval h_private_type)
#define  QMCKL_MAX_FUN_LEN   256
#define  QMCKL_MAX_MSG_LEN  1024

typedef struct qmckl_error_struct {

  qmckl_exit_code exit_code;
  char function[QMCKL_MAX_FUN_LEN];
  char message [QMCKL_MAX_MSG_LEN];

} qmckl_error_struct;
   #+end_src

* Updating errors in the context

   The error is updated in the context using ~qmckl_set_error~.
   When the error is set in the context, it is mandatory to specify
   from which function the error is triggered, and a message
   explaining the error. The exit code can't be ~QMCKL_SUCCESS~.

   # Header
   #+begin_src c :comments org :tangle (eval h_func)
qmckl_exit_code
qmckl_set_error(qmckl_context context,
                const qmckl_exit_code exit_code,
                const char* function_name,
                const char* message);
   #+end_src

  # Source
  #+begin_src c :tangle (eval c) :exports none
qmckl_exit_code
qmckl_set_error(qmckl_context context,
                const qmckl_exit_code exit_code,
                const char* function_name,
                const char* message)
{
 /* Passing a function name and a message is mandatory. */
  assert (function_name != NULL);
  assert (message != NULL);

 /* Exit codes are assumed valid. */
  assert (exit_code >= 0);
  assert (exit_code != QMCKL_SUCCESS);
  assert (exit_code < QMCKL_INVALID_EXIT_CODE);

 /* The context is assumed to exist. */
  assert (qmckl_context_check(context) != QMCKL_NULL_CONTEXT);

  qmckl_lock(context);
  {
    qmckl_context_struct* const ctx = (qmckl_context_struct*) context;
    assert (ctx != NULL); /* Impossible because the context is valid. */

    ctx->error.exit_code = exit_code;
    strncpy(ctx->error.function, function_name, QMCKL_MAX_FUN_LEN-1);
    strncpy(ctx->error.message, message, QMCKL_MAX_MSG_LEN-1);
  }
  qmckl_unlock(context);

  return QMCKL_SUCCESS;
}
    #+end_src

* Get the error

  Upon error, the error type and message can be obtained from the
  context using ~qmckl_get_error~. The message and function name
  is returned in the variables provided. Therefore, passing a 
  function name and message is mandatory.

  # Header
   #+begin_src c :comments org :tangle (eval h_func)
qmckl_exit_code
qmckl_get_error(qmckl_context context,
                qmckl_exit_code *exit_code,
                char* function_name,
                char* message);
   #+end_src

  # Source
  #+begin_src c :tangle (eval c) :exports none
qmckl_exit_code
qmckl_get_error(qmckl_context context,
                qmckl_exit_code *exit_code,
                char* function_name,
                char* message)
{
 /* Passing a function name and a message is mandatory. */
  assert (function_name != NULL);
  assert (message != NULL);

 /* The context is assumed to exist. */
  assert (qmckl_context_check(context) != QMCKL_NULL_CONTEXT);

  qmckl_lock(context);
  {
    qmckl_context_struct* const ctx = (qmckl_context_struct*) context;
    assert (ctx != NULL); /* Impossible because the context is valid. */

/* Turn off annoying GCC warning */
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstringop-truncation"
#endif

    strncpy(function_name, ctx->error.function, QMCKL_MAX_FUN_LEN-1);
    strncpy(message      , ctx->error.message , QMCKL_MAX_MSG_LEN-1);

#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif

    (*exit_code) = ctx->error.exit_code;
  }
  qmckl_unlock(context);

  return QMCKL_SUCCESS;
}
    #+end_src

* Failing
  
   To make a function fail, the ~qmckl_failwith~ function should be
   called, such that information about the failure is stored in
   the context. The desired exit code is given as an argument, as
   well as the name of the function and an error message. If the
   message is ~NULL~, then the default message obtained by
 ~qmckl_string_of_error~ is used. The return code of the function is
   the desired return code.
   Upon failure, a ~QMCKL_NULL_CONTEXT~ is returned.

   #+begin_src c :comments org :tangle (eval h_func)
qmckl_exit_code
qmckl_failwith(qmckl_context context,
               const qmckl_exit_code exit_code,
               const char* function,
               const char* message) ;
   #+end_src
   
   #+begin_src c :comments org :tangle (eval c) :exports none
qmckl_exit_code
qmckl_failwith(qmckl_context context,
               const qmckl_exit_code exit_code,
               const char* function,
               const char* message)
{
  assert (exit_code > 0);
  assert (exit_code < QMCKL_INVALID_EXIT_CODE);
  assert (function != NULL);
  assert (strlen(function) < QMCKL_MAX_FUN_LEN);
  if (message != NULL) {
    assert (strlen(message)  < QMCKL_MAX_MSG_LEN);
  }

  if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT)
    return QMCKL_INVALID_CONTEXT;

  if (message == NULL) {
    qmckl_exit_code rc =
      qmckl_set_error(context, exit_code, function, qmckl_string_of_error(exit_code));
    assert (rc == QMCKL_SUCCESS);
  } else {
    qmckl_exit_code rc =
      qmckl_set_error(context, exit_code, function, message);
    assert (rc == QMCKL_SUCCESS);
  }

  return exit_code;
}

   #+end_src

   For example, this function can be used as
   #+begin_src c :tangle no
if (x < 0) {
  return qmckl_failwith(context,
                        QMCKL_INVALID_ARG_2,
                        "qmckl_function",
                        "Expected x >= 0");
 }
   #+end_src

* Last error

  Returns a string describing the last error, using ~qmckl_get_error~.

  # Header
   #+begin_src c :comments org :tangle (eval h_func)
qmckl_exit_code
qmckl_last_error(qmckl_context context, char* buffer);
   #+end_src

  # Source
  #+begin_src c :tangle (eval c) :exports none
qmckl_exit_code
qmckl_last_error(qmckl_context context, char* buffer) {

  char function_name[QMCKL_MAX_FUN_LEN];
  char message[QMCKL_MAX_MSG_LEN];

  qmckl_exit_code rc, last_rc;

  if (qmckl_context_check(context) == QMCKL_NULL_CONTEXT) {
    strncpy(buffer, "Null context", 13);
    return QMCKL_FAILURE;
  }

  rc = qmckl_get_error(context, &last_rc, function_name, message);
  if (rc != QMCKL_SUCCESS) {
    return rc;
  }


  sprintf(buffer, "Error -- %s -- in %s\n%s",
          qmckl_string_of_error(last_rc),
          function_name, message);

  return QMCKL_SUCCESS;
}
    #+end_src
    
** Fortran inteface

   #+begin_src f90 :tangle (eval fh_func) :exports none :noweb yes
  interface
     subroutine qmckl_last_error (context, string) bind(C, name='qmckl_last_error')
       use, intrinsic :: iso_c_binding
       import
       implicit none
       integer (c_int64_t) , intent(in), value :: context
       character, intent(out) :: string(*)
     end subroutine qmckl_last_error
  end interface
   #+end_src

* Helper functions for debugging

  The following function prints to ~stderr~ an error message is the return code is
  not ~QMCKL_SUCCESS~.

  # Header
   #+begin_src c :comments org :tangle (eval h_func)
qmckl_exit_code
qmckl_check(qmckl_context context, qmckl_exit_code rc);
   #+end_src

  # Source
  #+begin_src c :tangle (eval c) :exports none
#include <stdio.h>

qmckl_exit_code
qmckl_check(qmckl_context context, qmckl_exit_code rc)
{  

  if (rc != QMCKL_SUCCESS) {
    char fname[QMCKL_MAX_FUN_LEN];
    char message[QMCKL_MAX_MSG_LEN];

    fprintf(stderr, "===========\nQMCKL ERROR\n%s\n", qmckl_string_of_error(rc));
    qmckl_get_error(context, &rc, fname, message);
    fprintf(stderr, "Function: %s\nMessage: %s\n===========\n", fname, message);
  }

  return rc;
}
    #+end_src
    
  It should be used as:

    #+begin_src c
rc = qmckl_check(context,
                 qmckl_...(context, ...)
                 );
assert (rc == QMCKL_SUCCESS);
     #+end_src
    
** Fortran inteface

   #+begin_src f90 :tangle (eval fh_func) :exports none :noweb yes
  interface
     function qmckl_check (context, rc) bind(C, name='qmckl_check')
       use, intrinsic :: iso_c_binding
       import
       implicit none
       integer(qmckl_exit_code) :: qmckl_check
       integer (c_int64_t) , intent(in), value :: context
       integer(qmckl_exit_code), intent(in), value :: rc
     end function qmckl_check
  end interface
   #+end_src

* End of files                                                    :noexport:

  #+begin_src c :comments link :tangle (eval h_private_type)
#endif
  #+end_src

   #+begin_src c :comments link :tangle (eval c_test)
 /* Initialize the variables */
  char function_name[QMCKL_MAX_FUN_LEN]="";
  char message[QMCKL_MAX_MSG_LEN]="";

 /* Set the error code to be different from Success */
  qmckl_exit_code exit_code;
  exit_code = 1;

  assert (qmckl_set_error(context, exit_code, "my_function", "Message") == QMCKL_SUCCESS);

  assert (qmckl_get_error(context, &exit_code, function_name, message) == QMCKL_SUCCESS);
  assert (exit_code == 1);

  assert (strcmp(function_name,"my_function") == 0);
  assert (strcmp(message,"Message") == 0);

  exit_code = qmckl_context_destroy(context);
  assert(exit_code == QMCKL_SUCCESS);

  return 0;
}
   #+end_src

# -*- mode: org -*-
# vim: syntax=c