Remove ccid and pcsc

This was an early, but incomplete attempt to get yubikeys to work. I'll revisit
this later.

12 files changed, 0 insertions, 7432 deletions

diff --git a/pkg/ccid/config.h b/pkg/ccid/config.h
deleted file mode 100644
index cc49a808..00000000
--- a/pkg/ccid/config.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#include <config-posix.h>
-
-#define BUNDLE "ifd-ccid.bundle"
-#define HAVE_LIBUSB_H 1
-#define HAVE_MEMORY_H 1
-#define HAVE_PTHREAD 1
-#define HAVE_PTHREAD_PRIO_INHERIT 1
-#define HAVE_STRLCAT 1
-#define HAVE_STRLCPY 1
-#define LT_OBJDIR ".libs/"
-/* #undef NO_LOG */
-#define PACKAGE "ccid"
-#define PACKAGE_BUGREPORT ""
-#define PACKAGE_NAME "ccid"
-#define PACKAGE_STRING "ccid 1.4.24"
-#define PACKAGE_TARNAME "ccid"
-#define PACKAGE_URL ""
-#define PACKAGE_VERSION "1.4.24"
-#define PCSCLITE_HP_DROPDIR "/lib/pcsc/drivers"
-/* #undef PTHREAD_CREATE_JOINABLE */
-#define TIME_WITH_SYS_TIME 1
-/* #undef USE_COMPOSITE_AS_MULTISLOT */
-/* #undef USE_SYSLOG */
-#define VERSION "1.4.24"
-/* #undef YYTEXT_POINTER */
-/* #undef const */
-/* #undef size_t */
diff --git a/pkg/ccid/gen.rc b/pkg/ccid/gen.rc
deleted file mode 100644
index 4f541ac8..00000000
--- a/pkg/ccid/gen.rc
+++ /dev/null
@@ -1,31 +0,0 @@
-version=1.4.24
-cflags\
-	-D HAVE_CONFIG_H\
-	-isystem '$builddir'/pkg/libusb/include\
-	-isystem '$builddir'/pkg/pcsc/include\
-	-I include\
-	-I '$dir' \
-	-I '$srcdir'/src\
-
-phony deps pkg/^(libusb pcsc)^/headers
-
-lib libccid.a -d '$dir'/deps src/^(\
-	ccid.c \
-	commands.c \
-	ifdhandler.c \
-	utils.c \
-	ccid_usb.c\
-	tokenparser.c\
-	towitoko/atr.c \
-	towitoko/pps.c \
-	openct/buffer.c \
-	openct/checksum.c \
-	openct/proto-t1.c \
-)
-
-build '$outdir'/Info.plist awk '$srcdir'/src/Info.plist.src\
-	'|' '$dir'/info_plist.awk '$srcdir'/readers/supported_readers.txt
-with expr '-f $dir/info_plist.awk -v readers=$srcdir/readers/supported_readers.txt target=libccid.a version='$version
-file lib/pcsc/drivers/ifd-ccid.bundle/Contents/Info.plist '$outdir'/Info.plist 644
-
-fetch git
diff --git a/pkg/ccid/info_plist.awk b/pkg/ccid/info_plist.awk
deleted file mode 100644
index 50b3fcf7..00000000
--- a/pkg/ccid/info_plist.awk
+++ /dev/null
@@ -1,31 +0,0 @@
-BEGIN {
-	n = 1
-	while (getline < readers) {
-		if ($0 ~ /^(#|$)/)
-			continue
-		split($0, r, ":")
-		vendor[n] = r[1]
-		product[n] = r[2]
-		gsub("&", "&amp;", r[3])
-		name[n] = r[3]
-		++n
-	}
-}
-
-function printstrs(a) {
-	for (i = 1; i < n; ++i)
-		printf "\t\t<string>%s</string>\n", a[i]
-}
-
-/MAGIC_VENDOR/ {printstrs(vendor); next}
-/MAGIC_PRODUCT/ {printstrs(product); next}
-/MAGIC_FRIENDLYNAME/ {printstrs(name); next}
-/MAGIC_TARGET/ {sub("MAGIC_TARGET", target)}
-/MAGIC_VERSION/ {sub("MAGIC_VERSION", version)}
-/MAGIC_CLASS/ {
-	print "\t<key>CFBundleName</key>"
-	print "\t<string>CCIDCLASSDRIVER</string>"
-	next
-}
-
-{print}
diff --git a/pkg/ccid/patch/0001-Check-in-source-files-from-ccid-1.4.24-distribution.patch b/pkg/ccid/patch/0001-Check-in-source-files-from-ccid-1.4.24-distribution.patch
deleted file mode 100644
index 75f32470..00000000
--- a/pkg/ccid/patch/0001-Check-in-source-files-from-ccid-1.4.24-distribution.patch
+++ /dev/null
@@ -1,5181 +0,0 @@
-From 0dde59faca9805e0981eb598e5ad683e6da21d16 Mon Sep 17 00:00:00 2001
-From: Michael Forney <mforney@mforney.org>
-Date: Tue, 5 Jul 2016 22:26:57 -0700
-Subject: [PATCH] Check in source files from ccid 1.4.24 distribution
-
-This replaces some symlinks to ../PCSC/* with the actual files, and adds the
-generated tokenparser.c.
----
- src/misc.h        |   84 ++-
- src/parser.h      |   54 +-
- src/simclist.c    | 1526 +++++++++++++++++++++++++++++++++++++++-
- src/simclist.h    |  981 +++++++++++++++++++++++++-
- src/strlcpy.c     |   61 +-
- src/strlcpycat.h  |   46 +-
- src/tokenparser.c | 2020 +++++++++++++++++++++++++++++++++++++++++++++++++++++
- src/tokenparser.l |  283 +++++++-
- 8 files changed, 5048 insertions(+), 7 deletions(-)
- mode change 120000 => 100644 src/misc.h
- mode change 120000 => 100644 src/parser.h
- mode change 120000 => 100644 src/simclist.c
- mode change 120000 => 100644 src/simclist.h
- mode change 120000 => 100644 src/strlcpy.c
- mode change 120000 => 100644 src/strlcpycat.h
- create mode 100644 src/tokenparser.c
- mode change 120000 => 100644 src/tokenparser.l
-
-diff --git a/src/misc.h b/src/misc.h
-deleted file mode 120000
-index b47f6b0..0000000
---- a/src/misc.h
-+++ /dev/null
-@@ -1 +0,0 @@
--../PCSC/src/misc.h
-\ No newline at end of file
-diff --git a/src/misc.h b/src/misc.h
-new file mode 100644
-index 0000000..ea0d098
---- /dev/null
-+++ b/src/misc.h
-@@ -0,0 +1,83 @@
-+/*
-+ * This handles GCC attributes
-+ *
-+ * MUSCLE SmartCard Development ( http://pcsclite.alioth.debian.org/pcsclite.html )
-+ *
-+ * Copyright (C) 2005-2010
-+ *  Ludovic Rousseau <ludovic.rousseau@free.fr>
-+ *
-+Redistribution and use in source and binary forms, with or without
-+modification, are permitted provided that the following conditions
-+are met:
-+
-+1. Redistributions of source code must retain the above copyright
-+   notice, this list of conditions and the following disclaimer.
-+2. Redistributions in binary form must reproduce the above copyright
-+   notice, this list of conditions and the following disclaimer in the
-+   documentation and/or other materials provided with the distribution.
-+3. The name of the author may not be used to endorse or promote products
-+   derived from this software without specific prior written permission.
-+
-+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+#ifndef __misc_h__
-+#define __misc_h__
-+
-+/*
-+ * Declare the function as internal to the library: the function name is
-+ * not exported and can't be used by a program linked to the library
-+ *
-+ * see http://gcc.gnu.org/onlinedocs/gcc-3.3.5/gcc/Function-Attributes.html#Function-Attributes
-+ * see http://www.nedprod.com/programs/gccvisibility.html
-+ */
-+#if defined __GNUC__ && (! defined (__sun)) && (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3))
-+#define INTERNAL __attribute__ ((visibility("hidden")))
-+#define PCSC_API __attribute__ ((visibility("default")))
-+#elif (! defined __GNUC__ ) && defined (__sun)
-+/* http://wikis.sun.com/display/SunStudio/Macros+for+Shared+Library+Symbol+Visibility */
-+#define INTERNAL __hidden
-+#define PCSC_API __global
-+#else
-+#define INTERNAL
-+#define PCSC_API
-+#endif
-+#define EXTERNAL PCSC_API
-+
-+#if defined __GNUC__
-+
-+/* GNU Compiler Collection (GCC) */
-+#define CONSTRUCTOR __attribute__ ((constructor))
-+#define DESTRUCTOR __attribute__ ((destructor))
-+
-+#else
-+
-+/* SUN C compiler does not use __attribute__ but #pragma init (function)
-+ * We can't use a # inside a #define so it is not possible to use
-+ * #define CONSTRUCTOR_DECLARATION(x) #pragma init (x)
-+ * The #pragma is used directly where needed */
-+
-+/* any other */
-+#define CONSTRUCTOR
-+#define DESTRUCTOR
-+
-+#endif
-+
-+#ifndef min
-+#define min(a,b) (((a) < (b)) ? (a) : (b))
-+#endif
-+
-+#ifndef COUNT_OF
-+#define COUNT_OF(arr) (sizeof(arr)/sizeof(arr[0]))
-+#endif
-+
-+#endif /* __misc_h__ */
-diff --git a/src/parser.h b/src/parser.h
-deleted file mode 120000
-index 00feb5b..0000000
---- a/src/parser.h
-+++ /dev/null
-@@ -1 +0,0 @@
--../PCSC/src/parser.h
-\ No newline at end of file
-diff --git a/src/parser.h b/src/parser.h
-new file mode 100644
-index 0000000..09450dc
---- /dev/null
-+++ b/src/parser.h
-@@ -0,0 +1,53 @@
-+/*
-+ * MUSCLE SmartCard Development ( http://pcsclite.alioth.debian.org/pcsclite.html )
-+ *
-+ * Copyright (C) 2003
-+ *  Toni Andjelkovic <toni@soth.at>
-+ * Copyright (C) 2003-2009
-+ *  Ludovic Rousseau <ludovic.rousseau@free.fr>
-+ *
-+Redistribution and use in source and binary forms, with or without
-+modification, are permitted provided that the following conditions
-+are met:
-+
-+1. Redistributions of source code must retain the above copyright
-+   notice, this list of conditions and the following disclaimer.
-+2. Redistributions in binary form must reproduce the above copyright
-+   notice, this list of conditions and the following disclaimer in the
-+   documentation and/or other materials provided with the distribution.
-+3. The name of the author may not be used to endorse or promote products
-+   derived from this software without specific prior written permission.
-+
-+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+/**
-+ * @file
-+ * @brief Reads lexical config files and updates database.
-+ */
-+
-+#ifndef __parser_h__
-+#define __parser_h__
-+
-+#include "simclist.h"
-+
-+struct bundleElt
-+{
-+	char *key;
-+	list_t values;
-+};
-+
-+int LTPBundleFindValueWithKey(list_t *l, const char *key, list_t **values);
-+int bundleParse(const char *fileName, list_t *l);
-+void bundleRelease(list_t *l);
-+
-+#endif
-diff --git a/src/simclist.c b/src/simclist.c
-deleted file mode 120000
-index 40933f2..0000000
---- a/src/simclist.c
-+++ /dev/null
-@@ -1 +0,0 @@
--../PCSC/src/simclist.c
-\ No newline at end of file
-diff --git a/src/simclist.c b/src/simclist.c
-new file mode 100644
-index 0000000..c8d36f5
---- /dev/null
-+++ b/src/simclist.c
-@@ -0,0 +1,1525 @@
-+/*
-+ * Copyright (c) 2007,2008,2009,2010,2011 Mij <mij@bitchx.it>
-+ *
-+ * Permission to use, copy, modify, and distribute this software for any
-+ * purpose with or without fee is hereby granted, provided that the above
-+ * copyright notice and this permission notice appear in all copies.
-+ *
-+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-+ */
-+
-+
-+/*
-+ * SimCList library. See http://mij.oltrelinux.com/devel/simclist
-+ */
-+
-+/* SimCList implementation, version 1.6 */
-+
-+#include <stdlib.h>
-+#include <string.h>
-+#include <errno.h>          /* for setting errno */
-+#include <sys/types.h>
-+#ifndef _WIN32
-+    /* not in Windows! */
-+#   include <unistd.h>
-+#   include <stdint.h>
-+#endif
-+#ifndef SIMCLIST_NO_DUMPRESTORE
-+    /* includes for dump/restore */
-+#   include <time.h>
-+#   include <sys/uio.h>     /* for READ_ERRCHECK() and write() */
-+#   include <fcntl.h>       /* for open() etc */
-+#   ifndef _WIN32
-+#       include <arpa/inet.h>  /* for htons() on UNIX */
-+#   else
-+#       include <winsock2.h>  /* for htons() on Windows */
-+#   endif
-+#endif
-+
-+/* disable asserts */
-+#ifndef SIMCLIST_DEBUG
-+#define NDEBUG
-+#endif
-+
-+#include <assert.h>
-+
-+
-+#include <sys/stat.h>       /* for open()'s access modes S_IRUSR etc */
-+#include <limits.h>
-+
-+#if defined(_MSC_VER) || defined(__MINGW32__)
-+/* provide gettimeofday() missing in Windows */
-+int gettimeofday(struct timeval *tp, void *tzp) {
-+    DWORD t;
-+
-+    /* XSI says: "If tzp is not a null pointer, the behavior is unspecified" */
-+    assert(tzp == NULL);
-+
-+    t = timeGetTime();
-+    tp->tv_sec = t / 1000;
-+    tp->tv_usec = t % 1000;
-+    return 0;
-+}
-+#endif
-+
-+
-+/* work around lack of inttypes.h support in broken Microsoft Visual Studio compilers */
-+#if !defined(_WIN32) || !defined(_MSC_VER)
-+#   include <inttypes.h>   /* (u)int*_t */
-+#else
-+#   include <basetsd.h>
-+typedef UINT8   uint8_t;
-+typedef UINT16  uint16_t;
-+typedef ULONG32 uint32_t;
-+typedef UINT64  uint64_t;
-+typedef INT8    int8_t;
-+typedef INT16   int16_t;
-+typedef LONG32  int32_t;
-+typedef INT64   int64_t;
-+#endif
-+
-+
-+/* define some commodity macros for Dump/Restore functionality */
-+#ifndef SIMCLIST_NO_DUMPRESTORE
-+/* write() decorated with error checking logic */
-+#define WRITE_ERRCHECK(fd, msgbuf, msglen)      do {                                                    \
-+                                                    if (write(fd, msgbuf, msglen) < 0) return -1;       \
-+                                                } while (0);
-+/* READ_ERRCHECK() decorated with error checking logic */
-+#define READ_ERRCHECK(fd, msgbuf, msglen)      do {                                                     \
-+                                                    if (read(fd, msgbuf, msglen) != msglen) {           \
-+                                                        /*errno = EPROTO;*/                             \
-+                                                        return -1;                                      \
-+                                                    }                                                   \
-+                                                } while (0);
-+
-+/* convert 64bit integers from host to network format */
-+#define hton64(x)       (\
-+        htons(1) == 1 ?                                         \
-+            (uint64_t)x      /* big endian */                   \
-+        :       /* little endian */                             \
-+        ((uint64_t)((((uint64_t)(x) & 0xff00000000000000ULL) >> 56) | \
-+            (((uint64_t)(x) & 0x00ff000000000000ULL) >> 40) | \
-+            (((uint64_t)(x) & 0x0000ff0000000000ULL) >> 24) | \
-+            (((uint64_t)(x) & 0x000000ff00000000ULL) >>  8) | \
-+            (((uint64_t)(x) & 0x00000000ff000000ULL) <<  8) | \
-+            (((uint64_t)(x) & 0x0000000000ff0000ULL) << 24) | \
-+            (((uint64_t)(x) & 0x000000000000ff00ULL) << 40) | \
-+            (((uint64_t)(x) & 0x00000000000000ffULL) << 56)))   \
-+        )
-+
-+/* convert 64bit integers from network to host format */
-+#define ntoh64(x)       (hton64(x))
-+#endif
-+
-+/* some OSes don't have EPROTO (eg OpenBSD) */
-+#ifndef EPROTO
-+#define EPROTO  EIO
-+#endif
-+
-+#ifdef SIMCLIST_WITH_THREADS
-+/* limit (approx) to the number of threads running
-+ * for threaded operations. Only meant when
-+ * SIMCLIST_WITH_THREADS is defined */
-+#define SIMCLIST_MAXTHREADS   2
-+#endif
-+
-+/*
-+ * how many elems to keep as spare. During a deletion, an element
-+ * can be saved in a "free-list", not free()d immediately. When
-+ * latter insertions are performed, spare elems can be used instead
-+ * of malloc()ing new elems.
-+ *
-+ * about this param, some values for appending
-+ * 10 million elems into an empty list:
-+ * (#, time[sec], gain[%], gain/no[%])
-+ * 0    2,164   0,00    0,00    <-- feature disabled
-+ * 1    1,815   34,9    34,9
-+ * 2    1,446   71,8    35,9    <-- MAX gain/no
-+ * 3    1,347   81,7    27,23
-+ * 5    1,213   95,1    19,02
-+ * 8    1,064   110,0   13,75
-+ * 10   1,015   114,9   11,49   <-- MAX gain w/ likely sol
-+ * 15   1,019   114,5   7,63
-+ * 25   0,985   117,9   4,72
-+ * 50   1,088   107,6   2,15
-+ * 75   1,016   114,8   1,53
-+ * 100  0,988   117,6   1,18
-+ * 150  1,022   114,2   0,76
-+ * 200  0,939   122,5   0,61    <-- MIN time
-+ */
-+#ifndef SIMCLIST_MAX_SPARE_ELEMS
-+#define SIMCLIST_MAX_SPARE_ELEMS        5
-+#endif
-+
-+
-+#ifdef SIMCLIST_WITH_THREADS
-+#include <pthread.h>
-+#endif
-+
-+#include "simclist.h"
-+
-+
-+/* minumum number of elements for sorting with quicksort instead of insertion */
-+#define SIMCLIST_MINQUICKSORTELS        24
-+
-+
-+/* list dump declarations */
-+#define SIMCLIST_DUMPFORMAT_VERSION     1   /* (short integer) version of fileformat managed by _dump* and _restore* functions */
-+
-+#define SIMCLIST_DUMPFORMAT_HEADERLEN   30  /* length of the header */
-+
-+/* header for a list dump */
-+struct list_dump_header_s {
-+    uint16_t ver;               /* version */
-+    int32_t timestamp_sec;      /* dump timestamp, seconds since UNIX Epoch */
-+    int32_t timestamp_usec;     /* dump timestamp, microseconds since timestamp_sec */
-+    int32_t rndterm;            /* random value terminator -- terminates the data sequence */
-+
-+    uint32_t totlistlen;        /* sum of every element' size, bytes */
-+    uint32_t numels;            /* number of elements */
-+    uint32_t elemlen;           /* bytes length of an element, for constant-size lists, <= 0 otherwise */
-+    int32_t listhash;           /* hash of the list at the time of dumping, or 0 if to be ignored */
-+};
-+
-+
-+
-+/* deletes tmp from list, with care wrt its position (head, tail, middle) */
-+static int list_drop_elem(list_t *restrict l, struct list_entry_s *tmp, unsigned int pos);
-+
-+/* set default values for initialized lists */
-+static int list_attributes_setdefaults(list_t *restrict l);
-+
-+#ifndef NDEBUG
-+/* check whether the list internal REPresentation is valid -- Costs O(n) */
-+static int list_repOk(const list_t *restrict l);
-+
-+/* check whether the list attribute set is valid -- Costs O(1) */
-+static int list_attrOk(const list_t *restrict l);
-+#endif
-+
-+/* do not inline, this is recursive */
-+static void list_sort_quicksort(list_t *restrict l, int versus,
-+        unsigned int first, struct list_entry_s *fel,
-+        unsigned int last, struct list_entry_s *lel);
-+
-+static inline void list_sort_selectionsort(list_t *restrict l, int versus,
-+        unsigned int first, struct list_entry_s *fel,
-+        unsigned int last, struct list_entry_s *lel);
-+
-+static void *list_get_minmax(const list_t *restrict l, int versus);
-+
-+static inline struct list_entry_s *list_findpos(const list_t *restrict l, int posstart);
-+
-+/*
-+ * Random Number Generator
-+ *
-+ * The user is expected to seed the RNG (ie call srand()) if
-+ * SIMCLIST_SYSTEM_RNG is defined.
-+ *
-+ * Otherwise, a self-contained RNG based on LCG is used; see
-+ * http://en.wikipedia.org/wiki/Linear_congruential_generator .
-+ *
-+ * Facts pro local RNG:
-+ * 1. no need for the user to call srand() on his own
-+ * 2. very fast, possibly faster than OS
-+ * 3. avoid interference with user's RNG
-+ *
-+ * Facts pro system RNG:
-+ * 1. may be more accurate (irrelevant for SimCList randno purposes)
-+ * 2. why reinvent the wheel
-+ *
-+ * Default to local RNG for user's ease of use.
-+ */
-+
-+#ifdef SIMCLIST_SYSTEM_RNG
-+/* keep track whether we initialized already (non-0) or not (0) */
-+static unsigned random_seed = 0;
-+
-+/* use local RNG */
-+static inline void seed_random(void) {
-+    if (random_seed == 0)
-+        random_seed = (unsigned)getpid() ^ (unsigned)time(NULL);
-+}
-+
-+static inline long get_random(void) {
-+    random_seed = (1664525 * random_seed + 1013904223);
-+    return random_seed;
-+}
-+
-+#else
-+/* use OS's random generator */
-+#   define  seed_random()
-+#   define  get_random()        (rand())
-+#endif
-+
-+
-+/* list initialization */
-+int list_init(list_t *restrict l) {
-+    if (l == NULL) return -1;
-+
-+    seed_random();
-+
-+    l->numels = 0;
-+
-+    /* head/tail sentinels and mid pointer */
-+    l->head_sentinel = (struct list_entry_s *)malloc(sizeof(struct list_entry_s));
-+    l->tail_sentinel = (struct list_entry_s *)malloc(sizeof(struct list_entry_s));
-+    l->head_sentinel->next = l->tail_sentinel;
-+    l->tail_sentinel->prev = l->head_sentinel;
-+    l->head_sentinel->prev = l->tail_sentinel->next = l->mid = NULL;
-+    l->head_sentinel->data = l->tail_sentinel->data = NULL;
-+
-+    /* iteration attributes */
-+    l->iter_active = 0;
-+    l->iter_pos = 0;
-+    l->iter_curentry = NULL;
-+
-+    /* free-list attributes */
-+    l->spareels = (struct list_entry_s **)malloc(SIMCLIST_MAX_SPARE_ELEMS * sizeof(struct list_entry_s *));
-+    l->spareelsnum = 0;
-+
-+#ifdef SIMCLIST_WITH_THREADS
-+    l->threadcount = 0;
-+#endif
-+
-+    list_attributes_setdefaults(l);
-+
-+    assert(list_repOk(l));
-+    assert(list_attrOk(l));
-+
-+    return 0;
-+}
-+
-+void list_destroy(list_t *restrict l) {
-+    unsigned int i;
-+
-+    list_clear(l);
-+    for (i = 0; i < l->spareelsnum; i++) {
-+        free(l->spareels[i]);
-+    }
-+    free(l->spareels);
-+    free(l->head_sentinel);
-+    free(l->tail_sentinel);
-+}
-+
-+int list_attributes_setdefaults(list_t *restrict l) {
-+    l->attrs.comparator = NULL;
-+    l->attrs.seeker = NULL;
-+
-+    /* also free() element data when removing and element from the list */
-+    l->attrs.meter = NULL;
-+    l->attrs.copy_data = 0;
-+
-+    l->attrs.hasher = NULL;
-+
-+    /* serializer/unserializer */
-+    l->attrs.serializer = NULL;
-+    l->attrs.unserializer = NULL;
-+
-+    assert(list_attrOk(l));
-+
-+    return 0;
-+}
-+
-+/* setting list properties */
-+int list_attributes_comparator(list_t *restrict l, element_comparator comparator_fun) {
-+    if (l == NULL) return -1;
-+
-+    l->attrs.comparator = comparator_fun;
-+
-+    assert(list_attrOk(l));
-+
-+    return 0;
-+}
-+
-+int list_attributes_seeker(list_t *restrict l, element_seeker seeker_fun) {
-+    if (l == NULL) return -1;
-+
-+    l->attrs.seeker = seeker_fun;
-+    assert(list_attrOk(l));
-+
-+    return 0;
-+}
-+
-+int list_attributes_copy(list_t *restrict l, element_meter metric_fun, int copy_data) {
-+    if (l == NULL || (metric_fun == NULL && copy_data != 0)) return -1;
-+
-+    l->attrs.meter = metric_fun;
-+    l->attrs.copy_data = copy_data;
-+
-+    assert(list_attrOk(l));
-+
-+    return 0;
-+}
-+
-+int list_attributes_hash_computer(list_t *restrict l, element_hash_computer hash_computer_fun) {
-+    if (l == NULL) return -1;
-+
-+    l->attrs.hasher = hash_computer_fun;
-+    assert(list_attrOk(l));
-+    return 0;
-+}
-+
-+int list_attributes_serializer(list_t *restrict l, element_serializer serializer_fun) {
-+    if (l == NULL) return -1;
-+
-+    l->attrs.serializer = serializer_fun;
-+    assert(list_attrOk(l));
-+    return 0;
-+}
-+
-+int list_attributes_unserializer(list_t *restrict l, element_unserializer unserializer_fun) {
-+    if (l == NULL) return -1;
-+
-+    l->attrs.unserializer = unserializer_fun;
-+    assert(list_attrOk(l));
-+    return 0;
-+}
-+
-+int list_append(list_t *restrict l, const void *data) {
-+    return list_insert_at(l, data, l->numels);
-+}
-+
-+int list_prepend(list_t *restrict l, const void *data) {
-+    return list_insert_at(l, data, 0);
-+}
-+
-+void *list_fetch(list_t *restrict l) {
-+    return list_extract_at(l, 0);
-+}
-+
-+void *list_get_at(const list_t *restrict l, unsigned int pos) {
-+    struct list_entry_s *tmp;
-+
-+    tmp = list_findpos(l, pos);
-+
-+    return (tmp != NULL ? tmp->data : NULL);
-+}
-+
-+void *list_get_max(const list_t *restrict l) {
-+    return list_get_minmax(l, +1);
-+}
-+
-+void *list_get_min(const list_t *restrict l) {
-+    return list_get_minmax(l, -1);
-+}
-+
-+/* REQUIRES {list->numels >= 1}
-+ * return the min (versus < 0) or max value (v > 0) in l */
-+static void *list_get_minmax(const list_t *restrict l, int versus) {
-+    void *curminmax;
-+    struct list_entry_s *s;
-+
-+    if (l->attrs.comparator == NULL || l->numels == 0)
-+        return NULL;
-+
-+    curminmax = l->head_sentinel->next->data;
-+    for (s = l->head_sentinel->next->next; s != l->tail_sentinel; s = s->next) {
-+        if (l->attrs.comparator(curminmax, s->data) * versus > 0)
-+            curminmax = s->data;
-+    }
-+
-+    return curminmax;
-+}
-+
-+/* set tmp to point to element at index posstart in l */
-+static inline struct list_entry_s *list_findpos(const list_t *restrict l, int posstart) {
-+    struct list_entry_s *ptr;
-+    float x;
-+    int i;
-+
-+    /* accept 1 slot overflow for fetching head and tail sentinels */
-+    if (posstart < -1 || posstart > (int)l->numels) return NULL;
-+
-+    x = (float)(posstart+1) / l->numels;
-+    if (x <= 0.25) {
-+        /* first quarter: get to posstart from head */
-+        for (i = -1, ptr = l->head_sentinel; i < posstart; ptr = ptr->next, i++);
-+    } else if (x < 0.5) {
-+        /* second quarter: get to posstart from mid */
-+        for (i = (l->numels-1)/2, ptr = l->mid; i > posstart; ptr = ptr->prev, i--);
-+    } else if (x <= 0.75) {
-+        /* third quarter: get to posstart from mid */
-+        for (i = (l->numels-1)/2, ptr = l->mid; i < posstart; ptr = ptr->next, i++);
-+    } else {
-+        /* fourth quarter: get to posstart from tail */
-+        for (i = l->numels, ptr = l->tail_sentinel; i > posstart; ptr = ptr->prev, i--);
-+    }
-+
-+    return ptr;
-+}
-+
-+void *list_extract_at(list_t *restrict l, unsigned int pos) {
-+    struct list_entry_s *tmp;
-+    void *data;
-+
-+    if (l->iter_active || pos >= l->numels) return NULL;
-+
-+    tmp = list_findpos(l, pos);
-+    data = tmp->data;
-+
-+    tmp->data = NULL;   /* save data from list_drop_elem() free() */
-+    list_drop_elem(l, tmp, pos);
-+    l->numels--;
-+
-+    assert(list_repOk(l));
-+
-+    return data;
-+}
-+
-+int list_insert_at(list_t *restrict l, const void *data, unsigned int pos) {
-+    struct list_entry_s *lent, *succ, *prec;
-+
-+    if (l->iter_active || pos > l->numels) return -1;
-+
-+    /* this code optimizes malloc() with a free-list */
-+    if (l->spareelsnum > 0) {
-+        lent = l->spareels[l->spareelsnum-1];
-+        l->spareelsnum--;
-+    } else {
-+        lent = (struct list_entry_s *)malloc(sizeof(struct list_entry_s));
-+        if (lent == NULL)
-+            return -1;
-+    }
-+
-+    if (l->attrs.copy_data) {
-+        /* make room for user' data (has to be copied) */
-+        size_t datalen = l->attrs.meter(data);
-+        lent->data = (struct list_entry_s *)malloc(datalen);
-+        memcpy(lent->data, data, datalen);
-+    } else {
-+        lent->data = (void*)data;
-+    }
-+
-+    /* actually append element */
-+    prec = list_findpos(l, pos-1);
-+    succ = prec->next;
-+
-+    prec->next = lent;
-+    lent->prev = prec;
-+    lent->next = succ;
-+    succ->prev = lent;
-+
-+    l->numels++;
-+
-+    /* fix mid pointer */
-+    if (l->numels == 1) { /* first element, set pointer */
-+        l->mid = lent;
-+    } else if (l->numels % 2) {    /* now odd */
-+        if (pos >= (l->numels-1)/2) l->mid = l->mid->next;
-+    } else {                /* now even */
-+        if (pos <= (l->numels-1)/2) l->mid = l->mid->prev;
-+    }
-+
-+    assert(list_repOk(l));
-+
-+    return 1;
-+}
-+
-+int list_delete(list_t *restrict l, const void *data) {
-+	int pos, r;
-+
-+	pos = list_locate(l, data);
-+	if (pos < 0)
-+		return -1;
-+
-+	r = list_delete_at(l, pos);
-+	if (r < 0)
-+		return -1;
-+
-+    assert(list_repOk(l));
-+
-+	return 0;
-+}
-+
-+int list_delete_at(list_t *restrict l, unsigned int pos) {
-+    struct list_entry_s *delendo;
-+
-+
-+    if (l->iter_active || pos >= l->numels) return -1;
-+
-+    delendo = list_findpos(l, pos);
-+
-+    list_drop_elem(l, delendo, pos);
-+
-+    l->numels--;
-+
-+
-+    assert(list_repOk(l));
-+
-+    return  0;
-+}
-+
-+int list_delete_range(list_t *restrict l, unsigned int posstart, unsigned int posend) {
-+    struct list_entry_s *lastvalid, *tmp, *tmp2;
-+    unsigned int numdel, midposafter, i;
-+    int movedx;
-+
-+    if (l->iter_active || posend < posstart || posend >= l->numels) return -1;
-+
-+    numdel = posend - posstart + 1;
-+    if (numdel == l->numels) return list_clear(l);
-+
-+    tmp = list_findpos(l, posstart);    /* first el to be deleted */
-+    lastvalid = tmp->prev;              /* last valid element */
-+
-+    midposafter = (l->numels-1-numdel)/2;
-+
-+    midposafter = midposafter < posstart ? midposafter : midposafter+numdel;
-+    movedx = midposafter - (l->numels-1)/2;
-+
-+    if (movedx > 0) { /* move right */
-+        for (i = 0; i < (unsigned int)movedx; l->mid = l->mid->next, i++);
-+    } else {    /* move left */
-+        movedx = -movedx;
-+        for (i = 0; i < (unsigned int)movedx; l->mid = l->mid->prev, i++);
-+    }
-+
-+    assert(posstart == 0 || lastvalid != l->head_sentinel);
-+    i = posstart;
-+    if (l->attrs.copy_data) {
-+        /* also free element data */
-+        for (; i <= posend; i++) {
-+            tmp2 = tmp;
-+            tmp = tmp->next;
-+            if (tmp2->data != NULL) free(tmp2->data);
-+            if (l->spareelsnum < SIMCLIST_MAX_SPARE_ELEMS) {
-+                l->spareels[l->spareelsnum++] = tmp2;
-+            } else {
-+                free(tmp2);
-+            }
-+        }
-+    } else {
-+        /* only free containers */
-+        for (; i <= posend; i++) {
-+            tmp2 = tmp;
-+            tmp = tmp->next;
-+            if (l->spareelsnum < SIMCLIST_MAX_SPARE_ELEMS) {
-+                l->spareels[l->spareelsnum++] = tmp2;
-+            } else {
-+                free(tmp2);
-+            }
-+        }
-+    }
-+    assert(i == posend+1 && (posend != l->numels || tmp == l->tail_sentinel));
-+
-+    lastvalid->next = tmp;
-+    tmp->prev = lastvalid;
-+
-+    l->numels -= posend - posstart + 1;
-+
-+    assert(list_repOk(l));
-+
-+    return numdel;
-+}
-+
-+int list_clear(list_t *restrict l) {
-+    struct list_entry_s *s;
-+    unsigned int numels;
-+
-+    /* will be returned */
-+    numels = l->numels;
-+
-+    if (l->iter_active) return -1;
-+
-+    if (l->attrs.copy_data) {        /* also free user data */
-+        /* spare a loop conditional with two loops: spareing elems and freeing elems */
-+        for (s = l->head_sentinel->next; l->spareelsnum < SIMCLIST_MAX_SPARE_ELEMS && s != l->tail_sentinel; s = s->next) {
-+            /* move elements as spares as long as there is room */
-+            if (s->data != NULL) free(s->data);
-+            l->spareels[l->spareelsnum++] = s;
-+        }
-+        while (s != l->tail_sentinel) {
-+            /* free the remaining elems */
-+            if (s->data != NULL) free(s->data);
-+            s = s->next;
-+            free(s->prev);
-+        }
-+        l->head_sentinel->next = l->tail_sentinel;
-+        l->tail_sentinel->prev = l->head_sentinel;
-+    } else { /* only free element containers */
-+        /* spare a loop conditional with two loops: spareing elems and freeing elems */
-+        for (s = l->head_sentinel->next; l->spareelsnum < SIMCLIST_MAX_SPARE_ELEMS && s != l->tail_sentinel; s = s->next) {
-+            /* move elements as spares as long as there is room */
-+            l->spareels[l->spareelsnum++] = s;
-+        }
-+        while (s != l->tail_sentinel) {
-+            /* free the remaining elems */
-+            s = s->next;
-+            free(s->prev);
-+        }
-+        l->head_sentinel->next = l->tail_sentinel;
-+        l->tail_sentinel->prev = l->head_sentinel;
-+    }
-+    l->numels = 0;
-+    l->mid = NULL;
-+
-+    assert(list_repOk(l));
-+
-+    return numels;
-+}
-+
-+unsigned int list_size(const list_t *restrict l) {
-+    return l->numels;
-+}
-+
-+int list_empty(const list_t *restrict l) {
-+    return (l->numels == 0);
-+}
-+
-+int list_locate(const list_t *restrict l, const void *data) {
-+    struct list_entry_s *el;
-+    int pos = 0;
-+
-+    if (l->attrs.comparator != NULL) {
-+        /* use comparator */
-+        for (el = l->head_sentinel->next; el != l->tail_sentinel; el = el->next, pos++) {
-+            if (l->attrs.comparator(data, el->data) == 0) break;
-+        }
-+    } else {
-+        /* compare references */
-+        for (el = l->head_sentinel->next; el != l->tail_sentinel; el = el->next, pos++) {
-+            if (el->data == data) break;
-+        }
-+    }
-+    if (el == l->tail_sentinel) return -1;
-+
-+    return pos;
-+}
-+
-+void *list_seek(list_t *restrict l, const void *indicator) {
-+    const struct list_entry_s *iter;
-+
-+    if (l->attrs.seeker == NULL) return NULL;
-+
-+    for (iter = l->head_sentinel->next; iter != l->tail_sentinel; iter = iter->next) {
-+        if (l->attrs.seeker(iter->data, indicator) != 0) return iter->data;
-+    }
-+
-+    return NULL;
-+}
-+
-+int list_contains(const list_t *restrict l, const void *data) {
-+    return (list_locate(l, data) >= 0);
-+}
-+
-+int list_concat(const list_t *l1, const list_t *l2, list_t *restrict dest) {
-+    struct list_entry_s *el, *srcel;
-+    unsigned int cnt;
-+    int err;
-+
-+
-+    if (l1 == NULL || l2 == NULL || dest == NULL || l1 == dest || l2 == dest)
-+        return -1;
-+
-+    list_init(dest);
-+
-+    dest->numels = l1->numels + l2->numels;
-+    if (dest->numels == 0)
-+        return 0;
-+
-+    /* copy list1 */
-+    srcel = l1->head_sentinel->next;
-+    el = dest->head_sentinel;
-+    while (srcel != l1->tail_sentinel) {
-+        el->next = (struct list_entry_s *)malloc(sizeof(struct list_entry_s));
-+        el->next->prev = el;
-+        el = el->next;
-+        el->data = srcel->data;
-+        srcel = srcel->next;
-+    }
-+    dest->mid = el;     /* approximate position (adjust later) */
-+    /* copy list 2 */
-+    srcel = l2->head_sentinel->next;
-+    while (srcel != l2->tail_sentinel) {
-+        el->next = (struct list_entry_s *)malloc(sizeof(struct list_entry_s));
-+        el->next->prev = el;
-+        el = el->next;
-+        el->data = srcel->data;
-+        srcel = srcel->next;
-+    }
-+    el->next = dest->tail_sentinel;
-+    dest->tail_sentinel->prev = el;
-+
-+    /* fix mid pointer */
-+    err = l2->numels - l1->numels;
-+    if ((err+1)/2 > 0) {        /* correct pos RIGHT (err-1)/2 moves */
-+        err = (err+1)/2;
-+        for (cnt = 0; cnt < (unsigned int)err; cnt++) dest->mid = dest->mid->next;
-+    } else if (err/2 < 0) { /* correct pos LEFT (err/2)-1 moves */
-+        err = -err/2;
-+        for (cnt = 0; cnt < (unsigned int)err; cnt++) dest->mid = dest->mid->prev;
-+    }
-+
-+    assert(!(list_repOk(l1) && list_repOk(l2)) || list_repOk(dest));
-+
-+    return 0;
-+}
-+
-+int list_sort(list_t *restrict l, int versus) {
-+    if (l->iter_active || l->attrs.comparator == NULL) /* cannot modify list in the middle of an iteration */
-+        return -1;
-+
-+    if (l->numels <= 1)
-+        return 0;
-+    list_sort_quicksort(l, versus, 0, l->head_sentinel->next, l->numels-1, l->tail_sentinel->prev);
-+    assert(list_repOk(l));
-+    return 0;
-+}
-+
-+#ifdef SIMCLIST_WITH_THREADS
-+struct list_sort_wrappedparams {
-+    list_t *restrict l;
-+    int versus;
-+    unsigned int first, last;
-+    struct list_entry_s *fel, *lel;
-+};
-+
-+static void *list_sort_quicksort_threadwrapper(void *wrapped_params) {
-+    struct list_sort_wrappedparams *wp = (struct list_sort_wrappedparams *)wrapped_params;
-+    list_sort_quicksort(wp->l, wp->versus, wp->first, wp->fel, wp->last, wp->lel);
-+    free(wp);
-+    pthread_exit(NULL);
-+    return NULL;
-+}
-+#endif
-+
-+static inline void list_sort_selectionsort(list_t *restrict l, int versus,
-+        unsigned int first, struct list_entry_s *fel,
-+        unsigned int last, struct list_entry_s *lel) {
-+    struct list_entry_s *cursor, *toswap, *firstunsorted;
-+    void *tmpdata;
-+
-+    if (last <= first) /* <= 1-element lists are always sorted */
-+        return;
-+
-+    for (firstunsorted = fel; firstunsorted != lel; firstunsorted = firstunsorted->next) {
-+        /* find min or max in the remainder of the list */
-+        for (toswap = firstunsorted, cursor = firstunsorted->next; cursor != lel->next; cursor = cursor->next)
-+            if (l->attrs.comparator(toswap->data, cursor->data) * -versus > 0) toswap = cursor;
-+        if (toswap != firstunsorted) { /* swap firstunsorted with toswap */
-+            tmpdata = firstunsorted->data;
-+            firstunsorted->data = toswap->data;
-+            toswap->data = tmpdata;
-+        }
-+    }
-+}
-+
-+static void list_sort_quicksort(list_t *restrict l, int versus,
-+        unsigned int first, struct list_entry_s *fel,
-+        unsigned int last, struct list_entry_s *lel) {
-+    unsigned int pivotid;
-+    unsigned int i;
-+    register struct list_entry_s *pivot;
-+    struct list_entry_s *left, *right;
-+    void *tmpdata;
-+#ifdef SIMCLIST_WITH_THREADS
-+    pthread_t tid;
-+    int traised;
-+#endif
-+
-+
-+    if (last <= first)      /* <= 1-element lists are always sorted */
-+        return;
-+
-+    if (last - first+1 <= SIMCLIST_MINQUICKSORTELS) {
-+        list_sort_selectionsort(l, versus, first, fel, last, lel);
-+        return;
-+    }
-+
-+    /* base of iteration: one element list */
-+    if (! (last > first)) return;
-+
-+    pivotid = (get_random() % (last - first + 1));
-+    /* pivotid = (last - first + 1) / 2; */
-+
-+    /* find pivot */
-+    if (pivotid < (last - first + 1)/2) {
-+        for (i = 0, pivot = fel; i < pivotid; pivot = pivot->next, i++);
-+    } else {
-+        for (i = last - first, pivot = lel; i > pivotid; pivot = pivot->prev, i--);
-+    }
-+
-+    /* smaller PIVOT bigger */
-+    left = fel;
-+    right = lel;
-+    /* iterate     --- left ---> PIV <--- right --- */
-+    while (left != pivot && right != pivot) {
-+        for (; left != pivot && (l->attrs.comparator(left->data, pivot->data) * -versus <= 0); left = left->next);
-+        /* left points to a smaller element, or to pivot */
-+        for (; right != pivot && (l->attrs.comparator(right->data, pivot->data) * -versus >= 0); right = right->prev);
-+        /* right points to a bigger element, or to pivot */
-+        if (left != pivot && right != pivot) {
-+            /* swap, then move iterators */
-+            tmpdata = left->data;
-+            left->data = right->data;
-+            right->data = tmpdata;
-+
-+            left = left->next;
-+            right = right->prev;
-+        }
-+    }
-+
-+    /* now either left points to pivot (end run), or right */
-+    if (right == pivot) {    /* left part longer */
-+        while (left != pivot) {
-+            if (l->attrs.comparator(left->data, pivot->data) * -versus > 0) {
-+                tmpdata = left->data;
-+                left->data = pivot->prev->data;
-+                pivot->prev->data = pivot->data;
-+                pivot->data = tmpdata;
-+                pivot = pivot->prev;
-+                pivotid--;
-+                if (pivot == left) break;
-+            } else {
-+                left = left->next;
-+            }
-+        }
-+    } else {                /* right part longer */
-+        while (right != pivot) {
-+            if (l->attrs.comparator(right->data, pivot->data) * -versus < 0) {
-+                /* move current right before pivot */
-+                tmpdata = right->data;
-+                right->data = pivot->next->data;
-+                pivot->next->data = pivot->data;
-+                pivot->data = tmpdata;
-+                pivot = pivot->next;
-+                pivotid++;
-+                if (pivot == right) break;
-+            } else {
-+                right = right->prev;
-+            }
-+        }
-+    }
-+
-+    /* sort sublists A and B :       |---A---| pivot |---B---| */
-+
-+#ifdef SIMCLIST_WITH_THREADS
-+    traised = 0;
-+    if (pivotid > 0) {
-+        /* prepare wrapped args, then start thread */
-+        if (l->threadcount < SIMCLIST_MAXTHREADS-1) {
-+            struct list_sort_wrappedparams *wp = (struct list_sort_wrappedparams *)malloc(sizeof(struct list_sort_wrappedparams));
-+            l->threadcount++;
-+            traised = 1;
-+            wp->l = l;
-+            wp->versus = versus;
-+            wp->first = first;
-+            wp->fel = fel;
-+            wp->last = first+pivotid-1;
-+            wp->lel = pivot->prev;
-+            if (pthread_create(&tid, NULL, list_sort_quicksort_threadwrapper, wp) != 0) {
-+                free(wp);
-+                traised = 0;
-+                list_sort_quicksort(l, versus, first, fel, first+pivotid-1, pivot->prev);
-+            }
-+        } else {
-+            list_sort_quicksort(l, versus, first, fel, first+pivotid-1, pivot->prev);
-+        }
-+    }
-+    if (first + pivotid < last) list_sort_quicksort(l, versus, first+pivotid+1, pivot->next, last, lel);
-+    if (traised) {
-+        pthread_join(tid, (void **)NULL);
-+        l->threadcount--;
-+    }
-+#else
-+    if (pivotid > 0) list_sort_quicksort(l, versus, first, fel, first+pivotid-1, pivot->prev);
-+    if (first + pivotid < last) list_sort_quicksort(l, versus, first+pivotid+1, pivot->next, last, lel);
-+#endif
-+}
-+
-+int list_iterator_start(list_t *restrict l) {
-+    if (l->iter_active) return 0;
-+    l->iter_pos = 0;
-+    l->iter_active = 1;
-+    l->iter_curentry = l->head_sentinel->next;
-+    return 1;
-+}
-+
-+void *list_iterator_next(list_t *restrict l) {
-+    void *toret;
-+
-+    if (! l->iter_active) return NULL;
-+
-+    toret = l->iter_curentry->data;
-+    l->iter_curentry = l->iter_curentry->next;
-+    l->iter_pos++;
-+
-+    return toret;
-+}
-+
-+int list_iterator_hasnext(const list_t *restrict l) {
-+    if (! l->iter_active) return 0;
-+    return (l->iter_pos < l->numels);
-+}
-+
-+int list_iterator_stop(list_t *restrict l) {
-+    if (! l->iter_active) return 0;
-+    l->iter_pos = 0;
-+    l->iter_active = 0;
-+    return 1;
-+}
-+
-+int list_hash(const list_t *restrict l, list_hash_t *restrict hash) {
-+    struct list_entry_s *x;
-+    list_hash_t tmphash;
-+
-+    assert(hash != NULL);
-+
-+    tmphash = l->numels * 2 + 100;
-+    if (l->attrs.hasher == NULL) {
-+#ifdef SIMCLIST_ALLOW_LOCATIONBASED_HASHES
-+        /* ENABLE WITH CARE !! */
-+#warning "Memlocation-based hash is consistent only for testing modification in the same program run."
-+        int i;
-+
-+        /* only use element references */
-+        for (x = l->head_sentinel->next; x != l->tail_sentinel; x = x->next) {
-+            for (i = 0; i < sizeof(x->data); i++) {
-+                tmphash += (tmphash ^ (uintptr_t)x->data);
-+            }
-+            tmphash += tmphash % l->numels;
-+        }
-+#else
-+        return -1;
-+#endif
-+    } else {
-+        /* hash each element with the user-given function */
-+        for (x = l->head_sentinel->next; x != l->tail_sentinel; x = x->next) {
-+            tmphash += tmphash ^ l->attrs.hasher(x->data);
-+            tmphash += tmphash % l->numels;
-+        }
-+    }
-+
-+    *hash = tmphash;
-+
-+    return 0;
-+}
-+
-+#ifndef SIMCLIST_NO_DUMPRESTORE
-+int list_dump_getinfo_filedescriptor(int fd, list_dump_info_t *restrict info) {
-+    int32_t terminator_head, terminator_tail;
-+    uint32_t elemlen;
-+    off_t hop;
-+
-+
-+    /* version */
-+    READ_ERRCHECK(fd, & info->version, sizeof(info->version));
-+    info->version = ntohs(info->version);
-+    if (info->version > SIMCLIST_DUMPFORMAT_VERSION) {
-+        errno = EILSEQ;
-+        return -1;
-+    }
-+
-+    /* timestamp.tv_sec and timestamp.tv_usec */
-+    READ_ERRCHECK(fd, & info->timestamp.tv_sec, sizeof(info->timestamp.tv_sec));
-+    info->timestamp.tv_sec = ntohl(info->timestamp.tv_sec);
-+    READ_ERRCHECK(fd, & info->timestamp.tv_usec, sizeof(info->timestamp.tv_usec));
-+    info->timestamp.tv_usec = ntohl(info->timestamp.tv_usec);
-+
-+    /* list terminator (to check thereafter) */
-+    READ_ERRCHECK(fd, & terminator_head, sizeof(terminator_head));
-+    terminator_head = ntohl(terminator_head);
-+
-+    /* list size */
-+    READ_ERRCHECK(fd, & info->list_size, sizeof(info->list_size));
-+    info->list_size = ntohl(info->list_size);
-+
-+    /* number of elements */
-+    READ_ERRCHECK(fd, & info->list_numels, sizeof(info->list_numels));
-+    info->list_numels = ntohl(info->list_numels);
-+
-+    /* length of each element (for checking for consistency) */
-+    READ_ERRCHECK(fd, & elemlen, sizeof(elemlen));
-+    elemlen = ntohl(elemlen);
-+
-+    /* list hash */
-+    READ_ERRCHECK(fd, & info->list_hash, sizeof(info->list_hash));
-+    info->list_hash = ntohl(info->list_hash);
-+
-+    /* check consistency */
-+    if (elemlen > 0) {
-+        /* constant length, hop by size only */
-+        hop = info->list_size;
-+    } else {
-+        /* non-constant length, hop by size + all element length blocks */
-+        hop = info->list_size + elemlen*info->list_numels;
-+    }
-+    if (lseek(fd, hop, SEEK_CUR) == -1) {
-+        return -1;
-+    }
-+
-+    /* read the trailing value and compare with terminator_head */
-+    READ_ERRCHECK(fd, & terminator_tail, sizeof(terminator_tail));
-+    terminator_tail = ntohl(terminator_tail);
-+
-+    if (terminator_head == terminator_tail)
-+        info->consistent = 1;
-+    else
-+        info->consistent = 0;
-+
-+    return 0;
-+}
-+
-+int list_dump_getinfo_file(const char *restrict filename, list_dump_info_t *restrict info) {
-+    int fd, ret;
-+
-+    fd = open(filename, O_RDONLY, 0);
-+    if (fd < 0) return -1;
-+
-+    ret = list_dump_getinfo_filedescriptor(fd, info);
-+    close(fd);
-+
-+    return ret;
-+}
-+
-+int list_dump_filedescriptor(const list_t *restrict l, int fd, size_t *restrict len) {
-+    struct list_entry_s *x;
-+    void *ser_buf;
-+    uint32_t bufsize;
-+    struct timeval timeofday;
-+    struct list_dump_header_s header;
-+
-+    if (l->attrs.meter == NULL && l->attrs.serializer == NULL) {
-+        errno = ENOTTY;
-+        return -1;
-+    }
-+
-+    /****       DUMP FORMAT      ****
-+
-+    [ ver   timestamp   |  totlen   numels  elemlen     hash    |   DATA ]
-+
-+    where DATA can be:
-+    @ for constant-size list (element size is constant; elemlen > 0)
-+    [ elem    elem    ...    elem ]
-+    @ for other lists (element size dictated by element_meter each time; elemlen <= 0)
-+    [ size elem     size elem       ...     size elem ]
-+
-+    all integers are encoded in NETWORK BYTE FORMAT
-+    *****/
-+
-+
-+    /* prepare HEADER */
-+    /* version */
-+    header.ver = htons( SIMCLIST_DUMPFORMAT_VERSION );
-+
-+    /* timestamp */
-+    gettimeofday(&timeofday, NULL);
-+    header.timestamp_sec = htonl(timeofday.tv_sec);
-+    header.timestamp_usec = htonl(timeofday.tv_usec);
-+
-+    header.rndterm = htonl((int32_t)get_random());
-+
-+    /* total list size is postprocessed afterwards */
-+
-+    /* number of elements */
-+    header.numels = htonl(l->numels);
-+
-+    /* include an hash, if possible */
-+    if (l->attrs.hasher != NULL) {
-+        if (htonl(list_hash(l, & header.listhash)) != 0) {
-+            /* could not compute list hash! */
-+            return -1;
-+        }
-+    } else {
-+        header.listhash = htonl(0);
-+    }
-+
-+    header.totlistlen = header.elemlen = 0;
-+
-+    /* leave room for the header at the beginning of the file */
-+    if (lseek(fd, SIMCLIST_DUMPFORMAT_HEADERLEN, SEEK_SET) < 0) {
-+        /* errno set by lseek() */
-+        return -1;
-+    }
-+
-+    /* write CONTENT */
-+    if (l->numels > 0) {
-+        /* SPECULATE that the list has constant element size */
-+
-+        if (l->attrs.serializer != NULL) {  /* user user-specified serializer */
-+            /* get preliminary length of serialized element in header.elemlen */
-+            ser_buf = l->attrs.serializer(l->head_sentinel->next->data, & header.elemlen);
-+            free(ser_buf);
-+            /* request custom serialization of each element */
-+            for (x = l->head_sentinel->next; x != l->tail_sentinel; x = x->next) {
-+                ser_buf = l->attrs.serializer(x->data, &bufsize);
-+                header.totlistlen += bufsize;
-+                if (header.elemlen != 0) {      /* continue on speculation */
-+                    if (header.elemlen != bufsize) {
-+                        free(ser_buf);
-+                        /* constant element length speculation broken! */
-+                        header.elemlen = 0;
-+                        header.totlistlen = 0;
-+                        x = l->head_sentinel;
-+                        if (lseek(fd, SIMCLIST_DUMPFORMAT_HEADERLEN, SEEK_SET) < 0) {
-+                            /* errno set by lseek() */
-+                            return -1;
-+                        }
-+                        /* restart from the beginning */
-+                        continue;
-+                    }
-+                    /* speculation confirmed */
-+                    WRITE_ERRCHECK(fd, ser_buf, bufsize);
-+                } else {                        /* speculation found broken */
-+                    WRITE_ERRCHECK(fd, & bufsize, sizeof(size_t));
-+                    WRITE_ERRCHECK(fd, ser_buf, bufsize);
-+                }
-+                free(ser_buf);
-+            }
-+        } else if (l->attrs.meter != NULL) {
-+            header.elemlen = (uint32_t)l->attrs.meter(l->head_sentinel->next->data);
-+
-+            /* serialize the element straight from its data */
-+            for (x = l->head_sentinel->next; x != l->tail_sentinel; x = x->next) {
-+                bufsize = l->attrs.meter(x->data);
-+                header.totlistlen += bufsize;
-+                if (header.elemlen != 0) {
-+                    if (header.elemlen != bufsize) {
-+                        /* constant element length speculation broken! */
-+                        header.elemlen = 0;
-+                        header.totlistlen = 0;
-+                        x = l->head_sentinel;
-+                        /* restart from the beginning */
-+                        continue;
-+                    }
-+                    WRITE_ERRCHECK(fd, x->data, bufsize);
-+                } else {
-+                    WRITE_ERRCHECK(fd, &bufsize, sizeof(size_t));
-+                    WRITE_ERRCHECK(fd, x->data, bufsize);
-+                }
-+            }
-+        }
-+        /* adjust endianness */
-+        header.elemlen = htonl(header.elemlen);
-+        header.totlistlen = htonl(header.totlistlen);
-+    }
-+
-+    /* write random terminator */
-+    WRITE_ERRCHECK(fd, & header.rndterm, sizeof(header.rndterm));        /* list terminator */
-+
-+
-+    /* write header */
-+    lseek(fd, 0, SEEK_SET);
-+
-+    WRITE_ERRCHECK(fd, & header.ver, sizeof(header.ver));                        /* version */
-+    WRITE_ERRCHECK(fd, & header.timestamp_sec, sizeof(header.timestamp_sec));    /* timestamp seconds */
-+    WRITE_ERRCHECK(fd, & header.timestamp_usec, sizeof(header.timestamp_usec));  /* timestamp microseconds */
-+    WRITE_ERRCHECK(fd, & header.rndterm, sizeof(header.rndterm));                /* random terminator */
-+
-+    WRITE_ERRCHECK(fd, & header.totlistlen, sizeof(header.totlistlen));          /* total length of elements */
-+    WRITE_ERRCHECK(fd, & header.numels, sizeof(header.numels));                  /* number of elements */
-+    WRITE_ERRCHECK(fd, & header.elemlen, sizeof(header.elemlen));                /* size of each element, or 0 for independent */
-+    WRITE_ERRCHECK(fd, & header.listhash, sizeof(header.listhash));              /* list hash, or 0 for "ignore" */
-+
-+
-+    /* possibly store total written length in "len" */
-+    if (len != NULL) {
-+        *len = sizeof(header) + ntohl(header.totlistlen);
-+    }
-+
-+    return 0;
-+}
-+
-+int list_restore_filedescriptor(list_t *restrict l, int fd, size_t *restrict len) {
-+    struct list_dump_header_s header;
-+    unsigned long cnt;
-+    void *buf;
-+    uint32_t elsize, totreadlen, totmemorylen;
-+
-+    memset(& header, 0, sizeof(header));
-+
-+    /* read header */
-+
-+    /* version */
-+    READ_ERRCHECK(fd, &header.ver, sizeof(header.ver));
-+    header.ver = ntohs(header.ver);
-+    if (header.ver != SIMCLIST_DUMPFORMAT_VERSION) {
-+        errno = EILSEQ;
-+        return -1;
-+    }
-+
-+    /* timestamp */
-+    READ_ERRCHECK(fd, & header.timestamp_sec, sizeof(header.timestamp_sec));
-+    header.timestamp_sec = ntohl(header.timestamp_sec);
-+    READ_ERRCHECK(fd, & header.timestamp_usec, sizeof(header.timestamp_usec));
-+    header.timestamp_usec = ntohl(header.timestamp_usec);
-+
-+    /* list terminator */
-+    READ_ERRCHECK(fd, & header.rndterm, sizeof(header.rndterm));
-+
-+    header.rndterm = ntohl(header.rndterm);
-+
-+    /* total list size */
-+    READ_ERRCHECK(fd, & header.totlistlen, sizeof(header.totlistlen));
-+    header.totlistlen = ntohl(header.totlistlen);
-+
-+    /* number of elements */
-+    READ_ERRCHECK(fd, & header.numels, sizeof(header.numels));
-+    header.numels = ntohl(header.numels);
-+
-+    /* length of every element, or '0' = variable */
-+    READ_ERRCHECK(fd, & header.elemlen, sizeof(header.elemlen));
-+    header.elemlen = ntohl(header.elemlen);
-+
-+    /* list hash, or 0 = 'ignore' */
-+    READ_ERRCHECK(fd, & header.listhash, sizeof(header.listhash));
-+    header.listhash = ntohl(header.listhash);
-+
-+
-+    /* read content */
-+    totreadlen = totmemorylen = 0;
-+    if (header.elemlen > 0) {
-+        /* elements have constant size = header.elemlen */
-+        if (l->attrs.unserializer != NULL) {
-+            /* use unserializer */
-+            buf = malloc(header.elemlen);
-+            for (cnt = 0; cnt < header.numels; cnt++) {
-+                READ_ERRCHECK(fd, buf, header.elemlen);
-+                list_append(l, l->attrs.unserializer(buf, & elsize));
-+                totmemorylen += elsize;
-+            }
-+        } else {
-+            /* copy verbatim into memory */
-+            for (cnt = 0; cnt < header.numels; cnt++) {
-+                buf = malloc(header.elemlen);
-+                READ_ERRCHECK(fd, buf, header.elemlen);
-+                list_append(l, buf);
-+            }
-+            totmemorylen = header.numels * header.elemlen;
-+        }
-+        totreadlen = header.numels * header.elemlen;
-+    } else {
-+        /* elements have variable size. Each element is preceded by its size */
-+        if (l->attrs.unserializer != NULL) {
-+            /* use unserializer */
-+            for (cnt = 0; cnt < header.numels; cnt++) {
-+                READ_ERRCHECK(fd, & elsize, sizeof(elsize));
-+                buf = malloc((size_t)elsize);
-+                READ_ERRCHECK(fd, buf, elsize);
-+                totreadlen += elsize;
-+                list_append(l, l->attrs.unserializer(buf, & elsize));
-+                totmemorylen += elsize;
-+            }
-+        } else {
-+            /* copy verbatim into memory */
-+            for (cnt = 0; cnt < header.numels; cnt++) {
-+                READ_ERRCHECK(fd, & elsize, sizeof(elsize));
-+                buf = malloc(elsize);
-+                READ_ERRCHECK(fd, buf, elsize);
-+                totreadlen += elsize;
-+                list_append(l, buf);
-+            }
-+            totmemorylen = totreadlen;
-+        }
-+    }
-+
-+    READ_ERRCHECK(fd, &elsize, sizeof(elsize));  /* read list terminator */
-+    elsize = ntohl(elsize);
-+
-+    /* possibly verify the list consistency */
-+    /* wrt hash */
-+    /* don't do that
-+    if (header.listhash != 0 && header.listhash != list_hash(l)) {
-+        errno = ECANCELED;
-+        return -1;
-+    }
-+    */
-+
-+    /* wrt header */
-+    if (totreadlen != header.totlistlen && (int32_t)elsize == header.rndterm) {
-+        errno = EPROTO;
-+        return -1;
-+    }
-+
-+    /* wrt file */
-+    if (lseek(fd, 0, SEEK_CUR) != lseek(fd, 0, SEEK_END)) {
-+        errno = EPROTO;
-+        return -1;
-+    }
-+
-+    if (len != NULL) {
-+        *len = totmemorylen;
-+    }
-+
-+    return 0;
-+}
-+
-+int list_dump_file(const list_t *restrict l, const char *restrict filename, size_t *restrict len) {
-+    int fd, oflag, mode;
-+
-+#ifndef _WIN32
-+    oflag = O_RDWR | O_CREAT | O_TRUNC;
-+    mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
-+#else
-+    oflag = _O_RDWR | _O_CREAT | _O_TRUNC;
-+    mode = _S_IRUSR | _S_IWUSR | _S_IRGRP | _S_IROTH;
-+#endif
-+    fd = open(filename, oflag, mode);
-+    if (fd < 0) return -1;
-+
-+    list_dump_filedescriptor(l, fd, len);
-+    close(fd);
-+
-+    return 0;
-+}
-+
-+int list_restore_file(list_t *restrict l, const char *restrict filename, size_t *restrict len) {
-+    int fd;
-+
-+    fd = open(filename, O_RDONLY, 0);
-+    if (fd < 0) return -1;
-+
-+    list_restore_filedescriptor(l, fd, len);
-+    close(fd);
-+
-+    return 0;
-+}
-+#endif /* ifndef SIMCLIST_NO_DUMPRESTORE */
-+
-+
-+static int list_drop_elem(list_t *restrict l, struct list_entry_s *tmp, unsigned int pos) {
-+    if (tmp == NULL) return -1;
-+
-+    /* fix mid pointer. This is wrt the PRE situation */
-+    if (l->numels % 2) {    /* now odd */
-+        /* sort out the base case by hand */
-+        if (l->numels == 1) l->mid = NULL;
-+        else if (pos >= l->numels/2) l->mid = l->mid->prev;
-+    } else {                /* now even */
-+        if (pos < l->numels/2) l->mid = l->mid->next;
-+    }
-+
-+    tmp->prev->next = tmp->next;
-+    tmp->next->prev = tmp->prev;
-+
-+    /* free what's to be freed */
-+    if (l->attrs.copy_data && tmp->data != NULL)
-+        free(tmp->data);
-+
-+    if (l->spareelsnum < SIMCLIST_MAX_SPARE_ELEMS) {
-+        l->spareels[l->spareelsnum++] = tmp;
-+    } else {
-+        free(tmp);
-+    }
-+
-+    return 0;
-+}
-+
-+/* ready-made comparators and meters */
-+#define SIMCLIST_NUMBER_COMPARATOR(type)     int list_comparator_##type(const void *a, const void *b) { return( *(type *)a < *(type *)b) - (*(type *)a > *(type *)b); }
-+
-+SIMCLIST_NUMBER_COMPARATOR(int8_t)
-+SIMCLIST_NUMBER_COMPARATOR(int16_t)
-+SIMCLIST_NUMBER_COMPARATOR(int32_t)
-+SIMCLIST_NUMBER_COMPARATOR(int64_t)
-+
-+SIMCLIST_NUMBER_COMPARATOR(uint8_t)
-+SIMCLIST_NUMBER_COMPARATOR(uint16_t)
-+SIMCLIST_NUMBER_COMPARATOR(uint32_t)
-+SIMCLIST_NUMBER_COMPARATOR(uint64_t)
-+
-+SIMCLIST_NUMBER_COMPARATOR(float)
-+SIMCLIST_NUMBER_COMPARATOR(double)
-+
-+int list_comparator_string(const void *a, const void *b) { return strcmp((const char *)b, (const char *)a); }
-+
-+/* ready-made metric functions */
-+#define SIMCLIST_METER(type)        size_t list_meter_##type(const void *el) { if (el) { /* kill compiler whinge */ } return sizeof(type); }
-+
-+SIMCLIST_METER(int8_t)
-+SIMCLIST_METER(int16_t)
-+SIMCLIST_METER(int32_t)
-+SIMCLIST_METER(int64_t)
-+
-+SIMCLIST_METER(uint8_t)
-+SIMCLIST_METER(uint16_t)
-+SIMCLIST_METER(uint32_t)
-+SIMCLIST_METER(uint64_t)
-+
-+SIMCLIST_METER(float)
-+SIMCLIST_METER(double)
-+
-+size_t list_meter_string(const void *el) { return strlen((const char *)el) + 1; }
-+
-+/* ready-made hashing functions */
-+#define SIMCLIST_HASHCOMPUTER(type)    list_hash_t list_hashcomputer_##type(const void *el) { return (list_hash_t)(*(type *)el); }
-+
-+SIMCLIST_HASHCOMPUTER(int8_t)
-+SIMCLIST_HASHCOMPUTER(int16_t)
-+SIMCLIST_HASHCOMPUTER(int32_t)
-+SIMCLIST_HASHCOMPUTER(int64_t)
-+
-+SIMCLIST_HASHCOMPUTER(uint8_t)
-+SIMCLIST_HASHCOMPUTER(uint16_t)
-+SIMCLIST_HASHCOMPUTER(uint32_t)
-+SIMCLIST_HASHCOMPUTER(uint64_t)
-+
-+SIMCLIST_HASHCOMPUTER(float)
-+SIMCLIST_HASHCOMPUTER(double)
-+
-+list_hash_t list_hashcomputer_string(const void *el) {
-+    size_t l;
-+    list_hash_t hash = 123;
-+    const char *str = (const char *)el;
-+    char plus;
-+
-+    for (l = 0; str[l] != '\0'; l++) {
-+        if (l) plus = hash ^ str[l];
-+        else plus = hash ^ (str[l] - str[0]);
-+        hash += (plus << (CHAR_BIT * (l % sizeof(list_hash_t))));
-+    }
-+
-+    return hash;
-+}
-+
-+
-+#ifndef NDEBUG
-+static int list_repOk(const list_t *restrict l) {
-+    int ok, i;
-+    struct list_entry_s *s;
-+
-+    ok = (l != NULL) && (
-+            /* head/tail checks */
-+            (l->head_sentinel != NULL && l->tail_sentinel != NULL) &&
-+                (l->head_sentinel != l->tail_sentinel) && (l->head_sentinel->prev == NULL && l->tail_sentinel->next == NULL) &&
-+            /* empty list */
-+            (l->numels > 0 || (l->mid == NULL && l->head_sentinel->next == l->tail_sentinel && l->tail_sentinel->prev == l->head_sentinel)) &&
-+            /* spare elements checks */
-+            l->spareelsnum <= SIMCLIST_MAX_SPARE_ELEMS
-+         );
-+
-+    if (!ok) return 0;
-+
-+    if (l->numels >= 1) {
-+        /* correct referencing */
-+        for (i = -1, s = l->head_sentinel; i < (int)(l->numels-1)/2 && s->next != NULL; i++, s = s->next) {
-+            if (s->next->prev != s) break;
-+        }
-+        ok = (i == (int)(l->numels-1)/2 && l->mid == s);
-+        if (!ok) return 0;
-+        for (; s->next != NULL; i++, s = s->next) {
-+            if (s->next->prev != s) break;
-+        }
-+        ok = (i == (int)l->numels && s == l->tail_sentinel);
-+    }
-+
-+    return ok;
-+}
-+
-+static int list_attrOk(const list_t *restrict l) {
-+    int ok;
-+
-+    ok = (l->attrs.copy_data == 0 || l->attrs.meter != NULL);
-+    return ok;
-+}
-+
-+#endif
-+
-diff --git a/src/simclist.h b/src/simclist.h
-deleted file mode 120000
-index 8a44093..0000000
---- a/src/simclist.h
-+++ /dev/null
-@@ -1 +0,0 @@
--../PCSC/src/simclist.h
-\ No newline at end of file
-diff --git a/src/simclist.h b/src/simclist.h
-new file mode 100644
-index 0000000..2ce9d49
---- /dev/null
-+++ b/src/simclist.h
-@@ -0,0 +1,980 @@
-+/*
-+ * Copyright (c) 2007,2008 Mij <mij@bitchx.it>
-+ *
-+ * Permission to use, copy, modify, and distribute this software for any
-+ * purpose with or without fee is hereby granted, provided that the above
-+ * copyright notice and this permission notice appear in all copies.
-+ *
-+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-+ */
-+
-+
-+/*
-+ * SimCList library. See http://mij.oltrelinux.com/devel/simclist
-+ */
-+
-+
-+#ifndef SIMCLIST_H
-+#define SIMCLIST_H
-+
-+#ifdef __cplusplus
-+extern "C" {
-+#endif
-+
-+#include <inttypes.h>
-+#include <errno.h>
-+#include <sys/types.h>
-+
-+#ifndef SIMCLIST_NO_DUMPRESTORE
-+#   ifndef _WIN32
-+#       include <sys/time.h>    /* list_dump_info_t's struct timeval */
-+#   else
-+#       include <time.h>
-+#   endif
-+#endif
-+
-+
-+/* Be friend of both C90 and C99 compilers */
-+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-+    /* "inline" and "restrict" are keywords */
-+#else
-+#   define inline           /* inline */
-+#   define restrict         /* restrict */
-+#endif
-+
-+
-+/**
-+ * Type representing list hashes.
-+ *
-+ * This is a signed integer value.
-+ */
-+typedef int32_t list_hash_t;
-+
-+#ifndef SIMCLIST_NO_DUMPRESTORE
-+typedef struct {
-+    uint16_t version;           /* dump version */
-+    struct timeval timestamp;   /* when the list has been dumped, seconds since UNIX epoch */
-+    uint32_t list_size;
-+    uint32_t list_numels;
-+    list_hash_t list_hash;      /* hash of the list when dumped, or 0 if invalid */
-+    uint32_t dumpsize;
-+    int consistent;             /* 1 if the dump is verified complete/consistent; 0 otherwise */
-+} list_dump_info_t;
-+#endif
-+
-+/**
-+ * a comparator of elements.
-+ *
-+ * A comparator of elements is a function that:
-+ *      -# receives two references to elements a and b
-+ *      -# returns {<0, 0, >0} if (a > b), (a == b), (a < b) respectively
-+ *
-+ * It is responsability of the function to handle possible NULL values.
-+ */
-+typedef int (*element_comparator)(const void *a, const void *b);
-+
-+/**
-+ * a seeker of elements.
-+ *
-+ * An element seeker is a function that:
-+ *      -# receives a reference to an element el
-+ *      -# receives a reference to some indicator data
-+ *      -# returns non-0 if the element matches the indicator, 0 otherwise
-+ *
-+ * It is responsability of the function to handle possible NULL values in any
-+ * argument.
-+ */
-+typedef int (*element_seeker)(const void *el, const void *indicator);
-+
-+/**
-+ * an element lenght meter.
-+ *
-+ * An element meter is a function that:
-+ *      -# receives the reference to an element el
-+ *      -# returns its size in bytes
-+ *
-+ * It is responsability of the function to handle possible NULL values.
-+ */
-+typedef size_t (*element_meter)(const void *el);
-+
-+/**
-+ * a function computing the hash of elements.
-+ *
-+ * An hash computing function is a function that:
-+ *      -# receives the reference to an element el
-+ *      -# returns a hash value for el
-+ *
-+ * It is responsability of the function to handle possible NULL values.
-+ */
-+typedef list_hash_t (*element_hash_computer)(const void *el);
-+
-+/**
-+ * a function for serializing an element.
-+ *
-+ * A serializer function is one that gets a reference to an element,
-+ * and returns a reference to a buffer that contains its serialization
-+ * along with the length of this buffer.
-+ * It is responsability of the function to handle possible NULL values,
-+ * returning a NULL buffer and a 0 buffer length.
-+ *
-+ * These functions have 3 goals:
-+ *  -# "freeze" and "flatten" the memory representation of the element
-+ *  -# provide a portable (wrt byte order, or type size) representation of the element, if the dump can be used on different sw/hw combinations
-+ *  -# possibly extract a compressed representation of the element
-+ *
-+ * @param el                reference to the element data
-+ * @param serialize_buffer  reference to fill with the length of the buffer
-+ * @return                  reference to the buffer with the serialized data
-+ */
-+typedef void *(*element_serializer)(const void *restrict el, uint32_t *restrict serializ_len);
-+
-+/**
-+ * a function for un-serializing an element.
-+ *
-+ * An unserializer function accomplishes the inverse operation of the
-+ * serializer function.  An unserializer function is one that gets a
-+ * serialized representation of an element and turns it backe to the original
-+ * element. The serialized representation is passed as a reference to a buffer
-+ * with its data, and the function allocates and returns the buffer containing
-+ * the original element, and it sets the length of this buffer into the
-+ * integer passed by reference.
-+ *
-+ * @param data              reference to the buffer with the serialized representation of the element
-+ * @param data_len          reference to the location where to store the length of the data in the buffer returned
-+ * @return                  reference to a buffer with the original, unserialized representation of the element
-+ */
-+typedef void *(*element_unserializer)(const void *restrict data, uint32_t *restrict data_len);
-+
-+/* [private-use] list entry -- olds actual user datum */
-+struct list_entry_s {
-+    void *data;
-+
-+    /* doubly-linked list service references */
-+    struct list_entry_s *next;
-+    struct list_entry_s *prev;
-+};
-+
-+/* [private-use] list attributes */
-+struct list_attributes_s {
-+    /* user-set routine for comparing list elements */
-+    element_comparator comparator;
-+    /* user-set routing for seeking elements */
-+    element_seeker seeker;
-+    /* user-set routine for determining the length of an element */
-+    element_meter meter;
-+    int copy_data;
-+    /* user-set routine for computing the hash of an element */
-+    element_hash_computer hasher;
-+    /* user-set routine for serializing an element */
-+    element_serializer serializer;
-+    /* user-set routine for unserializing an element */
-+    element_unserializer unserializer;
-+};
-+
-+/** list object */
-+typedef struct {
-+    struct list_entry_s *head_sentinel;
-+    struct list_entry_s *tail_sentinel;
-+    struct list_entry_s *mid;
-+
-+    unsigned int numels;
-+
-+    /* array of spare elements */
-+    struct list_entry_s **spareels;
-+    unsigned int spareelsnum;
-+
-+#ifdef SIMCLIST_WITH_THREADS
-+    /* how many threads are currently running */
-+    unsigned int threadcount;
-+#endif
-+
-+    /* service variables for list iteration */
-+    int iter_active;
-+    unsigned int iter_pos;
-+    struct list_entry_s *iter_curentry;
-+
-+    /* list attributes */
-+    struct list_attributes_s attrs;
-+} list_t;
-+
-+/**
-+ * initialize a list object for use.
-+ *
-+ * @param l     must point to a user-provided memory location
-+ * @return      0 for success. -1 for failure
-+ */
-+int list_init(list_t *restrict l);
-+
-+/**
-+ * completely remove the list from memory.
-+ *
-+ * This function is the inverse of list_init(). It is meant to be called when
-+ * the list is no longer going to be used. Elements and possible memory taken
-+ * for internal use are freed.
-+ *
-+ * @param l     list to destroy
-+ */
-+void list_destroy(list_t *restrict l);
-+
-+/**
-+ * set the comparator function for list elements.
-+ *
-+ * Comparator functions are used for searching and sorting. If NULL is passed
-+ * as reference to the function, the comparator is disabled.
-+ *
-+ * @param l     list to operate
-+ * @param comparator_fun    pointer to the actual comparator function
-+ * @return      0 if the attribute was successfully set; -1 otherwise
-+ *
-+ * @see element_comparator()
-+ */
-+int list_attributes_comparator(list_t *restrict l, element_comparator comparator_fun);
-+
-+/**
-+ * set a seeker function for list elements.
-+ *
-+ * Seeker functions are used for finding elements. If NULL is passed as reference
-+ * to the function, the seeker is disabled.
-+ *
-+ * @param l     list to operate
-+ * @param seeker_fun    pointer to the actual seeker function
-+ * @return      0 if the attribute was successfully set; -1 otherwise
-+ *
-+ * @see element_seeker()
-+ */
-+int list_attributes_seeker(list_t *restrict l, element_seeker seeker_fun);
-+
-+/**
-+ * require to free element data when list entry is removed (default: don't free).
-+ *
-+ * [ advanced preference ]
-+ *
-+ * By default, when an element is removed from the list, it disappears from
-+ * the list by its actual data is not free()d. With this option, every
-+ * deletion causes element data to be freed.
-+ *
-+ * It is responsability of this function to correctly handle NULL values, if
-+ * NULL elements are inserted into the list.
-+ *
-+ * @param l             list to operate
-+ * @param metric_fun    pointer to the actual metric function
-+ * @param copy_data     0: do not free element data (default); non-0: do free
-+ * @return          0 if the attribute was successfully set; -1 otherwise
-+ *
-+ * @see element_meter()
-+ * @see list_meter_int8_t()
-+ * @see list_meter_int16_t()
-+ * @see list_meter_int32_t()
-+ * @see list_meter_int64_t()
-+ * @see list_meter_uint8_t()
-+ * @see list_meter_uint16_t()
-+ * @see list_meter_uint32_t()
-+ * @see list_meter_uint64_t()
-+ * @see list_meter_float()
-+ * @see list_meter_double()
-+ * @see list_meter_string()
-+ */
-+int list_attributes_copy(list_t *restrict l, element_meter metric_fun, int copy_data);
-+
-+/**
-+ * set the element hash computing function for the list elements.
-+ *
-+ * [ advanced preference ]
-+ *
-+ * An hash can be requested depicting the list status at a given time. An hash
-+ * only depends on the elements and their order. By default, the hash of an
-+ * element is only computed on its reference. With this function, the user can
-+ * set a custom function computing the hash of an element. If such function is
-+ * provided, the list_hash() function automatically computes the list hash using
-+ * the custom function instead of simply referring to element references.
-+ *
-+ * @param l             list to operate
-+ * @param hash_computer_fun pointer to the actual hash computing function
-+ * @return              0 if the attribute was successfully set; -1 otherwise
-+ *
-+ * @see element_hash_computer()
-+ */
-+int list_attributes_hash_computer(list_t *restrict l, element_hash_computer hash_computer_fun);
-+
-+/**
-+ * set the element serializer function for the list elements.
-+ *
-+ * [ advanced preference ]
-+ *
-+ * Serialize functions are used for dumping the list to some persistent
-+ * storage.  The serializer function is called for each element; it is passed
-+ * a reference to the element and a reference to a size_t object. It will
-+ * provide (and return) the buffer with the serialization of the element and
-+ * fill the size_t object with the length of this serialization data.
-+ *
-+ * @param   l   list to operate
-+ * @param   serializer_fun  pointer to the actual serializer function
-+ * @return      0 if the attribute was successfully set; -1 otherwise
-+ *
-+ * @see     element_serializer()
-+ * @see     list_dump_filedescriptor()
-+ * @see     list_restore_filedescriptor()
-+ */
-+int list_attributes_serializer(list_t *restrict l, element_serializer serializer_fun);
-+
-+/**
-+ * set the element unserializer function for the list elements.
-+ *
-+ * [ advanced preference ]
-+ *
-+ * Unserialize functions are used for restoring the list from some persistent
-+ * storage. The unserializer function is called for each element segment read
-+ * from the storage; it is passed the segment and a reference to an integer.
-+ * It shall allocate and return a buffer compiled with the resumed memory
-+ * representation of the element, and set the integer value to the length of
-+ * this buffer.
-+ *
-+ * @param   l       list to operate
-+ * @param   unserializer_fun    pointer to the actual unserializer function
-+ * @return      0 if the attribute was successfully set; -1 otherwise
-+ *
-+ * @see     element_unserializer()
-+ * @see     list_dump_filedescriptor()
-+ * @see     list_restore_filedescriptor()
-+ */
-+int list_attributes_unserializer(list_t *restrict l, element_unserializer unserializer_fun);
-+
-+/**
-+ * append data at the end of the list.
-+ *
-+ * This function is useful for adding elements with a FIFO/queue policy.
-+ *
-+ * @param l     list to operate
-+ * @param data  pointer to user data to append
-+ *
-+ * @return      1 for success. < 0 for failure
-+ */
-+int list_append(list_t *restrict l, const void *data);
-+
-+/**
-+ * insert data in the head of the list.
-+ *
-+ * This function is useful for adding elements with a LIFO/Stack policy.
-+ *
-+ * @param l     list to operate
-+ * @param data  pointer to user data to append
-+ *
-+ * @return      1 for success. < 0 for failure
-+ */
-+int list_prepend(list_t *restrict l, const void *restrict data);
-+
-+/**
-+ * extract the element in the top of the list.
-+ *
-+ * This function is for using a list with a FIFO/queue policy.
-+ *
-+ * @param l     list to operate
-+ * @return      reference to user datum, or NULL on errors
-+ */
-+void *list_fetch(list_t *restrict l);
-+
-+/**
-+ * retrieve an element at a given position.
-+ *
-+ * @param l     list to operate
-+ * @param pos   [0,size-1] position index of the element wanted
-+ * @return      reference to user datum, or NULL on errors
-+ */
-+void *list_get_at(const list_t *restrict l, unsigned int pos);
-+
-+/**
-+ * return the maximum element of the list.
-+ *
-+ * @warning Requires a comparator function to be set for the list.
-+ *
-+ * Returns the maximum element with respect to the comparator function output.
-+ * 
-+ * @see list_attributes_comparator()
-+ *
-+ * @param l     list to operate
-+ * @return      the reference to the element, or NULL
-+ */
-+void *list_get_max(const list_t *restrict l);
-+
-+/**
-+ * return the minimum element of the list.
-+ *
-+ * @warning Requires a comparator function to be set for the list.
-+ *
-+ * Returns the minimum element with respect to the comparator function output.
-+ *
-+ * @see list_attributes_comparator()
-+ *
-+ * @param l     list to operate
-+ * @return      the reference to the element, or NULL
-+ */
-+void *list_get_min(const list_t *restrict l);
-+
-+/**
-+ * retrieve and remove from list an element at a given position.
-+ *
-+ * @param l     list to operate
-+ * @param pos   [0,size-1] position index of the element wanted
-+ * @return      reference to user datum, or NULL on errors
-+ */
-+void *list_extract_at(list_t *restrict l, unsigned int pos);
-+
-+/**
-+ * insert an element at a given position.
-+ *
-+ * @param l     list to operate
-+ * @param data  reference to data to be inserted
-+ * @param pos   [0,size-1] position index to insert the element at
-+ * @return      positive value on success. Negative on failure
-+ */
-+int list_insert_at(list_t *restrict l, const void *data, unsigned int pos);
-+
-+/**
-+ * expunge the first found given element from the list.
-+ *
-+ * Inspects the given list looking for the given element; if the element
-+ * is found, it is removed. Only the first occurence is removed.
-+ * If a comparator function was not set, elements are compared by reference.
-+ * Otherwise, the comparator is used to match the element.
-+ *
-+ * @param l     list to operate
-+ * @param data  reference of the element to search for
-+ * @return      0 on success. Negative value on failure
-+ *
-+ * @see list_attributes_comparator()
-+ * @see list_delete_at()
-+ */
-+int list_delete(list_t *restrict l, const void *data);
-+
-+/**
-+ * expunge an element at a given position from the list.
-+ *
-+ * @param l     list to operate
-+ * @param pos   [0,size-1] position index of the element to be deleted
-+ * @return      0 on success. Negative value on failure
-+ */
-+int list_delete_at(list_t *restrict l, unsigned int pos);
-+
-+/**
-+ * expunge an array of elements from the list, given their position range.
-+ *
-+ * @param l     list to operate
-+ * @param posstart  [0,size-1] position index of the first element to be deleted
-+ * @param posend    [posstart,size-1] position of the last element to be deleted
-+ * @return      the number of elements successfully removed on success, <0 on error
-+ */
-+int list_delete_range(list_t *restrict l, unsigned int posstart, unsigned int posend);
-+
-+/**
-+ * clear all the elements off of the list.
-+ *
-+ * The element datums will not be freed.
-+ *
-+ * @see list_delete_range()
-+ * @see list_size()
-+ *
-+ * @param l     list to operate
-+ * @return      the number of elements removed on success, <0 on error
-+ */
-+int list_clear(list_t *restrict l);
-+
-+/**
-+ * inspect the number of elements in the list.
-+ *
-+ * @param l     list to operate
-+ * @return      number of elements currently held by the list
-+ */
-+unsigned int list_size(const list_t *restrict l);
-+
-+/**
-+ * inspect whether the list is empty.
-+ *
-+ * @param l     list to operate
-+ * @return      0 iff the list is not empty
-+ * 
-+ * @see list_size()
-+ */
-+int list_empty(const list_t *restrict l);
-+
-+/**
-+ * find the position of an element in a list.
-+ *
-+ * @warning Requires a comparator function to be set for the list.
-+ *
-+ * Inspects the given list looking for the given element; if the element
-+ * is found, its position into the list is returned.
-+ * Elements are inspected comparing references if a comparator has not been
-+ * set. Otherwise, the comparator is used to find the element.
-+ *
-+ * @param l     list to operate
-+ * @param data  reference of the element to search for
-+ * @return      position of element in the list, or <0 if not found
-+ * 
-+ * @see list_attributes_comparator()
-+ * @see list_get_at()
-+ */
-+int list_locate(const list_t *restrict l, const void *data);
-+
-+/**
-+ * returns an element given an indicator.
-+ *
-+ * @warning Requires a seeker function to be set for the list.
-+ *
-+ * Inspect the given list looking with the seeker if an element matches
-+ * an indicator. If such element is found, the reference to the element
-+ * is returned.
-+ *
-+ * @param l     list to operate
-+ * @param indicator indicator data to pass to the seeker along with elements
-+ * @return      reference to the element accepted by the seeker, or NULL if none found
-+ */
-+void *list_seek(list_t *restrict l, const void *indicator);
-+
-+/**
-+ * inspect whether some data is member of the list.
-+ *
-+ * @warning Requires a comparator function to be set for the list.
-+ *
-+ * By default, a per-reference comparison is accomplished. That is,
-+ * the data is in list if any element of the list points to the same
-+ * location of data.
-+ * A "semantic" comparison is accomplished, otherwise, if a comparator
-+ * function has been set previously, with list_attributes_comparator();
-+ * in which case, the given data reference is believed to be in list iff
-+ * comparator_fun(elementdata, userdata) == 0 for any element in the list.
-+ * 
-+ * @param l     list to operate
-+ * @param data  reference to the data to search
-+ * @return      0 iff the list does not contain data as an element
-+ *
-+ * @see list_attributes_comparator()
-+ */
-+int list_contains(const list_t *restrict l, const void *data);
-+
-+/**
-+ * concatenate two lists
-+ *
-+ * Concatenates one list with another, and stores the result into a
-+ * user-provided list object, which must be different from both the
-+ * lists to concatenate. Attributes from the original lists are not
-+ * cloned.
-+ * The destination list referred is threated as virgin room: if it
-+ * is an existing list containing elements, memory leaks will happen.
-+ * It is OK to specify the same list twice as source, for "doubling"
-+ * it in the destination.
-+ *
-+ * @param l1    base list
-+ * @param l2    list to append to the base
-+ * @param dest  reference to the destination list
-+ * @return      0 for success, -1 for errors
-+ */
-+int list_concat(const list_t *l1, const list_t *l2, list_t *restrict dest);
-+
-+/**
-+ * sort list elements.
-+ *
-+ * @warning Requires a comparator function to be set for the list.
-+ *
-+ * Sorts the list in ascending or descending order as specified by the versus
-+ * flag. The algorithm chooses autonomously what algorithm is best suited for
-+ * sorting the list wrt its current status.
-+ *
-+ * @param l     list to operate
-+ * @param versus positive: order small to big; negative: order big to small
-+ * @return      0 iff sorting was successful
-+ *
-+ * @see list_attributes_comparator()
-+ */
-+int list_sort(list_t *restrict l, int versus);
-+
-+/**
-+ * start an iteration session.
-+ *
-+ * This function prepares the list to be iterated.
-+ *
-+ * @param l     list to operate
-+ * @return 		0 if the list cannot be currently iterated. >0 otherwise
-+ * 
-+ * @see list_iterator_stop()
-+ */
-+int list_iterator_start(list_t *restrict l);
-+
-+/**
-+ * return the next element in the iteration session.
-+ *
-+ * @param l     list to operate
-+ * @return		element datum, or NULL on errors
-+ */
-+void *list_iterator_next(list_t *restrict l);
-+
-+/**
-+ * inspect whether more elements are available in the iteration session.
-+ *
-+ * @param l     list to operate
-+ * @return      0 iff no more elements are available.
-+ */
-+int list_iterator_hasnext(const list_t *restrict l);
-+
-+/**
-+ * end an iteration session.
-+ *
-+ * @param l     list to operate
-+ * @return      0 iff the iteration session cannot be stopped
-+ */
-+int list_iterator_stop(list_t *restrict l);
-+
-+/**
-+ * return the hash of the current status of the list.
-+ *
-+ * @param l     list to operate
-+ * @param hash  where the resulting hash is put
-+ *
-+ * @return      0 for success; <0 for failure
-+ */
-+int list_hash(const list_t *restrict l, list_hash_t *restrict hash);
-+
-+#ifndef SIMCLIST_NO_DUMPRESTORE
-+/**
-+ * get meta informations on a list dump on filedescriptor.
-+ *
-+ * [ advanced function ]
-+ *
-+ * Extracts the meta information from a SimCList dump located in a file
-+ * descriptor. The file descriptor must be open and positioned at the
-+ * beginning of the SimCList dump block.
-+ *
-+ * @param fd        file descriptor to get metadata from
-+ * @param info      reference to a dump metainformation structure to fill
-+ * @return          0 for success; <0 for failure
-+ *
-+ * @see list_dump_filedescriptor()
-+ */
-+int list_dump_getinfo_filedescriptor(int fd, list_dump_info_t *restrict info);
-+
-+/**
-+ * get meta informations on a list dump on file.
-+ *
-+ * [ advanced function ]
-+ *
-+ * Extracts the meta information from a SimCList dump located in a file.
-+ *
-+ * @param filename  filename of the file to fetch from
-+ * @param info      reference to a dump metainformation structure to fill
-+ * @return          0 for success; <0 for failure
-+ *
-+ * @see list_dump_filedescriptor()
-+ */
-+int list_dump_getinfo_file(const char *restrict filename, list_dump_info_t *restrict info);
-+
-+/**
-+ * dump the list into an open, writable file descriptor.
-+ *
-+ * This function "dumps" the list to a persistent storage so it can be
-+ * preserved across process terminations.
-+ * When called, the file descriptor must be open for writing and positioned
-+ * where the serialized data must begin. It writes its serialization of the
-+ * list in a form which is portable across different architectures. Dump can
-+ * be safely performed on stream-only (non seekable) descriptors. The file
-+ * descriptor is not closed at the end of the operations.
-+ *
-+ * To use dump functions, either of these conditions must be satisfied:
-+ *      -# a metric function has been specified with list_attributes_copy()
-+ *      -# a serializer function has been specified with list_attributes_serializer()
-+ *
-+ * If a metric function has been specified, each element of the list is dumped
-+ * as-is from memory, copying it from its pointer for its length down to the
-+ * file descriptor. This might have impacts on portability of the dump to
-+ * different architectures.
-+ *
-+ * If a serializer function has been specified, its result for each element is
-+ * dumped to the file descriptor.
-+ *
-+ *
-+ * @param l     list to operate
-+ * @param fd    file descriptor to write to
-+ * @param len   location to store the resulting length of the dump (bytes), or NULL
-+ *
-+ * @return      0 if successful; -1 otherwise
-+ *
-+ * @see element_serializer()
-+ * @see list_attributes_copy()
-+ * @see list_attributes_serializer()
-+ */
-+int list_dump_filedescriptor(const list_t *restrict l, int fd, size_t *restrict len);
-+
-+/**
-+ * dump the list to a file name.
-+ *
-+ * This function creates a filename and dumps the current content of the list
-+ * to it. If the file exists it is overwritten. The number of bytes written to
-+ * the file can be returned in a specified argument.
-+ *
-+ * @param l     list to operate
-+ * @param filename    filename to write to
-+ * @param len   location to store the resulting length of the dump (bytes), or NULL
-+ *
-+ * @return      0 if successful; -1 otherwise
-+ *
-+ * @see list_attributes_copy()
-+ * @see element_serializer()
-+ * @see list_attributes_serializer()
-+ * @see list_dump_filedescriptor()
-+ * @see list_restore_file()
-+ *
-+ * This function stores a representation of the list 
-+ */
-+int list_dump_file(const list_t *restrict l, const char *restrict filename, size_t *restrict len);
-+
-+/**
-+ * restore the list from an open, readable file descriptor to memory.
-+ *
-+ * This function is the "inverse" of list_dump_filedescriptor(). It restores
-+ * the list content from a (open, read-ready) file descriptor to memory. An
-+ * unserializer might be needed to restore elements from the persistent
-+ * representation back into memory-consistent format. List attributes can not
-+ * be restored and must be set manually.
-+ *
-+ * @see list_dump_filedescriptor()
-+ * @see list_attributes_serializer()
-+ * @see list_attributes_unserializer()
-+ *
-+ * @param l     list to restore to
-+ * @param fd    file descriptor to read from.
-+ * @param len   location to store the length of the dump read (bytes), or NULL
-+ * @return      0 if successful; -1 otherwise
-+ */
-+int list_restore_filedescriptor(list_t *restrict l, int fd, size_t *restrict len);
-+
-+/**
-+ * restore the list from a file name.
-+ *
-+ * This function restores the content of a list from a file into memory. It is
-+ * the inverse of list_dump_file().
-+ *
-+ * @see element_unserializer()
-+ * @see list_attributes_unserializer()
-+ * @see list_dump_file()
-+ * @see list_restore_filedescriptor()
-+ *
-+ * @param l         list to restore to
-+ * @param filename  filename to read data from
-+ * @param len       location to store the length of the dump read (bytes), or NULL
-+ * @return          0 if successful; -1 otherwise
-+ */
-+int list_restore_file(list_t *restrict l, const char *restrict filename, size_t *len);
-+#endif
-+
-+/* ready-made comparators, meters and hash computers */
-+                                /* comparator functions */
-+/**
-+ * ready-made comparator for int8_t elements.
-+ * @see list_attributes_comparator()
-+ */
-+int list_comparator_int8_t(const void *a, const void *b);
-+
-+/**
-+ * ready-made comparator for int16_t elements.
-+ * @see list_attributes_comparator()
-+ */
-+int list_comparator_int16_t(const void *a, const void *b);
-+
-+/**
-+ * ready-made comparator for int32_t elements.
-+ * @see list_attributes_comparator()
-+ */
-+int list_comparator_int32_t(const void *a, const void *b);
-+
-+/**
-+ * ready-made comparator for int64_t elements.
-+ * @see list_attributes_comparator()
-+ */
-+int list_comparator_int64_t(const void *a, const void *b);
-+
-+/**
-+ * ready-made comparator for uint8_t elements.
-+ * @see list_attributes_comparator()
-+ */
-+int list_comparator_uint8_t(const void *a, const void *b);
-+
-+/**
-+ * ready-made comparator for uint16_t elements.
-+ * @see list_attributes_comparator()
-+ */
-+int list_comparator_uint16_t(const void *a, const void *b);
-+
-+/**
-+ * ready-made comparator for uint32_t elements.
-+ * @see list_attributes_comparator()
-+ */
-+int list_comparator_uint32_t(const void *a, const void *b);
-+
-+/**
-+ * ready-made comparator for uint64_t elements.
-+ * @see list_attributes_comparator()
-+ */
-+int list_comparator_uint64_t(const void *a, const void *b);
-+
-+/**
-+ * ready-made comparator for float elements.
-+ * @see list_attributes_comparator()
-+ */
-+int list_comparator_float(const void *a, const void *b);
-+
-+/**
-+ * ready-made comparator for double elements.
-+ * @see list_attributes_comparator()
-+ */
-+int list_comparator_double(const void *a, const void *b);
-+
-+/**
-+ * ready-made comparator for string elements.
-+ * @see list_attributes_comparator()
-+ */
-+int list_comparator_string(const void *a, const void *b);
-+
-+                                /*          metric functions        */
-+/**
-+ * ready-made metric function for int8_t elements.
-+ * @see list_attributes_copy()
-+ */
-+size_t list_meter_int8_t(const void *el);
-+
-+/**
-+ * ready-made metric function for int16_t elements.
-+ * @see list_attributes_copy()
-+ */
-+size_t list_meter_int16_t(const void *el);
-+
-+/**
-+ * ready-made metric function for int32_t elements.
-+ * @see list_attributes_copy()
-+ */
-+size_t list_meter_int32_t(const void *el);
-+
-+/**
-+ * ready-made metric function for int64_t elements.
-+ * @see list_attributes_copy()
-+ */
-+size_t list_meter_int64_t(const void *el);
-+
-+/**
-+ * ready-made metric function for uint8_t elements.
-+ * @see list_attributes_copy()
-+ */
-+size_t list_meter_uint8_t(const void *el);
-+
-+/**
-+ * ready-made metric function for uint16_t elements.
-+ * @see list_attributes_copy()
-+ */
-+size_t list_meter_uint16_t(const void *el);
-+
-+/**
-+ * ready-made metric function for uint32_t elements.
-+ * @see list_attributes_copy()
-+ */
-+size_t list_meter_uint32_t(const void *el);
-+
-+/**
-+ * ready-made metric function for uint64_t elements.
-+ * @see list_attributes_copy()
-+ */
-+size_t list_meter_uint64_t(const void *el);
-+
-+/**
-+ * ready-made metric function for float elements.
-+ * @see list_attributes_copy()
-+ */
-+size_t list_meter_float(const void *el);
-+
-+/**
-+ * ready-made metric function for double elements.
-+ * @see list_attributes_copy()
-+ */
-+size_t list_meter_double(const void *el);
-+
-+/**
-+ * ready-made metric function for string elements.
-+ * @see list_attributes_copy()
-+ */
-+size_t list_meter_string(const void *el);
-+
-+                                /*          hash functions          */
-+/**
-+ * ready-made hash function for int8_t elements.
-+ * @see list_attributes_hash_computer()
-+ */
-+list_hash_t list_hashcomputer_int8_t(const void *el);
-+
-+/**
-+ * ready-made hash function for int16_t elements.
-+ * @see list_attributes_hash_computer()
-+ */
-+list_hash_t list_hashcomputer_int16_t(const void *el);
-+
-+/**
-+ * ready-made hash function for int32_t elements.
-+ * @see list_attributes_hash_computer()
-+ */
-+list_hash_t list_hashcomputer_int32_t(const void *el);
-+
-+/**
-+ * ready-made hash function for int64_t elements.
-+ * @see list_attributes_hash_computer()
-+ */
-+list_hash_t list_hashcomputer_int64_t(const void *el);
-+
-+/**
-+ * ready-made hash function for uint8_t elements.
-+ * @see list_attributes_hash_computer()
-+ */
-+list_hash_t list_hashcomputer_uint8_t(const void *el);
-+
-+/**
-+ * ready-made hash function for uint16_t elements.
-+ * @see list_attributes_hash_computer()
-+ */
-+list_hash_t list_hashcomputer_uint16_t(const void *el);
-+
-+/**
-+ * ready-made hash function for uint32_t elements.
-+ * @see list_attributes_hash_computer()
-+ */
-+list_hash_t list_hashcomputer_uint32_t(const void *el);
-+
-+/**
-+ * ready-made hash function for uint64_t elements.
-+ * @see list_attributes_hash_computer()
-+ */
-+list_hash_t list_hashcomputer_uint64_t(const void *el);
-+
-+/**
-+ * ready-made hash function for float elements.
-+ * @see list_attributes_hash_computer()
-+ */
-+list_hash_t list_hashcomputer_float(const void *el);
-+
-+/**
-+ * ready-made hash function for double elements.
-+ * @see list_attributes_hash_computer()
-+ */
-+list_hash_t list_hashcomputer_double(const void *el);
-+
-+/**
-+ * ready-made hash function for string elements.
-+ * @see list_attributes_hash_computer()
-+ */
-+list_hash_t list_hashcomputer_string(const void *el);
-+
-+#ifdef __cplusplus
-+}
-+#endif
-+
-+#endif
-+
-diff --git a/src/strlcpy.c b/src/strlcpy.c
-deleted file mode 120000
-index bde77fc..0000000
---- a/src/strlcpy.c
-+++ /dev/null
-@@ -1 +0,0 @@
--../PCSC/src/strlcpy.c
-\ No newline at end of file
-diff --git a/src/strlcpy.c b/src/strlcpy.c
-new file mode 100644
-index 0000000..437df6d
---- /dev/null
-+++ b/src/strlcpy.c
-@@ -0,0 +1,60 @@
-+/*	$OpenBSD: strlcpy.c,v 1.10 2005/08/08 08:05:37 espie Exp $	*/
-+
-+/*
-+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
-+ *
-+ * Permission to use, copy, modify, and distribute this software for any
-+ * purpose with or without fee is hereby granted, provided that the above
-+ * copyright notice and this permission notice appear in all copies.
-+ *
-+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-+ */
-+
-+#ifdef HAVE_CONFIG_H
-+#include <config.h>
-+#endif
-+
-+#ifndef HAVE_STRLCPY
-+
-+#include <sys/types.h>
-+#include <string.h>
-+#include "strlcpycat.h"
-+
-+/*
-+ * Copy src to string dst of size siz.  At most siz-1 characters
-+ * will be copied.  Always NUL terminates (unless siz == 0).
-+ * Returns strlen(src); if retval >= siz, truncation occurred.
-+ */
-+size_t
-+strlcpy(char *dst, const char *src, size_t siz)
-+{
-+	char *d = dst;
-+	const char *s = src;
-+	size_t n = siz;
-+
-+	/* Copy as many bytes as will fit */
-+	if (n != 0 && --n != 0) {
-+		do {
-+			if ((*d++ = *s++) == 0)
-+				break;
-+		} while (--n != 0);
-+	}
-+
-+	/* Not enough room in dst, add NUL and traverse rest of src */
-+	if (n == 0) {
-+		if (siz != 0)
-+			*d = '\0';		/* NUL-terminate dst */
-+		while (*s++)
-+			;
-+	}
-+
-+	return(s - src - 1);	/* count does not include NUL */
-+}
-+
-+#endif
-diff --git a/src/strlcpycat.h b/src/strlcpycat.h
-deleted file mode 120000
-index c240eca..0000000
---- a/src/strlcpycat.h
-+++ /dev/null
-@@ -1 +0,0 @@
--../PCSC/src/strlcpycat.h
-\ No newline at end of file
-diff --git a/src/strlcpycat.h b/src/strlcpycat.h
-new file mode 100644
-index 0000000..82c264a
---- /dev/null
-+++ b/src/strlcpycat.h
-@@ -0,0 +1,45 @@
-+/*
-+ * MUSCLE SmartCard Development ( http://pcsclite.alioth.debian.org/pcsclite.html )
-+ *
-+ * Copyright (C) 2004-2010
-+ *  Ludovic Rousseau <ludovic.rousseau@free.fr>
-+ *
-+Redistribution and use in source and binary forms, with or without
-+modification, are permitted provided that the following conditions
-+are met:
-+
-+1. Redistributions of source code must retain the above copyright
-+   notice, this list of conditions and the following disclaimer.
-+2. Redistributions in binary form must reproduce the above copyright
-+   notice, this list of conditions and the following disclaimer in the
-+   documentation and/or other materials provided with the distribution.
-+3. The name of the author may not be used to endorse or promote products
-+   derived from this software without specific prior written permission.
-+
-+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+/**
-+ * @file
-+ * @brief prototypes of strlcpy()/strlcat() imported from OpenBSD
-+ */
-+
-+#ifdef HAVE_STRLCPY
-+#include <string.h>
-+#else
-+size_t strlcpy(char *dst, const char *src, size_t siz);
-+#endif
-+
-+#ifndef HAVE_STRLCAT
-+size_t strlcat(char *dst, const char *src, size_t siz);
-+#endif
-+
-diff --git a/src/tokenparser.c b/src/tokenparser.c
-new file mode 100644
-index 0000000..352e69e
---- /dev/null
-+++ b/src/tokenparser.c
-@@ -0,0 +1,2020 @@
-+
-+#line 3 "tokenparser.c"
-+
-+#define  YY_INT_ALIGNED short int
-+
-+/* A lexical scanner generated by flex */
-+
-+#define FLEX_SCANNER
-+#define YY_FLEX_MAJOR_VERSION 2
-+#define YY_FLEX_MINOR_VERSION 5
-+#define YY_FLEX_SUBMINOR_VERSION 39
-+#if YY_FLEX_SUBMINOR_VERSION > 0
-+#define FLEX_BETA
-+#endif
-+
-+/* First, we deal with  platform-specific or compiler-specific issues. */
-+
-+/* begin standard C headers. */
-+#include <stdio.h>
-+#include <string.h>
-+#include <errno.h>
-+#include <stdlib.h>
-+
-+/* end standard C headers. */
-+
-+/* flex integer type definitions */
-+
-+#ifndef FLEXINT_H
-+#define FLEXINT_H
-+
-+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
-+
-+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-+
-+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
-+ * if you want the limit (max/min) macros for int types. 
-+ */
-+#ifndef __STDC_LIMIT_MACROS
-+#define __STDC_LIMIT_MACROS 1
-+#endif
-+
-+#include <inttypes.h>
-+typedef int8_t flex_int8_t;
-+typedef uint8_t flex_uint8_t;
-+typedef int16_t flex_int16_t;
-+typedef uint16_t flex_uint16_t;
-+typedef int32_t flex_int32_t;
-+typedef uint32_t flex_uint32_t;
-+#else
-+typedef signed char flex_int8_t;
-+typedef short int flex_int16_t;
-+typedef int flex_int32_t;
-+typedef unsigned char flex_uint8_t; 
-+typedef unsigned short int flex_uint16_t;
-+typedef unsigned int flex_uint32_t;
-+
-+/* Limits of integral types. */
-+#ifndef INT8_MIN
-+#define INT8_MIN               (-128)
-+#endif
-+#ifndef INT16_MIN
-+#define INT16_MIN              (-32767-1)
-+#endif
-+#ifndef INT32_MIN
-+#define INT32_MIN              (-2147483647-1)
-+#endif
-+#ifndef INT8_MAX
-+#define INT8_MAX               (127)
-+#endif
-+#ifndef INT16_MAX
-+#define INT16_MAX              (32767)
-+#endif
-+#ifndef INT32_MAX
-+#define INT32_MAX              (2147483647)
-+#endif
-+#ifndef UINT8_MAX
-+#define UINT8_MAX              (255U)
-+#endif
-+#ifndef UINT16_MAX
-+#define UINT16_MAX             (65535U)
-+#endif
-+#ifndef UINT32_MAX
-+#define UINT32_MAX             (4294967295U)
-+#endif
-+
-+#endif /* ! C99 */
-+
-+#endif /* ! FLEXINT_H */
-+
-+#ifdef __cplusplus
-+
-+/* The "const" storage-class-modifier is valid. */
-+#define YY_USE_CONST
-+
-+#else	/* ! __cplusplus */
-+
-+/* C99 requires __STDC__ to be defined as 1. */
-+#if defined (__STDC__)
-+
-+#define YY_USE_CONST
-+
-+#endif	/* defined (__STDC__) */
-+#endif	/* ! __cplusplus */
-+
-+#ifdef YY_USE_CONST
-+#define yyconst const
-+#else
-+#define yyconst
-+#endif
-+
-+/* Returned upon end-of-file. */
-+#define YY_NULL 0
-+
-+/* Promotes a possibly negative, possibly signed char to an unsigned
-+ * integer for use as an array index.  If the signed char is negative,
-+ * we want to instead treat it as an 8-bit unsigned char, hence the
-+ * double cast.
-+ */
-+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
-+
-+/* Enter a start condition.  This macro really ought to take a parameter,
-+ * but we do it the disgusting crufty way forced on us by the ()-less
-+ * definition of BEGIN.
-+ */
-+#define BEGIN (yy_start) = 1 + 2 *
-+
-+/* Translate the current start state into a value that can be later handed
-+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
-+ * compatibility.
-+ */
-+#define YY_START (((yy_start) - 1) / 2)
-+#define YYSTATE YY_START
-+
-+/* Action number for EOF rule of a given start state. */
-+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
-+
-+/* Special action meaning "start processing a new file". */
-+#define YY_NEW_FILE yyrestart(yyin  )
-+
-+#define YY_END_OF_BUFFER_CHAR 0
-+
-+/* Size of default input buffer. */
-+#ifndef YY_BUF_SIZE
-+#ifdef __ia64__
-+/* On IA-64, the buffer size is 16k, not 8k.
-+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
-+ * Ditto for the __ia64__ case accordingly.
-+ */
-+#define YY_BUF_SIZE 32768
-+#else
-+#define YY_BUF_SIZE 16384
-+#endif /* __ia64__ */
-+#endif
-+
-+/* The state buf must be large enough to hold one state per character in the main buffer.
-+ */
-+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
-+
-+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
-+#define YY_TYPEDEF_YY_BUFFER_STATE
-+typedef struct yy_buffer_state *YY_BUFFER_STATE;
-+#endif
-+
-+#ifndef YY_TYPEDEF_YY_SIZE_T
-+#define YY_TYPEDEF_YY_SIZE_T
-+typedef size_t yy_size_t;
-+#endif
-+
-+extern yy_size_t yyleng;
-+
-+extern FILE *yyin, *yyout;
-+
-+#define EOB_ACT_CONTINUE_SCAN 0
-+#define EOB_ACT_END_OF_FILE 1
-+#define EOB_ACT_LAST_MATCH 2
-+
-+    #define YY_LESS_LINENO(n)
-+    #define YY_LINENO_REWIND_TO(ptr)
-+    
-+/* Return all but the first "n" matched characters back to the input stream. */
-+#define yyless(n) \
-+	do \
-+		{ \
-+		/* Undo effects of setting up yytext. */ \
-+        int yyless_macro_arg = (n); \
-+        YY_LESS_LINENO(yyless_macro_arg);\
-+		*yy_cp = (yy_hold_char); \
-+		YY_RESTORE_YY_MORE_OFFSET \
-+		(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
-+		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
-+		} \
-+	while ( 0 )
-+
-+#define unput(c) yyunput( c, (yytext_ptr)  )
-+
-+#ifndef YY_STRUCT_YY_BUFFER_STATE
-+#define YY_STRUCT_YY_BUFFER_STATE
-+struct yy_buffer_state
-+	{
-+	FILE *yy_input_file;
-+
-+	char *yy_ch_buf;		/* input buffer */
-+	char *yy_buf_pos;		/* current position in input buffer */
-+
-+	/* Size of input buffer in bytes, not including room for EOB
-+	 * characters.
-+	 */
-+	yy_size_t yy_buf_size;
-+
-+	/* Number of characters read into yy_ch_buf, not including EOB
-+	 * characters.
-+	 */
-+	yy_size_t yy_n_chars;
-+
-+	/* Whether we "own" the buffer - i.e., we know we created it,
-+	 * and can realloc() it to grow it, and should free() it to
-+	 * delete it.
-+	 */
-+	int yy_is_our_buffer;
-+
-+	/* Whether this is an "interactive" input source; if so, and
-+	 * if we're using stdio for input, then we want to use getc()
-+	 * instead of fread(), to make sure we stop fetching input after
-+	 * each newline.
-+	 */
-+	int yy_is_interactive;
-+
-+	/* Whether we're considered to be at the beginning of a line.
-+	 * If so, '^' rules will be active on the next match, otherwise
-+	 * not.
-+	 */
-+	int yy_at_bol;
-+
-+    int yy_bs_lineno; /**< The line count. */
-+    int yy_bs_column; /**< The column count. */
-+    
-+	/* Whether to try to fill the input buffer when we reach the
-+	 * end of it.
-+	 */
-+	int yy_fill_buffer;
-+
-+	int yy_buffer_status;
-+
-+#define YY_BUFFER_NEW 0
-+#define YY_BUFFER_NORMAL 1
-+	/* When an EOF's been seen but there's still some text to process
-+	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
-+	 * shouldn't try reading from the input source any more.  We might
-+	 * still have a bunch of tokens to match, though, because of
-+	 * possible backing-up.
-+	 *
-+	 * When we actually see the EOF, we change the status to "new"
-+	 * (via yyrestart()), so that the user can continue scanning by
-+	 * just pointing yyin at a new input file.
-+	 */
-+#define YY_BUFFER_EOF_PENDING 2
-+
-+	};
-+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
-+
-+/* Stack of input buffers. */
-+static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
-+static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
-+static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
-+
-+/* We provide macros for accessing buffer states in case in the
-+ * future we want to put the buffer states in a more general
-+ * "scanner state".
-+ *
-+ * Returns the top of the stack, or NULL.
-+ */
-+#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
-+                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
-+                          : NULL)
-+
-+/* Same as previous macro, but useful when we know that the buffer stack is not
-+ * NULL or when we need an lvalue. For internal use only.
-+ */
-+#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
-+
-+/* yy_hold_char holds the character lost when yytext is formed. */
-+static char yy_hold_char;
-+static yy_size_t yy_n_chars;		/* number of characters read into yy_ch_buf */
-+yy_size_t yyleng;
-+
-+/* Points to current character in buffer. */
-+static char *yy_c_buf_p = (char *) 0;
-+static int yy_init = 0;		/* whether we need to initialize */
-+static int yy_start = 0;	/* start state number */
-+
-+/* Flag which is used to allow yywrap()'s to do buffer switches
-+ * instead of setting up a fresh yyin.  A bit of a hack ...
-+ */
-+static int yy_did_buffer_switch_on_eof;
-+
-+void yyrestart (FILE *input_file  );
-+void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
-+YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
-+void yy_delete_buffer (YY_BUFFER_STATE b  );
-+void yy_flush_buffer (YY_BUFFER_STATE b  );
-+void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
-+void yypop_buffer_state (void );
-+
-+static void yyensure_buffer_stack (void );
-+static void yy_load_buffer_state (void );
-+static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
-+
-+#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
-+
-+YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
-+YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
-+YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len  );
-+
-+void *yyalloc (yy_size_t  );
-+void *yyrealloc (void *,yy_size_t  );
-+void yyfree (void *  );
-+
-+#define yy_new_buffer yy_create_buffer
-+
-+#define yy_set_interactive(is_interactive) \
-+	{ \
-+	if ( ! YY_CURRENT_BUFFER ){ \
-+        yyensure_buffer_stack (); \
-+		YY_CURRENT_BUFFER_LVALUE =    \
-+            yy_create_buffer(yyin,YY_BUF_SIZE ); \
-+	} \
-+	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
-+	}
-+
-+#define yy_set_bol(at_bol) \
-+	{ \
-+	if ( ! YY_CURRENT_BUFFER ){\
-+        yyensure_buffer_stack (); \
-+		YY_CURRENT_BUFFER_LVALUE =    \
-+            yy_create_buffer(yyin,YY_BUF_SIZE ); \
-+	} \
-+	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
-+	}
-+
-+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
-+
-+/* Begin user sect3 */
-+
-+#define yywrap() 1
-+#define YY_SKIP_YYWRAP
-+
-+typedef unsigned char YY_CHAR;
-+
-+FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
-+
-+typedef int yy_state_type;
-+
-+extern int yylineno;
-+
-+int yylineno = 1;
-+
-+extern char *yytext;
-+#define yytext_ptr yytext
-+
-+static yy_state_type yy_get_previous_state (void );
-+static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
-+static int yy_get_next_buffer (void );
-+static void yy_fatal_error (yyconst char msg[]  );
-+
-+/* Done after the current pattern has been matched and before the
-+ * corresponding action - sets up yytext.
-+ */
-+#define YY_DO_BEFORE_ACTION \
-+	(yytext_ptr) = yy_bp; \
-+	yyleng = (size_t) (yy_cp - yy_bp); \
-+	(yy_hold_char) = *yy_cp; \
-+	*yy_cp = '\0'; \
-+	(yy_c_buf_p) = yy_cp;
-+
-+#define YY_NUM_RULES 7
-+#define YY_END_OF_BUFFER 8
-+/* This struct is not used in this scanner,
-+   but its presence is necessary. */
-+struct yy_trans_info
-+	{
-+	flex_int32_t yy_verify;
-+	flex_int32_t yy_nxt;
-+	};
-+static yyconst flex_int16_t yy_accept[39] =
-+    {   0,
-+        0,    0,    8,    6,    4,    2,    1,    6,    1,    0,
-+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-+        0,    0,    0,    0,    0,    0,    0,    0,    0,    3,
-+        0,    0,    0,    0,    0,    0,    5,    0
-+    } ;
-+
-+static yyconst flex_int32_t yy_ec[256] =
-+    {   0,
-+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    2,    4,    4,    5,    4,    4,    4,    4,    4,
-+        4,    4,    4,    4,    4,    4,    6,    7,    7,    7,
-+        7,    7,    7,    7,    7,    7,    7,    4,    4,    8,
-+        4,    9,    4,    4,   10,   10,   10,   10,   10,   10,
-+       10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
-+       10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
-+        4,    1,    4,    4,    4,    1,   11,   11,   11,   11,
-+
-+       12,   11,   13,   11,   14,   11,   15,   11,   11,   16,
-+       11,   11,   11,   17,   18,   19,   11,   11,   11,   11,
-+       20,   11,    1,    1,    1,    4,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1
-+    } ;
-+
-+static yyconst flex_int32_t yy_meta[21] =
-+    {   0,
-+        1,    2,    3,    4,    4,    4,    2,    1,    1,    2,
-+        2,    2,    2,    2,    2,    2,    2,    2,    2,    2
-+    } ;
-+
-+static yyconst flex_int16_t yy_base[43] =
-+    {   0,
-+        0,    7,   49,   50,   50,   50,    0,    1,    0,   36,
-+       28,   26,   28,   35,   29,    0,   26,   33,   27,   33,
-+       29,   22,    0,   24,   27,   14,   27,   23,   13,   50,
-+       10,    9,    4,    1,    0,    2,   50,   50,   19,   23,
-+        2,   26
-+    } ;
-+
-+static yyconst flex_int16_t yy_def[43] =
-+    {   0,
-+       39,   39,   38,   38,   38,   38,   40,   38,   40,   38,
-+       38,   38,   38,   38,   38,   41,   38,   41,   38,   38,
-+       38,   38,   42,   38,   42,   38,   38,   38,   38,   38,
-+       38,   38,   38,   38,   38,   38,   38,    0,   38,   38,
-+       38,   38
-+    } ;
-+
-+static yyconst flex_int16_t yy_nxt[71] =
-+    {   0,
-+       38,    5,    6,   18,    7,   38,   38,    8,    5,    6,
-+       37,    7,   36,   38,    8,   10,   35,   34,   11,    4,
-+        4,    4,    4,    9,    9,   33,    9,   25,   32,   25,
-+       31,   30,   29,   28,   27,   26,   24,   23,   22,   21,
-+       20,   19,   17,   16,   15,   14,   13,   12,   38,    3,
-+       38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
-+       38,   38,   38,   38,   38,   38,   38,   38,   38,   38
-+    } ;
-+
-+static yyconst flex_int16_t yy_chk[71] =
-+    {   0,
-+        0,    1,    1,   41,    1,    0,    0,    1,    2,    2,
-+       36,    2,   35,    0,    2,    8,   34,   33,    8,   39,
-+       39,   39,   39,   40,   40,   32,   40,   42,   31,   42,
-+       29,   28,   27,   26,   25,   24,   22,   21,   20,   19,
-+       18,   17,   15,   14,   13,   12,   11,   10,    3,   38,
-+       38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
-+       38,   38,   38,   38,   38,   38,   38,   38,   38,   38
-+    } ;
-+
-+static yy_state_type yy_last_accepting_state;
-+static char *yy_last_accepting_cpos;
-+
-+extern int yy_flex_debug;
-+int yy_flex_debug = 0;
-+
-+/* The intent behind this definition is that it'll catch
-+ * any uses of REJECT which flex missed.
-+ */
-+#define REJECT reject_used_but_not_detected
-+#define yymore() yymore_used_but_not_detected
-+#define YY_MORE_ADJ 0
-+#define YY_RESTORE_YY_MORE_OFFSET
-+char *yytext;
-+#line 1 "tokenparser.l"
-+/*
-+ * Reads lexical config files and updates database.
-+ *
-+ * MUSCLE SmartCard Development ( http://pcsclite.alioth.debian.org/pcsclite.html )
-+ *
-+ * Copyright (C) 2001-2003
-+ *  David Corcoran <corcoran@musclecard.com>
-+ * Copyright (C) 2003-2010
-+ *  Ludovic Rousseau <ludovic.rousseau@free.fr>
-+ *
-+Redistribution and use in source and binary forms, with or without
-+modification, are permitted provided that the following conditions
-+are met:
-+
-+1. Redistributions of source code must retain the above copyright
-+   notice, this list of conditions and the following disclaimer.
-+2. Redistributions in binary form must reproduce the above copyright
-+   notice, this list of conditions and the following disclaimer in the
-+   documentation and/or other materials provided with the distribution.
-+3. The name of the author may not be used to endorse or promote products
-+   derived from this software without specific prior written permission.
-+
-+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-+ */
-+/**
-+ * @file
-+ * @brief provides parsing functions for Info.plist files
-+ * platforms
-+ */
-+#line 42 "tokenparser.l"
-+
-+#include "config.h"
-+#include <stdio.h>
-+#include <string.h>
-+#include <errno.h>
-+#define NDEBUG
-+#include <assert.h>
-+
-+#include "simclist.h"
-+#include "debuglog.h"
-+#include "parser.h"
-+
-+static void eval_key(char *pcToken, list_t *list_key);
-+static void eval_value(char *pcToken, list_t *list_values);
-+void tperrorCheck (char *pcToken_error);
-+
-+static list_t *ListKeys;
-+static list_t *ListValues;
-+
-+#define YY_NO_INPUT 1
-+#line 545 "tokenparser.c"
-+
-+#define INITIAL 0
-+
-+#ifndef YY_NO_UNISTD_H
-+/* Special case for "unistd.h", since it is non-ANSI. We include it way
-+ * down here because we want the user's section 1 to have been scanned first.
-+ * The user has a chance to override it with an option.
-+ */
-+#include <unistd.h>
-+#endif
-+
-+#ifndef YY_EXTRA_TYPE
-+#define YY_EXTRA_TYPE void *
-+#endif
-+
-+static int yy_init_globals (void );
-+
-+/* Accessor methods to globals.
-+   These are made visible to non-reentrant scanners for convenience. */
-+
-+int yylex_destroy (void );
-+
-+int yyget_debug (void );
-+
-+void yyset_debug (int debug_flag  );
-+
-+YY_EXTRA_TYPE yyget_extra (void );
-+
-+void yyset_extra (YY_EXTRA_TYPE user_defined  );
-+
-+FILE *yyget_in (void );
-+
-+void yyset_in  (FILE * in_str  );
-+
-+FILE *yyget_out (void );
-+
-+void yyset_out  (FILE * out_str  );
-+
-+yy_size_t yyget_leng (void );
-+
-+char *yyget_text (void );
-+
-+int yyget_lineno (void );
-+
-+void yyset_lineno (int line_number  );
-+
-+/* Macros after this point can all be overridden by user definitions in
-+ * section 1.
-+ */
-+
-+#ifndef YY_SKIP_YYWRAP
-+#ifdef __cplusplus
-+extern "C" int yywrap (void );
-+#else
-+extern int yywrap (void );
-+#endif
-+#endif
-+
-+#ifndef yytext_ptr
-+static void yy_flex_strncpy (char *,yyconst char *,int );
-+#endif
-+
-+#ifdef YY_NEED_STRLEN
-+static int yy_flex_strlen (yyconst char * );
-+#endif
-+
-+#ifndef YY_NO_INPUT
-+
-+#ifdef __cplusplus
-+static int yyinput (void );
-+#else
-+static int input (void );
-+#endif
-+
-+#endif
-+
-+/* Amount of stuff to slurp up with each read. */
-+#ifndef YY_READ_BUF_SIZE
-+#ifdef __ia64__
-+/* On IA-64, the buffer size is 16k, not 8k */
-+#define YY_READ_BUF_SIZE 16384
-+#else
-+#define YY_READ_BUF_SIZE 8192
-+#endif /* __ia64__ */
-+#endif
-+
-+/* Copy whatever the last rule matched to the standard output. */
-+#ifndef ECHO
-+/* This used to be an fputs(), but since the string might contain NUL's,
-+ * we now use fwrite().
-+ */
-+#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
-+#endif
-+
-+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
-+ * is returned in "result".
-+ */
-+#ifndef YY_INPUT
-+#define YY_INPUT(buf,result,max_size) \
-+	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
-+		{ \
-+		int c = '*'; \
-+		size_t n; \
-+		for ( n = 0; n < max_size && \
-+			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
-+			buf[n] = (char) c; \
-+		if ( c == '\n' ) \
-+			buf[n++] = (char) c; \
-+		if ( c == EOF && ferror( yyin ) ) \
-+			YY_FATAL_ERROR( "input in flex scanner failed" ); \
-+		result = n; \
-+		} \
-+	else \
-+		{ \
-+		errno=0; \
-+		while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
-+			{ \
-+			if( errno != EINTR) \
-+				{ \
-+				YY_FATAL_ERROR( "input in flex scanner failed" ); \
-+				break; \
-+				} \
-+			errno=0; \
-+			clearerr(yyin); \
-+			} \
-+		}\
-+\
-+
-+#endif
-+
-+/* No semi-colon after return; correct usage is to write "yyterminate();" -
-+ * we don't want an extra ';' after the "return" because that will cause
-+ * some compilers to complain about unreachable statements.
-+ */
-+#ifndef yyterminate
-+#define yyterminate() return YY_NULL
-+#endif
-+
-+/* Number of entries by which start-condition stack grows. */
-+#ifndef YY_START_STACK_INCR
-+#define YY_START_STACK_INCR 25
-+#endif
-+
-+/* Report a fatal error. */
-+#ifndef YY_FATAL_ERROR
-+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
-+#endif
-+
-+/* end tables serialization structures and prototypes */
-+
-+/* Default declaration of generated scanner - a define so the user can
-+ * easily add parameters.
-+ */
-+#ifndef YY_DECL
-+#define YY_DECL_IS_OURS 1
-+
-+extern int yylex (void);
-+
-+#define YY_DECL int yylex (void)
-+#endif /* !YY_DECL */
-+
-+/* Code executed at the beginning of each rule, after yytext and yyleng
-+ * have been set up.
-+ */
-+#ifndef YY_USER_ACTION
-+#define YY_USER_ACTION
-+#endif
-+
-+/* Code executed at the end of each rule. */
-+#ifndef YY_BREAK
-+#define YY_BREAK break;
-+#endif
-+
-+#define YY_RULE_SETUP \
-+	YY_USER_ACTION
-+
-+/** The main scanner function which does all the work.
-+ */
-+YY_DECL
-+{
-+	register yy_state_type yy_current_state;
-+	register char *yy_cp, *yy_bp;
-+	register int yy_act;
-+    
-+	if ( !(yy_init) )
-+		{
-+		(yy_init) = 1;
-+
-+#ifdef YY_USER_INIT
-+		YY_USER_INIT;
-+#endif
-+
-+		if ( ! (yy_start) )
-+			(yy_start) = 1;	/* first start state */
-+
-+		if ( ! yyin )
-+			yyin = stdin;
-+
-+		if ( ! yyout )
-+			yyout = stdout;
-+
-+		if ( ! YY_CURRENT_BUFFER ) {
-+			yyensure_buffer_stack ();
-+			YY_CURRENT_BUFFER_LVALUE =
-+				yy_create_buffer(yyin,YY_BUF_SIZE );
-+		}
-+
-+		yy_load_buffer_state( );
-+		}
-+
-+	{
-+#line 67 "tokenparser.l"
-+
-+
-+#line 760 "tokenparser.c"
-+
-+	while ( 1 )		/* loops until end-of-file is reached */
-+		{
-+		yy_cp = (yy_c_buf_p);
-+
-+		/* Support of yytext. */
-+		*yy_cp = (yy_hold_char);
-+
-+		/* yy_bp points to the position in yy_ch_buf of the start of
-+		 * the current run.
-+		 */
-+		yy_bp = yy_cp;
-+
-+		yy_current_state = (yy_start);
-+yy_match:
-+		do
-+			{
-+			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
-+			if ( yy_accept[yy_current_state] )
-+				{
-+				(yy_last_accepting_state) = yy_current_state;
-+				(yy_last_accepting_cpos) = yy_cp;
-+				}
-+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-+				{
-+				yy_current_state = (int) yy_def[yy_current_state];
-+				if ( yy_current_state >= 39 )
-+					yy_c = yy_meta[(unsigned int) yy_c];
-+				}
-+			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-+			++yy_cp;
-+			}
-+		while ( yy_base[yy_current_state] != 50 );
-+
-+yy_find_action:
-+		yy_act = yy_accept[yy_current_state];
-+		if ( yy_act == 0 )
-+			{ /* have to back up */
-+			yy_cp = (yy_last_accepting_cpos);
-+			yy_current_state = (yy_last_accepting_state);
-+			yy_act = yy_accept[yy_current_state];
-+			}
-+
-+		YY_DO_BEFORE_ACTION;
-+
-+do_action:	/* This label is used only to access EOF actions. */
-+
-+		switch ( yy_act )
-+	{ /* beginning of action switch */
-+			case 0: /* must back up */
-+			/* undo the effects of YY_DO_BEFORE_ACTION */
-+			*yy_cp = (yy_hold_char);
-+			yy_cp = (yy_last_accepting_cpos);
-+			yy_current_state = (yy_last_accepting_state);
-+			goto yy_find_action;
-+
-+case 1:
-+YY_RULE_SETUP
-+#line 69 "tokenparser.l"
-+{}
-+	YY_BREAK
-+case 2:
-+/* rule 2 can match eol */
-+YY_RULE_SETUP
-+#line 70 "tokenparser.l"
-+{}
-+	YY_BREAK
-+case 3:
-+YY_RULE_SETUP
-+#line 71 "tokenparser.l"
-+{ eval_key(yytext, ListKeys); }
-+	YY_BREAK
-+case 4:
-+YY_RULE_SETUP
-+#line 72 "tokenparser.l"
-+{}
-+	YY_BREAK
-+case 5:
-+YY_RULE_SETUP
-+#line 73 "tokenparser.l"
-+{ eval_value(yytext, ListValues); }
-+	YY_BREAK
-+case 6:
-+YY_RULE_SETUP
-+#line 74 "tokenparser.l"
-+{ tperrorCheck(yytext); }
-+	YY_BREAK
-+case 7:
-+YY_RULE_SETUP
-+#line 75 "tokenparser.l"
-+ECHO;
-+	YY_BREAK
-+#line 853 "tokenparser.c"
-+case YY_STATE_EOF(INITIAL):
-+	yyterminate();
-+
-+	case YY_END_OF_BUFFER:
-+		{
-+		/* Amount of text matched not including the EOB char. */
-+		int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
-+
-+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
-+		*yy_cp = (yy_hold_char);
-+		YY_RESTORE_YY_MORE_OFFSET
-+
-+		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
-+			{
-+			/* We're scanning a new file or input source.  It's
-+			 * possible that this happened because the user
-+			 * just pointed yyin at a new source and called
-+			 * yylex().  If so, then we have to assure
-+			 * consistency between YY_CURRENT_BUFFER and our
-+			 * globals.  Here is the right place to do so, because
-+			 * this is the first action (other than possibly a
-+			 * back-up) that will match for the new input source.
-+			 */
-+			(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-+			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
-+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
-+			}
-+
-+		/* Note that here we test for yy_c_buf_p "<=" to the position
-+		 * of the first EOB in the buffer, since yy_c_buf_p will
-+		 * already have been incremented past the NUL character
-+		 * (since all states make transitions on EOB to the
-+		 * end-of-buffer state).  Contrast this with the test
-+		 * in input().
-+		 */
-+		if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
-+			{ /* This was really a NUL. */
-+			yy_state_type yy_next_state;
-+
-+			(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
-+
-+			yy_current_state = yy_get_previous_state(  );
-+
-+			/* Okay, we're now positioned to make the NUL
-+			 * transition.  We couldn't have
-+			 * yy_get_previous_state() go ahead and do it
-+			 * for us because it doesn't know how to deal
-+			 * with the possibility of jamming (and we don't
-+			 * want to build jamming into it because then it
-+			 * will run more slowly).
-+			 */
-+
-+			yy_next_state = yy_try_NUL_trans( yy_current_state );
-+
-+			yy_bp = (yytext_ptr) + YY_MORE_ADJ;
-+
-+			if ( yy_next_state )
-+				{
-+				/* Consume the NUL. */
-+				yy_cp = ++(yy_c_buf_p);
-+				yy_current_state = yy_next_state;
-+				goto yy_match;
-+				}
-+
-+			else
-+				{
-+				yy_cp = (yy_c_buf_p);
-+				goto yy_find_action;
-+				}
-+			}
-+
-+		else switch ( yy_get_next_buffer(  ) )
-+			{
-+			case EOB_ACT_END_OF_FILE:
-+				{
-+				(yy_did_buffer_switch_on_eof) = 0;
-+
-+				if ( yywrap( ) )
-+					{
-+					/* Note: because we've taken care in
-+					 * yy_get_next_buffer() to have set up
-+					 * yytext, we can now set up
-+					 * yy_c_buf_p so that if some total
-+					 * hoser (like flex itself) wants to
-+					 * call the scanner after we return the
-+					 * YY_NULL, it'll still work - another
-+					 * YY_NULL will get returned.
-+					 */
-+					(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
-+
-+					yy_act = YY_STATE_EOF(YY_START);
-+					goto do_action;
-+					}
-+
-+				else
-+					{
-+					if ( ! (yy_did_buffer_switch_on_eof) )
-+						YY_NEW_FILE;
-+					}
-+				break;
-+				}
-+
-+			case EOB_ACT_CONTINUE_SCAN:
-+				(yy_c_buf_p) =
-+					(yytext_ptr) + yy_amount_of_matched_text;
-+
-+				yy_current_state = yy_get_previous_state(  );
-+
-+				yy_cp = (yy_c_buf_p);
-+				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
-+				goto yy_match;
-+
-+			case EOB_ACT_LAST_MATCH:
-+				(yy_c_buf_p) =
-+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
-+
-+				yy_current_state = yy_get_previous_state(  );
-+
-+				yy_cp = (yy_c_buf_p);
-+				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
-+				goto yy_find_action;
-+			}
-+		break;
-+		}
-+
-+	default:
-+		YY_FATAL_ERROR(
-+			"fatal flex scanner internal error--no action found" );
-+	} /* end of action switch */
-+		} /* end of scanning one token */
-+	} /* end of user's declarations */
-+} /* end of yylex */
-+
-+/* yy_get_next_buffer - try to read in a new buffer
-+ *
-+ * Returns a code representing an action:
-+ *	EOB_ACT_LAST_MATCH -
-+ *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
-+ *	EOB_ACT_END_OF_FILE - end of file
-+ */
-+static int yy_get_next_buffer (void)
-+{
-+    	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
-+	register char *source = (yytext_ptr);
-+	register int number_to_move, i;
-+	int ret_val;
-+
-+	if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
-+		YY_FATAL_ERROR(
-+		"fatal flex scanner internal error--end of buffer missed" );
-+
-+	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
-+		{ /* Don't try to fill the buffer, so this is an EOF. */
-+		if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
-+			{
-+			/* We matched a single character, the EOB, so
-+			 * treat this as a final EOF.
-+			 */
-+			return EOB_ACT_END_OF_FILE;
-+			}
-+
-+		else
-+			{
-+			/* We matched some text prior to the EOB, first
-+			 * process it.
-+			 */
-+			return EOB_ACT_LAST_MATCH;
-+			}
-+		}
-+
-+	/* Try to read more data. */
-+
-+	/* First move last chars to start of buffer. */
-+	number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
-+
-+	for ( i = 0; i < number_to_move; ++i )
-+		*(dest++) = *(source++);
-+
-+	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
-+		/* don't do the read, it's not guaranteed to return an EOF,
-+		 * just force an EOF
-+		 */
-+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
-+
-+	else
-+		{
-+			yy_size_t num_to_read =
-+			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
-+
-+		while ( num_to_read <= 0 )
-+			{ /* Not enough room in the buffer - grow it. */
-+
-+			/* just a shorter name for the current buffer */
-+			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
-+
-+			int yy_c_buf_p_offset =
-+				(int) ((yy_c_buf_p) - b->yy_ch_buf);
-+
-+			if ( b->yy_is_our_buffer )
-+				{
-+				yy_size_t new_size = b->yy_buf_size * 2;
-+
-+				if ( new_size <= 0 )
-+					b->yy_buf_size += b->yy_buf_size / 8;
-+				else
-+					b->yy_buf_size *= 2;
-+
-+				b->yy_ch_buf = (char *)
-+					/* Include room in for 2 EOB chars. */
-+					yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
-+				}
-+			else
-+				/* Can't grow it, we don't own it. */
-+				b->yy_ch_buf = 0;
-+
-+			if ( ! b->yy_ch_buf )
-+				YY_FATAL_ERROR(
-+				"fatal error - scanner input buffer overflow" );
-+
-+			(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
-+
-+			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
-+						number_to_move - 1;
-+
-+			}
-+
-+		if ( num_to_read > YY_READ_BUF_SIZE )
-+			num_to_read = YY_READ_BUF_SIZE;
-+
-+		/* Read in more data. */
-+		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-+			(yy_n_chars), num_to_read );
-+
-+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
-+		}
-+
-+	if ( (yy_n_chars) == 0 )
-+		{
-+		if ( number_to_move == YY_MORE_ADJ )
-+			{
-+			ret_val = EOB_ACT_END_OF_FILE;
-+			yyrestart(yyin  );
-+			}
-+
-+		else
-+			{
-+			ret_val = EOB_ACT_LAST_MATCH;
-+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
-+				YY_BUFFER_EOF_PENDING;
-+			}
-+		}
-+
-+	else
-+		ret_val = EOB_ACT_CONTINUE_SCAN;
-+
-+	if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
-+		/* Extend the array by 50%, plus the number we really need. */
-+		yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
-+		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
-+		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
-+			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
-+	}
-+
-+	(yy_n_chars) += number_to_move;
-+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
-+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
-+
-+	(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
-+
-+	return ret_val;
-+}
-+
-+/* yy_get_previous_state - get the state just before the EOB char was reached */
-+
-+    static yy_state_type yy_get_previous_state (void)
-+{
-+	register yy_state_type yy_current_state;
-+	register char *yy_cp;
-+    
-+	yy_current_state = (yy_start);
-+
-+	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
-+		{
-+		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
-+		if ( yy_accept[yy_current_state] )
-+			{
-+			(yy_last_accepting_state) = yy_current_state;
-+			(yy_last_accepting_cpos) = yy_cp;
-+			}
-+		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-+			{
-+			yy_current_state = (int) yy_def[yy_current_state];
-+			if ( yy_current_state >= 39 )
-+				yy_c = yy_meta[(unsigned int) yy_c];
-+			}
-+		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-+		}
-+
-+	return yy_current_state;
-+}
-+
-+/* yy_try_NUL_trans - try to make a transition on the NUL character
-+ *
-+ * synopsis
-+ *	next_state = yy_try_NUL_trans( current_state );
-+ */
-+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
-+{
-+	register int yy_is_jam;
-+    	register char *yy_cp = (yy_c_buf_p);
-+
-+	register YY_CHAR yy_c = 1;
-+	if ( yy_accept[yy_current_state] )
-+		{
-+		(yy_last_accepting_state) = yy_current_state;
-+		(yy_last_accepting_cpos) = yy_cp;
-+		}
-+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-+		{
-+		yy_current_state = (int) yy_def[yy_current_state];
-+		if ( yy_current_state >= 39 )
-+			yy_c = yy_meta[(unsigned int) yy_c];
-+		}
-+	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-+	yy_is_jam = (yy_current_state == 38);
-+
-+		return yy_is_jam ? 0 : yy_current_state;
-+}
-+
-+#ifndef YY_NO_INPUT
-+#ifdef __cplusplus
-+    static int yyinput (void)
-+#else
-+    static int input  (void)
-+#endif
-+
-+{
-+	int c;
-+    
-+	*(yy_c_buf_p) = (yy_hold_char);
-+
-+	if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
-+		{
-+		/* yy_c_buf_p now points to the character we want to return.
-+		 * If this occurs *before* the EOB characters, then it's a
-+		 * valid NUL; if not, then we've hit the end of the buffer.
-+		 */
-+		if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
-+			/* This was really a NUL. */
-+			*(yy_c_buf_p) = '\0';
-+
-+		else
-+			{ /* need more input */
-+			yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
-+			++(yy_c_buf_p);
-+
-+			switch ( yy_get_next_buffer(  ) )
-+				{
-+				case EOB_ACT_LAST_MATCH:
-+					/* This happens because yy_g_n_b()
-+					 * sees that we've accumulated a
-+					 * token and flags that we need to
-+					 * try matching the token before
-+					 * proceeding.  But for input(),
-+					 * there's no matching to consider.
-+					 * So convert the EOB_ACT_LAST_MATCH
-+					 * to EOB_ACT_END_OF_FILE.
-+					 */
-+
-+					/* Reset buffer status. */
-+					yyrestart(yyin );
-+
-+					/*FALLTHROUGH*/
-+
-+				case EOB_ACT_END_OF_FILE:
-+					{
-+					if ( yywrap( ) )
-+						return EOF;
-+
-+					if ( ! (yy_did_buffer_switch_on_eof) )
-+						YY_NEW_FILE;
-+#ifdef __cplusplus
-+					return yyinput();
-+#else
-+					return input();
-+#endif
-+					}
-+
-+				case EOB_ACT_CONTINUE_SCAN:
-+					(yy_c_buf_p) = (yytext_ptr) + offset;
-+					break;
-+				}
-+			}
-+		}
-+
-+	c = *(unsigned char *) (yy_c_buf_p);	/* cast for 8-bit char's */
-+	*(yy_c_buf_p) = '\0';	/* preserve yytext */
-+	(yy_hold_char) = *++(yy_c_buf_p);
-+
-+	return c;
-+}
-+#endif	/* ifndef YY_NO_INPUT */
-+
-+/** Immediately switch to a different input stream.
-+ * @param input_file A readable stream.
-+ * 
-+ * @note This function does not reset the start condition to @c INITIAL .
-+ */
-+    void yyrestart  (FILE * input_file )
-+{
-+    
-+	if ( ! YY_CURRENT_BUFFER ){
-+        yyensure_buffer_stack ();
-+		YY_CURRENT_BUFFER_LVALUE =
-+            yy_create_buffer(yyin,YY_BUF_SIZE );
-+	}
-+
-+	yy_init_buffer(YY_CURRENT_BUFFER,input_file );
-+	yy_load_buffer_state( );
-+}
-+
-+/** Switch to a different input buffer.
-+ * @param new_buffer The new input buffer.
-+ * 
-+ */
-+    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
-+{
-+    
-+	/* TODO. We should be able to replace this entire function body
-+	 * with
-+	 *		yypop_buffer_state();
-+	 *		yypush_buffer_state(new_buffer);
-+     */
-+	yyensure_buffer_stack ();
-+	if ( YY_CURRENT_BUFFER == new_buffer )
-+		return;
-+
-+	if ( YY_CURRENT_BUFFER )
-+		{
-+		/* Flush out information for old buffer. */
-+		*(yy_c_buf_p) = (yy_hold_char);
-+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
-+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
-+		}
-+
-+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
-+	yy_load_buffer_state( );
-+
-+	/* We don't actually know whether we did this switch during
-+	 * EOF (yywrap()) processing, but the only time this flag
-+	 * is looked at is after yywrap() is called, so it's safe
-+	 * to go ahead and always set it.
-+	 */
-+	(yy_did_buffer_switch_on_eof) = 1;
-+}
-+
-+static void yy_load_buffer_state  (void)
-+{
-+    	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-+	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
-+	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
-+	(yy_hold_char) = *(yy_c_buf_p);
-+}
-+
-+/** Allocate and initialize an input buffer state.
-+ * @param file A readable stream.
-+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
-+ * 
-+ * @return the allocated buffer state.
-+ */
-+    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
-+{
-+	YY_BUFFER_STATE b;
-+    
-+	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
-+	if ( ! b )
-+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
-+
-+	b->yy_buf_size = size;
-+
-+	/* yy_ch_buf has to be 2 characters longer than the size given because
-+	 * we need to put in 2 end-of-buffer characters.
-+	 */
-+	b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
-+	if ( ! b->yy_ch_buf )
-+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
-+
-+	b->yy_is_our_buffer = 1;
-+
-+	yy_init_buffer(b,file );
-+
-+	return b;
-+}
-+
-+/** Destroy the buffer.
-+ * @param b a buffer created with yy_create_buffer()
-+ * 
-+ */
-+    void yy_delete_buffer (YY_BUFFER_STATE  b )
-+{
-+    
-+	if ( ! b )
-+		return;
-+
-+	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
-+		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
-+
-+	if ( b->yy_is_our_buffer )
-+		yyfree((void *) b->yy_ch_buf  );
-+
-+	yyfree((void *) b  );
-+}
-+
-+/* Initializes or reinitializes a buffer.
-+ * This function is sometimes called more than once on the same buffer,
-+ * such as during a yyrestart() or at EOF.
-+ */
-+    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
-+
-+{
-+	int oerrno = errno;
-+    
-+	yy_flush_buffer(b );
-+
-+	b->yy_input_file = file;
-+	b->yy_fill_buffer = 1;
-+
-+    /* If b is the current buffer, then yy_init_buffer was _probably_
-+     * called from yyrestart() or through yy_get_next_buffer.
-+     * In that case, we don't want to reset the lineno or column.
-+     */
-+    if (b != YY_CURRENT_BUFFER){
-+        b->yy_bs_lineno = 1;
-+        b->yy_bs_column = 0;
-+    }
-+
-+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
-+    
-+	errno = oerrno;
-+}
-+
-+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
-+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
-+ * 
-+ */
-+    void yy_flush_buffer (YY_BUFFER_STATE  b )
-+{
-+    	if ( ! b )
-+		return;
-+
-+	b->yy_n_chars = 0;
-+
-+	/* We always need two end-of-buffer characters.  The first causes
-+	 * a transition to the end-of-buffer state.  The second causes
-+	 * a jam in that state.
-+	 */
-+	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
-+	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
-+
-+	b->yy_buf_pos = &b->yy_ch_buf[0];
-+
-+	b->yy_at_bol = 1;
-+	b->yy_buffer_status = YY_BUFFER_NEW;
-+
-+	if ( b == YY_CURRENT_BUFFER )
-+		yy_load_buffer_state( );
-+}
-+
-+/** Pushes the new state onto the stack. The new state becomes
-+ *  the current state. This function will allocate the stack
-+ *  if necessary.
-+ *  @param new_buffer The new state.
-+ *  
-+ */
-+void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
-+{
-+    	if (new_buffer == NULL)
-+		return;
-+
-+	yyensure_buffer_stack();
-+
-+	/* This block is copied from yy_switch_to_buffer. */
-+	if ( YY_CURRENT_BUFFER )
-+		{
-+		/* Flush out information for old buffer. */
-+		*(yy_c_buf_p) = (yy_hold_char);
-+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
-+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
-+		}
-+
-+	/* Only push if top exists. Otherwise, replace top. */
-+	if (YY_CURRENT_BUFFER)
-+		(yy_buffer_stack_top)++;
-+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
-+
-+	/* copied from yy_switch_to_buffer. */
-+	yy_load_buffer_state( );
-+	(yy_did_buffer_switch_on_eof) = 1;
-+}
-+
-+/** Removes and deletes the top of the stack, if present.
-+ *  The next element becomes the new top.
-+ *  
-+ */
-+void yypop_buffer_state (void)
-+{
-+    	if (!YY_CURRENT_BUFFER)
-+		return;
-+
-+	yy_delete_buffer(YY_CURRENT_BUFFER );
-+	YY_CURRENT_BUFFER_LVALUE = NULL;
-+	if ((yy_buffer_stack_top) > 0)
-+		--(yy_buffer_stack_top);
-+
-+	if (YY_CURRENT_BUFFER) {
-+		yy_load_buffer_state( );
-+		(yy_did_buffer_switch_on_eof) = 1;
-+	}
-+}
-+
-+/* Allocates the stack if it does not exist.
-+ *  Guarantees space for at least one push.
-+ */
-+static void yyensure_buffer_stack (void)
-+{
-+	yy_size_t num_to_alloc;
-+    
-+	if (!(yy_buffer_stack)) {
-+
-+		/* First allocation is just for 2 elements, since we don't know if this
-+		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
-+		 * immediate realloc on the next call.
-+         */
-+		num_to_alloc = 1;
-+		(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
-+								(num_to_alloc * sizeof(struct yy_buffer_state*)
-+								);
-+		if ( ! (yy_buffer_stack) )
-+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
-+								  
-+		memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
-+				
-+		(yy_buffer_stack_max) = num_to_alloc;
-+		(yy_buffer_stack_top) = 0;
-+		return;
-+	}
-+
-+	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
-+
-+		/* Increase the buffer to prepare for a possible push. */
-+		int grow_size = 8 /* arbitrary grow size */;
-+
-+		num_to_alloc = (yy_buffer_stack_max) + grow_size;
-+		(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
-+								((yy_buffer_stack),
-+								num_to_alloc * sizeof(struct yy_buffer_state*)
-+								);
-+		if ( ! (yy_buffer_stack) )
-+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
-+
-+		/* zero only the new slots.*/
-+		memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
-+		(yy_buffer_stack_max) = num_to_alloc;
-+	}
-+}
-+
-+/** Setup the input buffer state to scan directly from a user-specified character buffer.
-+ * @param base the character buffer
-+ * @param size the size in bytes of the character buffer
-+ * 
-+ * @return the newly allocated buffer state object. 
-+ */
-+YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
-+{
-+	YY_BUFFER_STATE b;
-+    
-+	if ( size < 2 ||
-+	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
-+	     base[size-1] != YY_END_OF_BUFFER_CHAR )
-+		/* They forgot to leave room for the EOB's. */
-+		return 0;
-+
-+	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
-+	if ( ! b )
-+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
-+
-+	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
-+	b->yy_buf_pos = b->yy_ch_buf = base;
-+	b->yy_is_our_buffer = 0;
-+	b->yy_input_file = 0;
-+	b->yy_n_chars = b->yy_buf_size;
-+	b->yy_is_interactive = 0;
-+	b->yy_at_bol = 1;
-+	b->yy_fill_buffer = 0;
-+	b->yy_buffer_status = YY_BUFFER_NEW;
-+
-+	yy_switch_to_buffer(b  );
-+
-+	return b;
-+}
-+
-+/** Setup the input buffer state to scan a string. The next call to yylex() will
-+ * scan from a @e copy of @a str.
-+ * @param yystr a NUL-terminated string to scan
-+ * 
-+ * @return the newly allocated buffer state object.
-+ * @note If you want to scan bytes that may contain NUL values, then use
-+ *       yy_scan_bytes() instead.
-+ */
-+YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
-+{
-+    
-+	return yy_scan_bytes(yystr,strlen(yystr) );
-+}
-+
-+/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
-+ * scan from a @e copy of @a bytes.
-+ * @param yybytes the byte buffer to scan
-+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
-+ * 
-+ * @return the newly allocated buffer state object.
-+ */
-+YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len )
-+{
-+	YY_BUFFER_STATE b;
-+	char *buf;
-+	yy_size_t n;
-+	yy_size_t i;
-+    
-+	/* Get memory for full buffer, including space for trailing EOB's. */
-+	n = _yybytes_len + 2;
-+	buf = (char *) yyalloc(n  );
-+	if ( ! buf )
-+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
-+
-+	for ( i = 0; i < _yybytes_len; ++i )
-+		buf[i] = yybytes[i];
-+
-+	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
-+
-+	b = yy_scan_buffer(buf,n );
-+	if ( ! b )
-+		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
-+
-+	/* It's okay to grow etc. this buffer, and we should throw it
-+	 * away when we're done.
-+	 */
-+	b->yy_is_our_buffer = 1;
-+
-+	return b;
-+}
-+
-+#ifndef YY_EXIT_FAILURE
-+#define YY_EXIT_FAILURE 2
-+#endif
-+
-+static void yy_fatal_error (yyconst char* msg )
-+{
-+    	(void) fprintf( stderr, "%s\n", msg );
-+	exit( YY_EXIT_FAILURE );
-+}
-+
-+/* Redefine yyless() so it works in section 3 code. */
-+
-+#undef yyless
-+#define yyless(n) \
-+	do \
-+		{ \
-+		/* Undo effects of setting up yytext. */ \
-+        int yyless_macro_arg = (n); \
-+        YY_LESS_LINENO(yyless_macro_arg);\
-+		yytext[yyleng] = (yy_hold_char); \
-+		(yy_c_buf_p) = yytext + yyless_macro_arg; \
-+		(yy_hold_char) = *(yy_c_buf_p); \
-+		*(yy_c_buf_p) = '\0'; \
-+		yyleng = yyless_macro_arg; \
-+		} \
-+	while ( 0 )
-+
-+/* Accessor  methods (get/set functions) to struct members. */
-+
-+/** Get the current line number.
-+ * 
-+ */
-+int yyget_lineno  (void)
-+{
-+        
-+    return yylineno;
-+}
-+
-+/** Get the input stream.
-+ * 
-+ */
-+FILE *yyget_in  (void)
-+{
-+        return yyin;
-+}
-+
-+/** Get the output stream.
-+ * 
-+ */
-+FILE *yyget_out  (void)
-+{
-+        return yyout;
-+}
-+
-+/** Get the length of the current token.
-+ * 
-+ */
-+yy_size_t yyget_leng  (void)
-+{
-+        return yyleng;
-+}
-+
-+/** Get the current token.
-+ * 
-+ */
-+
-+char *yyget_text  (void)
-+{
-+        return yytext;
-+}
-+
-+/** Set the current line number.
-+ * @param line_number
-+ * 
-+ */
-+void yyset_lineno (int  line_number )
-+{
-+    
-+    yylineno = line_number;
-+}
-+
-+/** Set the input stream. This does not discard the current
-+ * input buffer.
-+ * @param in_str A readable stream.
-+ * 
-+ * @see yy_switch_to_buffer
-+ */
-+void yyset_in (FILE *  in_str )
-+{
-+        yyin = in_str ;
-+}
-+
-+void yyset_out (FILE *  out_str )
-+{
-+        yyout = out_str ;
-+}
-+
-+int yyget_debug  (void)
-+{
-+        return yy_flex_debug;
-+}
-+
-+void yyset_debug (int  bdebug )
-+{
-+        yy_flex_debug = bdebug ;
-+}
-+
-+static int yy_init_globals (void)
-+{
-+        /* Initialization is the same as for the non-reentrant scanner.
-+     * This function is called from yylex_destroy(), so don't allocate here.
-+     */
-+
-+    (yy_buffer_stack) = 0;
-+    (yy_buffer_stack_top) = 0;
-+    (yy_buffer_stack_max) = 0;
-+    (yy_c_buf_p) = (char *) 0;
-+    (yy_init) = 0;
-+    (yy_start) = 0;
-+
-+/* Defined in main.c */
-+#ifdef YY_STDINIT
-+    yyin = stdin;
-+    yyout = stdout;
-+#else
-+    yyin = (FILE *) 0;
-+    yyout = (FILE *) 0;
-+#endif
-+
-+    /* For future reference: Set errno on error, since we are called by
-+     * yylex_init()
-+     */
-+    return 0;
-+}
-+
-+/* yylex_destroy is for both reentrant and non-reentrant scanners. */
-+int yylex_destroy  (void)
-+{
-+    
-+    /* Pop the buffer stack, destroying each element. */
-+	while(YY_CURRENT_BUFFER){
-+		yy_delete_buffer(YY_CURRENT_BUFFER  );
-+		YY_CURRENT_BUFFER_LVALUE = NULL;
-+		yypop_buffer_state();
-+	}
-+
-+	/* Destroy the stack itself. */
-+	yyfree((yy_buffer_stack) );
-+	(yy_buffer_stack) = NULL;
-+
-+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
-+     * yylex() is called, initialization will occur. */
-+    yy_init_globals( );
-+
-+    return 0;
-+}
-+
-+/*
-+ * Internal utility routines.
-+ */
-+
-+#ifndef yytext_ptr
-+static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
-+{
-+	register int i;
-+	for ( i = 0; i < n; ++i )
-+		s1[i] = s2[i];
-+}
-+#endif
-+
-+#ifdef YY_NEED_STRLEN
-+static int yy_flex_strlen (yyconst char * s )
-+{
-+	register int n;
-+	for ( n = 0; s[n]; ++n )
-+		;
-+
-+	return n;
-+}
-+#endif
-+
-+void *yyalloc (yy_size_t  size )
-+{
-+	return (void *) malloc( size );
-+}
-+
-+void *yyrealloc  (void * ptr, yy_size_t  size )
-+{
-+	/* The cast to (char *) in the following accommodates both
-+	 * implementations that use char* generic pointers, and those
-+	 * that use void* generic pointers.  It works with the latter
-+	 * because both ANSI C and C++ allow castless assignment from
-+	 * any pointer type to void*, and deal with argument conversions
-+	 * as though doing an assignment.
-+	 */
-+	return (void *) realloc( (char *) ptr, size );
-+}
-+
-+void yyfree (void * ptr )
-+{
-+	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
-+}
-+
-+#define YYTABLES_NAME "yytables"
-+
-+#line 74 "tokenparser.l"
-+
-+
-+
-+
-+static void eval_key(char *pcToken, list_t *list_key)
-+{
-+	struct bundleElt *elt;
-+	int r;
-+	size_t len;
-+
-+	/* create a new list element */
-+	elt = malloc(sizeof(*elt));
-+	assert(elt);
-+
-+	/* <key>foobar</key>
-+	 * 012345 : 5 is the first key character index */
-+
-+	/* calculate the argument length */
-+	for (len=0; pcToken[len+5] != '<'; len++)
-+		;
-+	len++;	/* final NULL byte */
-+
-+	elt->key = malloc(len);
-+	memcpy(elt->key, &pcToken[5], len-1);
-+	elt->key[len-1] = '\0';
-+
-+	r = list_init(&elt->values);
-+	assert(r >= 0);
-+	(void)r;
-+
-+	/* add the key/values */
-+	list_append(list_key, elt);
-+
-+	/* set the list to store the values */
-+	ListValues = &elt->values;
-+}
-+
-+static void eval_value(char *pcToken, list_t *list_values)
-+{
-+	int r;
-+	size_t len;
-+	char *value;
-+	char *amp;
-+
-+	/* <string>foobar</string>
-+	 * 012345678 : 8 is the first string character index */
-+
-+	/* calculate the argument length */
-+	for (len=0; pcToken[len+8] != '<'; len++)
-+		;
-+	len++;	/* final NULL byte */
-+
-+	value = malloc(len);
-+	assert(value);
-+
-+	memcpy(value, &pcToken[8], len-1);
-+	value[len-1] = '\0';
-+
-+	/* for all &amp; in the string */
-+	amp = value;
-+	while ((amp = strstr(amp, "&amp;")) != NULL)
-+	{
-+		char *p;
-+
-+		/* just skip "amp;" substring (4 letters) */
-+		for (p = amp+1; *(p+4); p++)
-+		{
-+			*p = *(p+4);
-+		}
-+		/* terminate the now shorter string */
-+		*p = '\0';
-+
-+		/* skip the & and continue */
-+		amp++;
-+	}
-+
-+	r = list_append(list_values, value);
-+	assert(r >= 0);
-+	(void)r;
-+}
-+
-+void tperrorCheck (char *token_error)
-+{
-+    (void)token_error;
-+}
-+
-+/**
-+ * Find an optional key in a configuration file
-+ * No error is logged if the key is not found
-+ *
-+ * @param l list generated by bundleParse()
-+ * @param key searched key
-+ * @param[out] values list of token value (if key found)
-+ * @retval 0 OK
-+ * @retval 1 key not found
-+ */
-+int LTPBundleFindValueWithKey(list_t *l, const char *key, list_t **values)
-+{
-+	unsigned int i;
-+	int ret = 1;
-+
-+	for (i=0; i < list_size(l); i++)
-+	{
-+		struct bundleElt *elt;
-+
-+		elt = list_get_at(l, i);
-+		assert(elt);
-+
-+		if (0 == strcmp(elt->key, key))
-+		{
-+			*values = &elt->values;
-+			ret = 0;
-+		}
-+	}
-+
-+	return ret;
-+}
-+
-+
-+/**
-+ * Parse a Info.plist file and file a list
-+ *
-+ * @param fileName file name
-+ * @param l list containing the results
-+ * @retval -1 configuration file not found
-+ * @retval 0 OK
-+ */
-+int bundleParse(const char *fileName, list_t *l)
-+{
-+	FILE *file = NULL;
-+	int r;
-+#ifndef NDEBUG
-+	int i;
-+#endif
-+
-+	file = fopen(fileName, "r");
-+	if (!file)
-+	{
-+		Log3(PCSC_LOG_CRITICAL, "Could not open bundle file %s: %s",
-+			fileName, strerror(errno));
-+		return 1;
-+	}
-+
-+	r = list_init(l);
-+	assert(r >= 0);
-+	(void)r;
-+
-+	ListKeys = l;
-+	yyin = file;
-+
-+	do
-+	{
-+		(void)yylex();
-+	} while (!feof(file));
-+	yylex_destroy();
-+
-+	(void)fclose(file);
-+
-+#ifndef NDEBUG
-+	printf("size: %d\n", list_size(l));
-+	for (i=0; i < list_size(l); i++)
-+	{
-+		struct bundleElt *elt;
-+		unsigned int j;
-+
-+		elt = list_get_at(l, i);
-+		assert(elt);
-+		printf("Key: %s\n", elt->key);
-+
-+		for (j=0; j<list_size(&elt->values); j++)
-+		{
-+			char *v = list_get_at(&elt->values, j);
-+			printf(" value: %s\n", v);
-+		}
-+	}
-+#endif
-+
-+	return 0;
-+}
-+
-+/**
-+ * Free the list created by bundleParse()
-+ *
-+ * @param l list containing the results
-+ */
-+void bundleRelease(list_t *l)
-+{
-+	unsigned int i;
-+
-+	for (i=0; i < list_size(l); i++)
-+	{
-+		struct bundleElt *elt;
-+		unsigned int j;
-+
-+		elt = list_get_at(l, i);
-+		assert(elt);
-+
-+		/* free all the values */
-+		for (j=0; j<list_size(&elt->values); j++)
-+			free(list_get_at(&elt->values, j));
-+		list_destroy(&elt->values);
-+
-+		/* free the key */
-+		free(elt->key);
-+		free(elt);
-+	}
-+
-+	list_destroy(l);
-+}
-+
-diff --git a/src/tokenparser.l b/src/tokenparser.l
-deleted file mode 120000
-index a703db9..0000000
---- a/src/tokenparser.l
-+++ /dev/null
-@@ -1 +0,0 @@
--../PCSC/src/tokenparser.l
-\ No newline at end of file
-diff --git a/src/tokenparser.l b/src/tokenparser.l
-new file mode 100644
-index 0000000..0dd47b4
---- /dev/null
-+++ b/src/tokenparser.l
-@@ -0,0 +1,282 @@
-+/*
-+ * Reads lexical config files and updates database.
-+ *
-+ * MUSCLE SmartCard Development ( http://pcsclite.alioth.debian.org/pcsclite.html )
-+ *
-+ * Copyright (C) 2001-2003
-+ *  David Corcoran <corcoran@musclecard.com>
-+ * Copyright (C) 2003-2010
-+ *  Ludovic Rousseau <ludovic.rousseau@free.fr>
-+ *
-+Redistribution and use in source and binary forms, with or without
-+modification, are permitted provided that the following conditions
-+are met:
-+
-+1. Redistributions of source code must retain the above copyright
-+   notice, this list of conditions and the following disclaimer.
-+2. Redistributions in binary form must reproduce the above copyright
-+   notice, this list of conditions and the following disclaimer in the
-+   documentation and/or other materials provided with the distribution.
-+3. The name of the author may not be used to endorse or promote products
-+   derived from this software without specific prior written permission.
-+
-+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+/**
-+ * @file
-+ * @brief provides parsing functions for Info.plist files
-+ * platforms
-+ */
-+
-+%{
-+
-+#include "config.h"
-+#include <stdio.h>
-+#include <string.h>
-+#include <errno.h>
-+#define NDEBUG
-+#include <assert.h>
-+
-+#include "simclist.h"
-+#include "debuglog.h"
-+#include "parser.h"
-+
-+static void eval_key(char *pcToken, list_t *list_key);
-+static void eval_value(char *pcToken, list_t *list_values);
-+void tperrorCheck (char *pcToken_error);
-+
-+static list_t *ListKeys;
-+static list_t *ListValues;
-+
-+%}
-+
-+%option nounput
-+%option noinput
-+%option noyywrap
-+
-+%%
-+
-+#.*                                             {}
-+"\n"                                            {}
-+\<key\>([A-Z]|[a-z]|[0-9]|[ \t])+\<\/key\>      { eval_key(yytext, ListKeys); }
-+[ \t]                                           {}
-+\<string\>([A-Z]|[a-z]|[0-9]|[ \t]|[!@#$%^&*()\-+/_\:?.,=~'";\[\]])+\<\/string\> { eval_value(yytext, ListValues); }
-+.                                               { tperrorCheck(yytext); }
-+%%
-+
-+
-+static void eval_key(char *pcToken, list_t *list_key)
-+{
-+	struct bundleElt *elt;
-+	int r;
-+	size_t len;
-+
-+	/* create a new list element */
-+	elt = malloc(sizeof(*elt));
-+	assert(elt);
-+
-+	/* <key>foobar</key>
-+	 * 012345 : 5 is the first key character index */
-+
-+	/* calculate the argument length */
-+	for (len=0; pcToken[len+5] != '<'; len++)
-+		;
-+	len++;	/* final NULL byte */
-+
-+	elt->key = malloc(len);
-+	memcpy(elt->key, &pcToken[5], len-1);
-+	elt->key[len-1] = '\0';
-+
-+	r = list_init(&elt->values);
-+	assert(r >= 0);
-+	(void)r;
-+
-+	/* add the key/values */
-+	list_append(list_key, elt);
-+
-+	/* set the list to store the values */
-+	ListValues = &elt->values;
-+}
-+
-+static void eval_value(char *pcToken, list_t *list_values)
-+{
-+	int r;
-+	size_t len;
-+	char *value;
-+	char *amp;
-+
-+	/* <string>foobar</string>
-+	 * 012345678 : 8 is the first string character index */
-+
-+	/* calculate the argument length */
-+	for (len=0; pcToken[len+8] != '<'; len++)
-+		;
-+	len++;	/* final NULL byte */
-+
-+	value = malloc(len);
-+	assert(value);
-+
-+	memcpy(value, &pcToken[8], len-1);
-+	value[len-1] = '\0';
-+
-+	/* for all &amp; in the string */
-+	amp = value;
-+	while ((amp = strstr(amp, "&amp;")) != NULL)
-+	{
-+		char *p;
-+
-+		/* just skip "amp;" substring (4 letters) */
-+		for (p = amp+1; *(p+4); p++)
-+		{
-+			*p = *(p+4);
-+		}
-+		/* terminate the now shorter string */
-+		*p = '\0';
-+
-+		/* skip the & and continue */
-+		amp++;
-+	}
-+
-+	r = list_append(list_values, value);
-+	assert(r >= 0);
-+	(void)r;
-+}
-+
-+void tperrorCheck (char *token_error)
-+{
-+    (void)token_error;
-+}
-+
-+/**
-+ * Find an optional key in a configuration file
-+ * No error is logged if the key is not found
-+ *
-+ * @param l list generated by bundleParse()
-+ * @param key searched key
-+ * @param[out] values list of token value (if key found)
-+ * @retval 0 OK
-+ * @retval 1 key not found
-+ */
-+int LTPBundleFindValueWithKey(list_t *l, const char *key, list_t **values)
-+{
-+	unsigned int i;
-+	int ret = 1;
-+
-+	for (i=0; i < list_size(l); i++)
-+	{
-+		struct bundleElt *elt;
-+
-+		elt = list_get_at(l, i);
-+		assert(elt);
-+
-+		if (0 == strcmp(elt->key, key))
-+		{
-+			*values = &elt->values;
-+			ret = 0;
-+		}
-+	}
-+
-+	return ret;
-+}
-+
-+
-+/**
-+ * Parse a Info.plist file and file a list
-+ *
-+ * @param fileName file name
-+ * @param l list containing the results
-+ * @retval -1 configuration file not found
-+ * @retval 0 OK
-+ */
-+int bundleParse(const char *fileName, list_t *l)
-+{
-+	FILE *file = NULL;
-+	int r;
-+#ifndef NDEBUG
-+	int i;
-+#endif
-+
-+	file = fopen(fileName, "r");
-+	if (!file)
-+	{
-+		Log3(PCSC_LOG_CRITICAL, "Could not open bundle file %s: %s",
-+			fileName, strerror(errno));
-+		return 1;
-+	}
-+
-+	r = list_init(l);
-+	assert(r >= 0);
-+	(void)r;
-+
-+	ListKeys = l;
-+	yyin = file;
-+
-+	do
-+	{
-+		(void)yylex();
-+	} while (!feof(file));
-+	yylex_destroy();
-+
-+	(void)fclose(file);
-+
-+#ifndef NDEBUG
-+	printf("size: %d\n", list_size(l));
-+	for (i=0; i < list_size(l); i++)
-+	{
-+		struct bundleElt *elt;
-+		unsigned int j;
-+
-+		elt = list_get_at(l, i);
-+		assert(elt);
-+		printf("Key: %s\n", elt->key);
-+
-+		for (j=0; j<list_size(&elt->values); j++)
-+		{
-+			char *v = list_get_at(&elt->values, j);
-+			printf(" value: %s\n", v);
-+		}
-+	}
-+#endif
-+
-+	return 0;
-+}
-+
-+/**
-+ * Free the list created by bundleParse()
-+ *
-+ * @param l list containing the results
-+ */
-+void bundleRelease(list_t *l)
-+{
-+	unsigned int i;
-+
-+	for (i=0; i < list_size(l); i++)
-+	{
-+		struct bundleElt *elt;
-+		unsigned int j;
-+
-+		elt = list_get_at(l, i);
-+		assert(elt);
-+
-+		/* free all the values */
-+		for (j=0; j<list_size(&elt->values); j++)
-+			free(list_get_at(&elt->values, j));
-+		list_destroy(&elt->values);
-+
-+		/* free the key */
-+		free(elt->key);
-+		free(elt);
-+	}
-+
-+	list_destroy(l);
-+}
--- 
-2.9.0
-
diff --git a/pkg/ccid/rev b/pkg/ccid/rev
deleted file mode 100644
index d00491fd..00000000
--- a/pkg/ccid/rev
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/pkg/ccid/src b/pkg/ccid/src
deleted file mode 160000
-Subproject a1197c49cee479f4187dfd05c900224b99127e1
diff --git a/pkg/gen.rc b/pkg/gen.rc
index 0c2bbd81..49bb36ba 100644
--- a/pkg/gen.rc
+++ b/pkg/gen.rc
@@ -7,7 +7,6 @@ subgen bc
 subgen bearssl
 subgen blind
 subgen bzip2
-subgen ccid
 subgen curl
 subgen discount
 subgen dmenu
@@ -62,7 +61,6 @@ subgen ninja
 subgen openbsd
 subgen openssh
 subgen pcre
-subgen pcsc
 subgen perp
 subgen pigz
 subgen pixman
diff --git a/pkg/pcsc/config.h b/pkg/pcsc/config.h
deleted file mode 100644
index 2b1bd274..00000000
--- a/pkg/pcsc/config.h
+++ /dev/null
@@ -1,66 +0,0 @@
-#include <config-posix.h>
-
-/* #undef AC_APPLE_UNIVERSAL_BUILD */
-/* #undef ATR_DEBUG */
-/* #undef CRAY_STACKSEG_END */
-/* #undef C_ALLOCA */
-/* #undef FILTER_NAMES */
-#define HAVE_ALLOCA 1
-#define HAVE_ALLOCA_H 1
-#define HAVE_DAEMON 1
-/* #undef HAVE_DL_H */
-/* #undef HAVE_DOPRNT */
-#define HAVE_FLOCK 1
-#define HAVE_GETOPT_H 1
-#define HAVE_GETOPT_LONG 1
-/* #undef HAVE_LIBUDEV */
-/* #undef HAVE_LIBUDEV_H */
-#define HAVE_LIBUSB 1
-#define HAVE_LIBUSB_H 1
-#define HAVE_MEMORY_H 1
-/* #undef HAVE_NDIR_H */
-/* #undef HAVE_POLKIT */
-#define HAVE_PTHREAD 1
-#define HAVE_PTHREAD_PRIO_INHERIT 1
-/* #undef HAVE_STAT_EMPTY_STRING_BUG */
-#define HAVE_STRUCT_DIRENT_D_TYPE 1
-/* #undef HAVE_SYS_DIR_H */
-/* #undef HAVE_SYS_FILIO_H */
-/* #undef HAVE_SYS_NDIR_H */
-#define LT_OBJDIR ".libs/"
-/* #undef NO_LOG */
-#define PACKAGE "pcsc-lite"
-#define PACKAGE_BUGREPORT ""
-#define PACKAGE_NAME "pcsc-lite"
-#define PACKAGE_STRING "pcsc-lite 1.8.17"
-#define PACKAGE_TARNAME "pcsc-lite"
-#define PACKAGE_URL ""
-#define PACKAGE_VERSION "1.8.17"
-#define PCSCD_BINARY "/sbin/pcscd"
-#define PCSCLITE_FEATURES " Linux x86_64-unknown-linux-gnu usb usbdropdir=/lib/pcsc/drivers ipcdir=/var/run/pcscd configdir=/etc/reader.conf.d"
-#define PCSCLITE_HP_DROPDIR "/lib/pcsc/drivers"
-#define PCSC_ARCH "Linux"
-/* #undef PTHREAD_CREATE_JOINABLE */
-/* #undef STACK_DIRECTION */
-#define TIME_WITH_SYS_TIME 1
-#define USE_IPCDIR "/var/run/pcscd"
-/* #undef USE_SERIAL */
-#define USE_USB 1
-#define VERSION "1.8.17"
-#if defined AC_APPLE_UNIVERSAL_BUILD
-# if defined __BIG_ENDIAN__
-#  define WORDS_BIGENDIAN 1
-# endif
-#else
-# ifndef WORDS_BIGENDIAN
-/* #  undef WORDS_BIGENDIAN */
-# endif
-#endif
-/* #undef YYTEXT_POINTER */
-/* #undef const */
-/* #undef gid_t */
-#ifndef __cplusplus
-/* #undef inline */
-#endif
-/* #undef size_t */
-/* #undef uid_t */
diff --git a/pkg/pcsc/gen.rc b/pkg/pcsc/gen.rc
deleted file mode 100644
index 90d33c87..00000000
--- a/pkg/pcsc/gen.rc
+++ /dev/null
@@ -1,34 +0,0 @@
-version=1.8.17
-cflags\
-	-D HAVE_CONFIG_H\
-	-I include\
-	-I '$dir' \
-	-I '$outdir' \
-	-I '$outdir'/include\
-	-I '$srcdir'/src/PCSC
-
-set subst\
-	-e s,@VERSION@,$version,\
-	-e s,@PCSCLITE_CONFIG_DIR@,/etc/reader.conf.d,
-
-hdrs=(debuglog.h ifdhandler.h reader.h winscard.h wintypes.h)
-for(hdr in $hdrs)
-	build '$outdir'/include/$hdr copy '$srcdir'/src/PCSC/$hdr
-build '$outdir'/include/pcsclite.h sed '$srcdir'/src/PCSC/pcsclite.h.in ; with expr '$subst'
-hdrs=($hdrs pcsclite.h)
-phony headers '$outdir'/include/$hdrs
-
-build '$outdir'/pcscd.h sed '$srcdir'/src/pcscd.h.in ; with expr '$subst'
-phony deps '$outdir'/pcscd.h '$dir'/headers
-
-lib libpcsclite.a -d '$dir'/deps src/^(\
-	debug.c\
-	error.c\
-	winscard_clnt.c\
-	simclist.c\
-	sys_unix.c\
-	utils.c\
-	winscard_msg.c\
-)
-
-fetch git
diff --git a/pkg/pcsc/patch/0001-Add-tokenparser.c-from-pcsc-1.8.17-distribution.patch b/pkg/pcsc/patch/0001-Add-tokenparser.c-from-pcsc-1.8.17-distribution.patch
deleted file mode 100644
index 9c99d360..00000000
--- a/pkg/pcsc/patch/0001-Add-tokenparser.c-from-pcsc-1.8.17-distribution.patch
+++ /dev/null
@@ -1,2058 +0,0 @@
-From 13f8dbbd6cd2de7ac0c0567df53b72e82bc21d2d Mon Sep 17 00:00:00 2001
-From: Michael Forney <mforney@mforney.org>
-Date: Tue, 5 Jul 2016 23:13:48 -0700
-Subject: [PATCH] Add tokenparser.c from pcsc 1.8.17 distribution
-
----
- src/tokenparser.c | 2039 +++++++++++++++++++++++++++++++++++++++++++++++++++++
- 1 file changed, 2039 insertions(+)
- create mode 100644 src/tokenparser.c
-
-diff --git a/src/tokenparser.c b/src/tokenparser.c
-new file mode 100644
-index 0000000..94cee67
---- /dev/null
-+++ b/src/tokenparser.c
-@@ -0,0 +1,2039 @@
-+
-+#line 3 "tokenparser.c"
-+
-+#define  YY_INT_ALIGNED short int
-+
-+/* A lexical scanner generated by flex */
-+
-+#define yy_create_buffer tp_create_buffer
-+#define yy_delete_buffer tp_delete_buffer
-+#define yy_flex_debug tp_flex_debug
-+#define yy_init_buffer tp_init_buffer
-+#define yy_flush_buffer tp_flush_buffer
-+#define yy_load_buffer_state tp_load_buffer_state
-+#define yy_switch_to_buffer tp_switch_to_buffer
-+#define yyin tpin
-+#define yyleng tpleng
-+#define yylex tplex
-+#define yylineno tplineno
-+#define yyout tpout
-+#define yyrestart tprestart
-+#define yytext tptext
-+#define yywrap tpwrap
-+#define yyalloc tpalloc
-+#define yyrealloc tprealloc
-+#define yyfree tpfree
-+
-+#define FLEX_SCANNER
-+#define YY_FLEX_MAJOR_VERSION 2
-+#define YY_FLEX_MINOR_VERSION 5
-+#define YY_FLEX_SUBMINOR_VERSION 39
-+#if YY_FLEX_SUBMINOR_VERSION > 0
-+#define FLEX_BETA
-+#endif
-+
-+/* First, we deal with  platform-specific or compiler-specific issues. */
-+
-+/* begin standard C headers. */
-+#include <stdio.h>
-+#include <string.h>
-+#include <errno.h>
-+#include <stdlib.h>
-+
-+/* end standard C headers. */
-+
-+/* flex integer type definitions */
-+
-+#ifndef FLEXINT_H
-+#define FLEXINT_H
-+
-+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
-+
-+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-+
-+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
-+ * if you want the limit (max/min) macros for int types. 
-+ */
-+#ifndef __STDC_LIMIT_MACROS
-+#define __STDC_LIMIT_MACROS 1
-+#endif
-+
-+#include <inttypes.h>
-+typedef int8_t flex_int8_t;
-+typedef uint8_t flex_uint8_t;
-+typedef int16_t flex_int16_t;
-+typedef uint16_t flex_uint16_t;
-+typedef int32_t flex_int32_t;
-+typedef uint32_t flex_uint32_t;
-+#else
-+typedef signed char flex_int8_t;
-+typedef short int flex_int16_t;
-+typedef int flex_int32_t;
-+typedef unsigned char flex_uint8_t; 
-+typedef unsigned short int flex_uint16_t;
-+typedef unsigned int flex_uint32_t;
-+
-+/* Limits of integral types. */
-+#ifndef INT8_MIN
-+#define INT8_MIN               (-128)
-+#endif
-+#ifndef INT16_MIN
-+#define INT16_MIN              (-32767-1)
-+#endif
-+#ifndef INT32_MIN
-+#define INT32_MIN              (-2147483647-1)
-+#endif
-+#ifndef INT8_MAX
-+#define INT8_MAX               (127)
-+#endif
-+#ifndef INT16_MAX
-+#define INT16_MAX              (32767)
-+#endif
-+#ifndef INT32_MAX
-+#define INT32_MAX              (2147483647)
-+#endif
-+#ifndef UINT8_MAX
-+#define UINT8_MAX              (255U)
-+#endif
-+#ifndef UINT16_MAX
-+#define UINT16_MAX             (65535U)
-+#endif
-+#ifndef UINT32_MAX
-+#define UINT32_MAX             (4294967295U)
-+#endif
-+
-+#endif /* ! C99 */
-+
-+#endif /* ! FLEXINT_H */
-+
-+#ifdef __cplusplus
-+
-+/* The "const" storage-class-modifier is valid. */
-+#define YY_USE_CONST
-+
-+#else	/* ! __cplusplus */
-+
-+/* C99 requires __STDC__ to be defined as 1. */
-+#if defined (__STDC__)
-+
-+#define YY_USE_CONST
-+
-+#endif	/* defined (__STDC__) */
-+#endif	/* ! __cplusplus */
-+
-+#ifdef YY_USE_CONST
-+#define yyconst const
-+#else
-+#define yyconst
-+#endif
-+
-+/* Returned upon end-of-file. */
-+#define YY_NULL 0
-+
-+/* Promotes a possibly negative, possibly signed char to an unsigned
-+ * integer for use as an array index.  If the signed char is negative,
-+ * we want to instead treat it as an 8-bit unsigned char, hence the
-+ * double cast.
-+ */
-+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
-+
-+/* Enter a start condition.  This macro really ought to take a parameter,
-+ * but we do it the disgusting crufty way forced on us by the ()-less
-+ * definition of BEGIN.
-+ */
-+#define BEGIN (yy_start) = 1 + 2 *
-+
-+/* Translate the current start state into a value that can be later handed
-+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
-+ * compatibility.
-+ */
-+#define YY_START (((yy_start) - 1) / 2)
-+#define YYSTATE YY_START
-+
-+/* Action number for EOF rule of a given start state. */
-+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
-+
-+/* Special action meaning "start processing a new file". */
-+#define YY_NEW_FILE tprestart(tpin  )
-+
-+#define YY_END_OF_BUFFER_CHAR 0
-+
-+/* Size of default input buffer. */
-+#ifndef YY_BUF_SIZE
-+#ifdef __ia64__
-+/* On IA-64, the buffer size is 16k, not 8k.
-+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
-+ * Ditto for the __ia64__ case accordingly.
-+ */
-+#define YY_BUF_SIZE 32768
-+#else
-+#define YY_BUF_SIZE 16384
-+#endif /* __ia64__ */
-+#endif
-+
-+/* The state buf must be large enough to hold one state per character in the main buffer.
-+ */
-+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
-+
-+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
-+#define YY_TYPEDEF_YY_BUFFER_STATE
-+typedef struct yy_buffer_state *YY_BUFFER_STATE;
-+#endif
-+
-+#ifndef YY_TYPEDEF_YY_SIZE_T
-+#define YY_TYPEDEF_YY_SIZE_T
-+typedef size_t yy_size_t;
-+#endif
-+
-+extern yy_size_t tpleng;
-+
-+extern FILE *tpin, *tpout;
-+
-+#define EOB_ACT_CONTINUE_SCAN 0
-+#define EOB_ACT_END_OF_FILE 1
-+#define EOB_ACT_LAST_MATCH 2
-+
-+    #define YY_LESS_LINENO(n)
-+    #define YY_LINENO_REWIND_TO(ptr)
-+    
-+/* Return all but the first "n" matched characters back to the input stream. */
-+#define yyless(n) \
-+	do \
-+		{ \
-+		/* Undo effects of setting up tptext. */ \
-+        int yyless_macro_arg = (n); \
-+        YY_LESS_LINENO(yyless_macro_arg);\
-+		*yy_cp = (yy_hold_char); \
-+		YY_RESTORE_YY_MORE_OFFSET \
-+		(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
-+		YY_DO_BEFORE_ACTION; /* set up tptext again */ \
-+		} \
-+	while ( 0 )
-+
-+#define unput(c) yyunput( c, (yytext_ptr)  )
-+
-+#ifndef YY_STRUCT_YY_BUFFER_STATE
-+#define YY_STRUCT_YY_BUFFER_STATE
-+struct yy_buffer_state
-+	{
-+	FILE *yy_input_file;
-+
-+	char *yy_ch_buf;		/* input buffer */
-+	char *yy_buf_pos;		/* current position in input buffer */
-+
-+	/* Size of input buffer in bytes, not including room for EOB
-+	 * characters.
-+	 */
-+	yy_size_t yy_buf_size;
-+
-+	/* Number of characters read into yy_ch_buf, not including EOB
-+	 * characters.
-+	 */
-+	yy_size_t yy_n_chars;
-+
-+	/* Whether we "own" the buffer - i.e., we know we created it,
-+	 * and can realloc() it to grow it, and should free() it to
-+	 * delete it.
-+	 */
-+	int yy_is_our_buffer;
-+
-+	/* Whether this is an "interactive" input source; if so, and
-+	 * if we're using stdio for input, then we want to use getc()
-+	 * instead of fread(), to make sure we stop fetching input after
-+	 * each newline.
-+	 */
-+	int yy_is_interactive;
-+
-+	/* Whether we're considered to be at the beginning of a line.
-+	 * If so, '^' rules will be active on the next match, otherwise
-+	 * not.
-+	 */
-+	int yy_at_bol;
-+
-+    int yy_bs_lineno; /**< The line count. */
-+    int yy_bs_column; /**< The column count. */
-+    
-+	/* Whether to try to fill the input buffer when we reach the
-+	 * end of it.
-+	 */
-+	int yy_fill_buffer;
-+
-+	int yy_buffer_status;
-+
-+#define YY_BUFFER_NEW 0
-+#define YY_BUFFER_NORMAL 1
-+	/* When an EOF's been seen but there's still some text to process
-+	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
-+	 * shouldn't try reading from the input source any more.  We might
-+	 * still have a bunch of tokens to match, though, because of
-+	 * possible backing-up.
-+	 *
-+	 * When we actually see the EOF, we change the status to "new"
-+	 * (via tprestart()), so that the user can continue scanning by
-+	 * just pointing tpin at a new input file.
-+	 */
-+#define YY_BUFFER_EOF_PENDING 2
-+
-+	};
-+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
-+
-+/* Stack of input buffers. */
-+static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
-+static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
-+static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
-+
-+/* We provide macros for accessing buffer states in case in the
-+ * future we want to put the buffer states in a more general
-+ * "scanner state".
-+ *
-+ * Returns the top of the stack, or NULL.
-+ */
-+#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
-+                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
-+                          : NULL)
-+
-+/* Same as previous macro, but useful when we know that the buffer stack is not
-+ * NULL or when we need an lvalue. For internal use only.
-+ */
-+#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
-+
-+/* yy_hold_char holds the character lost when tptext is formed. */
-+static char yy_hold_char;
-+static yy_size_t yy_n_chars;		/* number of characters read into yy_ch_buf */
-+yy_size_t tpleng;
-+
-+/* Points to current character in buffer. */
-+static char *yy_c_buf_p = (char *) 0;
-+static int yy_init = 0;		/* whether we need to initialize */
-+static int yy_start = 0;	/* start state number */
-+
-+/* Flag which is used to allow tpwrap()'s to do buffer switches
-+ * instead of setting up a fresh tpin.  A bit of a hack ...
-+ */
-+static int yy_did_buffer_switch_on_eof;
-+
-+void tprestart (FILE *input_file  );
-+void tp_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
-+YY_BUFFER_STATE tp_create_buffer (FILE *file,int size  );
-+void tp_delete_buffer (YY_BUFFER_STATE b  );
-+void tp_flush_buffer (YY_BUFFER_STATE b  );
-+void tppush_buffer_state (YY_BUFFER_STATE new_buffer  );
-+void tppop_buffer_state (void );
-+
-+static void tpensure_buffer_stack (void );
-+static void tp_load_buffer_state (void );
-+static void tp_init_buffer (YY_BUFFER_STATE b,FILE *file  );
-+
-+#define YY_FLUSH_BUFFER tp_flush_buffer(YY_CURRENT_BUFFER )
-+
-+YY_BUFFER_STATE tp_scan_buffer (char *base,yy_size_t size  );
-+YY_BUFFER_STATE tp_scan_string (yyconst char *yy_str  );
-+YY_BUFFER_STATE tp_scan_bytes (yyconst char *bytes,yy_size_t len  );
-+
-+void *tpalloc (yy_size_t  );
-+void *tprealloc (void *,yy_size_t  );
-+void tpfree (void *  );
-+
-+#define yy_new_buffer tp_create_buffer
-+
-+#define yy_set_interactive(is_interactive) \
-+	{ \
-+	if ( ! YY_CURRENT_BUFFER ){ \
-+        tpensure_buffer_stack (); \
-+		YY_CURRENT_BUFFER_LVALUE =    \
-+            tp_create_buffer(tpin,YY_BUF_SIZE ); \
-+	} \
-+	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
-+	}
-+
-+#define yy_set_bol(at_bol) \
-+	{ \
-+	if ( ! YY_CURRENT_BUFFER ){\
-+        tpensure_buffer_stack (); \
-+		YY_CURRENT_BUFFER_LVALUE =    \
-+            tp_create_buffer(tpin,YY_BUF_SIZE ); \
-+	} \
-+	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
-+	}
-+
-+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
-+
-+/* Begin user sect3 */
-+
-+#define tpwrap() 1
-+#define YY_SKIP_YYWRAP
-+
-+typedef unsigned char YY_CHAR;
-+
-+FILE *tpin = (FILE *) 0, *tpout = (FILE *) 0;
-+
-+typedef int yy_state_type;
-+
-+extern int tplineno;
-+
-+int tplineno = 1;
-+
-+extern char *tptext;
-+#define yytext_ptr tptext
-+
-+static yy_state_type yy_get_previous_state (void );
-+static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
-+static int yy_get_next_buffer (void );
-+static void yy_fatal_error (yyconst char msg[]  );
-+
-+/* Done after the current pattern has been matched and before the
-+ * corresponding action - sets up tptext.
-+ */
-+#define YY_DO_BEFORE_ACTION \
-+	(yytext_ptr) = yy_bp; \
-+	tpleng = (size_t) (yy_cp - yy_bp); \
-+	(yy_hold_char) = *yy_cp; \
-+	*yy_cp = '\0'; \
-+	(yy_c_buf_p) = yy_cp;
-+
-+#define YY_NUM_RULES 7
-+#define YY_END_OF_BUFFER 8
-+/* This struct is not used in this scanner,
-+   but its presence is necessary. */
-+struct yy_trans_info
-+	{
-+	flex_int32_t yy_verify;
-+	flex_int32_t yy_nxt;
-+	};
-+static yyconst flex_int16_t yy_accept[39] =
-+    {   0,
-+        0,    0,    8,    6,    4,    2,    1,    6,    1,    0,
-+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-+        0,    0,    0,    0,    0,    0,    0,    0,    0,    3,
-+        0,    0,    0,    0,    0,    0,    5,    0
-+    } ;
-+
-+static yyconst flex_int32_t yy_ec[256] =
-+    {   0,
-+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    2,    4,    4,    5,    4,    4,    4,    4,    4,
-+        4,    4,    4,    4,    4,    4,    6,    7,    7,    7,
-+        7,    7,    7,    7,    7,    7,    7,    4,    4,    8,
-+        4,    9,    4,    4,   10,   10,   10,   10,   10,   10,
-+       10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
-+       10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
-+        4,    1,    4,    4,    4,    1,   11,   11,   11,   11,
-+
-+       12,   11,   13,   11,   14,   11,   15,   11,   11,   16,
-+       11,   11,   11,   17,   18,   19,   11,   11,   11,   11,
-+       20,   11,    1,    1,    1,    4,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-+        1,    1,    1,    1,    1
-+    } ;
-+
-+static yyconst flex_int32_t yy_meta[21] =
-+    {   0,
-+        1,    2,    3,    4,    4,    4,    2,    1,    1,    2,
-+        2,    2,    2,    2,    2,    2,    2,    2,    2,    2
-+    } ;
-+
-+static yyconst flex_int16_t yy_base[43] =
-+    {   0,
-+        0,    7,   49,   50,   50,   50,    0,    1,    0,   36,
-+       28,   26,   28,   35,   29,    0,   26,   33,   27,   33,
-+       29,   22,    0,   24,   27,   14,   27,   23,   13,   50,
-+       10,    9,    4,    1,    0,    2,   50,   50,   19,   23,
-+        2,   26
-+    } ;
-+
-+static yyconst flex_int16_t yy_def[43] =
-+    {   0,
-+       39,   39,   38,   38,   38,   38,   40,   38,   40,   38,
-+       38,   38,   38,   38,   38,   41,   38,   41,   38,   38,
-+       38,   38,   42,   38,   42,   38,   38,   38,   38,   38,
-+       38,   38,   38,   38,   38,   38,   38,    0,   38,   38,
-+       38,   38
-+    } ;
-+
-+static yyconst flex_int16_t yy_nxt[71] =
-+    {   0,
-+       38,    5,    6,   18,    7,   38,   38,    8,    5,    6,
-+       37,    7,   36,   38,    8,   10,   35,   34,   11,    4,
-+        4,    4,    4,    9,    9,   33,    9,   25,   32,   25,
-+       31,   30,   29,   28,   27,   26,   24,   23,   22,   21,
-+       20,   19,   17,   16,   15,   14,   13,   12,   38,    3,
-+       38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
-+       38,   38,   38,   38,   38,   38,   38,   38,   38,   38
-+    } ;
-+
-+static yyconst flex_int16_t yy_chk[71] =
-+    {   0,
-+        0,    1,    1,   41,    1,    0,    0,    1,    2,    2,
-+       36,    2,   35,    0,    2,    8,   34,   33,    8,   39,
-+       39,   39,   39,   40,   40,   32,   40,   42,   31,   42,
-+       29,   28,   27,   26,   25,   24,   22,   21,   20,   19,
-+       18,   17,   15,   14,   13,   12,   11,   10,    3,   38,
-+       38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
-+       38,   38,   38,   38,   38,   38,   38,   38,   38,   38
-+    } ;
-+
-+static yy_state_type yy_last_accepting_state;
-+static char *yy_last_accepting_cpos;
-+
-+extern int tp_flex_debug;
-+int tp_flex_debug = 0;
-+
-+/* The intent behind this definition is that it'll catch
-+ * any uses of REJECT which flex missed.
-+ */
-+#define REJECT reject_used_but_not_detected
-+#define yymore() yymore_used_but_not_detected
-+#define YY_MORE_ADJ 0
-+#define YY_RESTORE_YY_MORE_OFFSET
-+char *tptext;
-+#line 1 "tokenparser.l"
-+/*
-+ * Reads lexical config files and updates database.
-+ *
-+ * MUSCLE SmartCard Development ( http://pcsclite.alioth.debian.org/pcsclite.html )
-+ *
-+ * Copyright (C) 2001-2003
-+ *  David Corcoran <corcoran@musclecard.com>
-+ * Copyright (C) 2003-2010
-+ *  Ludovic Rousseau <ludovic.rousseau@free.fr>
-+ *
-+Redistribution and use in source and binary forms, with or without
-+modification, are permitted provided that the following conditions
-+are met:
-+
-+1. Redistributions of source code must retain the above copyright
-+   notice, this list of conditions and the following disclaimer.
-+2. Redistributions in binary form must reproduce the above copyright
-+   notice, this list of conditions and the following disclaimer in the
-+   documentation and/or other materials provided with the distribution.
-+3. The name of the author may not be used to endorse or promote products
-+   derived from this software without specific prior written permission.
-+
-+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-+ */
-+/**
-+ * @file
-+ * @brief provides parsing functions for Info.plist files
-+ * platforms
-+ */
-+#line 42 "tokenparser.l"
-+
-+#include "config.h"
-+#include <stdio.h>
-+#include <string.h>
-+#include <errno.h>
-+#define NDEBUG
-+#include <assert.h>
-+
-+#include "simclist.h"
-+#include "debuglog.h"
-+#include "parser.h"
-+
-+static void eval_key(char *pcToken, list_t *list_key);
-+static void eval_value(char *pcToken, list_t *list_values);
-+void tperrorCheck (char *pcToken_error);
-+
-+static list_t *ListKeys;
-+static list_t *ListValues;
-+
-+#define YY_NO_INPUT 1
-+#line 564 "tokenparser.c"
-+
-+#define INITIAL 0
-+
-+#ifndef YY_NO_UNISTD_H
-+/* Special case for "unistd.h", since it is non-ANSI. We include it way
-+ * down here because we want the user's section 1 to have been scanned first.
-+ * The user has a chance to override it with an option.
-+ */
-+#include <unistd.h>
-+#endif
-+
-+#ifndef YY_EXTRA_TYPE
-+#define YY_EXTRA_TYPE void *
-+#endif
-+
-+static int yy_init_globals (void );
-+
-+/* Accessor methods to globals.
-+   These are made visible to non-reentrant scanners for convenience. */
-+
-+int tplex_destroy (void );
-+
-+int tpget_debug (void );
-+
-+void tpset_debug (int debug_flag  );
-+
-+YY_EXTRA_TYPE tpget_extra (void );
-+
-+void tpset_extra (YY_EXTRA_TYPE user_defined  );
-+
-+FILE *tpget_in (void );
-+
-+void tpset_in  (FILE * in_str  );
-+
-+FILE *tpget_out (void );
-+
-+void tpset_out  (FILE * out_str  );
-+
-+yy_size_t tpget_leng (void );
-+
-+char *tpget_text (void );
-+
-+int tpget_lineno (void );
-+
-+void tpset_lineno (int line_number  );
-+
-+/* Macros after this point can all be overridden by user definitions in
-+ * section 1.
-+ */
-+
-+#ifndef YY_SKIP_YYWRAP
-+#ifdef __cplusplus
-+extern "C" int tpwrap (void );
-+#else
-+extern int tpwrap (void );
-+#endif
-+#endif
-+
-+#ifndef yytext_ptr
-+static void yy_flex_strncpy (char *,yyconst char *,int );
-+#endif
-+
-+#ifdef YY_NEED_STRLEN
-+static int yy_flex_strlen (yyconst char * );
-+#endif
-+
-+#ifndef YY_NO_INPUT
-+
-+#ifdef __cplusplus
-+static int yyinput (void );
-+#else
-+static int input (void );
-+#endif
-+
-+#endif
-+
-+/* Amount of stuff to slurp up with each read. */
-+#ifndef YY_READ_BUF_SIZE
-+#ifdef __ia64__
-+/* On IA-64, the buffer size is 16k, not 8k */
-+#define YY_READ_BUF_SIZE 16384
-+#else
-+#define YY_READ_BUF_SIZE 8192
-+#endif /* __ia64__ */
-+#endif
-+
-+/* Copy whatever the last rule matched to the standard output. */
-+#ifndef ECHO
-+/* This used to be an fputs(), but since the string might contain NUL's,
-+ * we now use fwrite().
-+ */
-+#define ECHO do { if (fwrite( tptext, tpleng, 1, tpout )) {} } while (0)
-+#endif
-+
-+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
-+ * is returned in "result".
-+ */
-+#ifndef YY_INPUT
-+#define YY_INPUT(buf,result,max_size) \
-+	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
-+		{ \
-+		int c = '*'; \
-+		size_t n; \
-+		for ( n = 0; n < max_size && \
-+			     (c = getc( tpin )) != EOF && c != '\n'; ++n ) \
-+			buf[n] = (char) c; \
-+		if ( c == '\n' ) \
-+			buf[n++] = (char) c; \
-+		if ( c == EOF && ferror( tpin ) ) \
-+			YY_FATAL_ERROR( "input in flex scanner failed" ); \
-+		result = n; \
-+		} \
-+	else \
-+		{ \
-+		errno=0; \
-+		while ( (result = fread(buf, 1, max_size, tpin))==0 && ferror(tpin)) \
-+			{ \
-+			if( errno != EINTR) \
-+				{ \
-+				YY_FATAL_ERROR( "input in flex scanner failed" ); \
-+				break; \
-+				} \
-+			errno=0; \
-+			clearerr(tpin); \
-+			} \
-+		}\
-+\
-+
-+#endif
-+
-+/* No semi-colon after return; correct usage is to write "yyterminate();" -
-+ * we don't want an extra ';' after the "return" because that will cause
-+ * some compilers to complain about unreachable statements.
-+ */
-+#ifndef yyterminate
-+#define yyterminate() return YY_NULL
-+#endif
-+
-+/* Number of entries by which start-condition stack grows. */
-+#ifndef YY_START_STACK_INCR
-+#define YY_START_STACK_INCR 25
-+#endif
-+
-+/* Report a fatal error. */
-+#ifndef YY_FATAL_ERROR
-+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
-+#endif
-+
-+/* end tables serialization structures and prototypes */
-+
-+/* Default declaration of generated scanner - a define so the user can
-+ * easily add parameters.
-+ */
-+#ifndef YY_DECL
-+#define YY_DECL_IS_OURS 1
-+
-+extern int tplex (void);
-+
-+#define YY_DECL int tplex (void)
-+#endif /* !YY_DECL */
-+
-+/* Code executed at the beginning of each rule, after tptext and tpleng
-+ * have been set up.
-+ */
-+#ifndef YY_USER_ACTION
-+#define YY_USER_ACTION
-+#endif
-+
-+/* Code executed at the end of each rule. */
-+#ifndef YY_BREAK
-+#define YY_BREAK break;
-+#endif
-+
-+#define YY_RULE_SETUP \
-+	YY_USER_ACTION
-+
-+/** The main scanner function which does all the work.
-+ */
-+YY_DECL
-+{
-+	register yy_state_type yy_current_state;
-+	register char *yy_cp, *yy_bp;
-+	register int yy_act;
-+    
-+	if ( !(yy_init) )
-+		{
-+		(yy_init) = 1;
-+
-+#ifdef YY_USER_INIT
-+		YY_USER_INIT;
-+#endif
-+
-+		if ( ! (yy_start) )
-+			(yy_start) = 1;	/* first start state */
-+
-+		if ( ! tpin )
-+			tpin = stdin;
-+
-+		if ( ! tpout )
-+			tpout = stdout;
-+
-+		if ( ! YY_CURRENT_BUFFER ) {
-+			tpensure_buffer_stack ();
-+			YY_CURRENT_BUFFER_LVALUE =
-+				tp_create_buffer(tpin,YY_BUF_SIZE );
-+		}
-+
-+		tp_load_buffer_state( );
-+		}
-+
-+	{
-+#line 67 "tokenparser.l"
-+
-+
-+#line 779 "tokenparser.c"
-+
-+	while ( 1 )		/* loops until end-of-file is reached */
-+		{
-+		yy_cp = (yy_c_buf_p);
-+
-+		/* Support of tptext. */
-+		*yy_cp = (yy_hold_char);
-+
-+		/* yy_bp points to the position in yy_ch_buf of the start of
-+		 * the current run.
-+		 */
-+		yy_bp = yy_cp;
-+
-+		yy_current_state = (yy_start);
-+yy_match:
-+		do
-+			{
-+			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
-+			if ( yy_accept[yy_current_state] )
-+				{
-+				(yy_last_accepting_state) = yy_current_state;
-+				(yy_last_accepting_cpos) = yy_cp;
-+				}
-+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-+				{
-+				yy_current_state = (int) yy_def[yy_current_state];
-+				if ( yy_current_state >= 39 )
-+					yy_c = yy_meta[(unsigned int) yy_c];
-+				}
-+			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-+			++yy_cp;
-+			}
-+		while ( yy_base[yy_current_state] != 50 );
-+
-+yy_find_action:
-+		yy_act = yy_accept[yy_current_state];
-+		if ( yy_act == 0 )
-+			{ /* have to back up */
-+			yy_cp = (yy_last_accepting_cpos);
-+			yy_current_state = (yy_last_accepting_state);
-+			yy_act = yy_accept[yy_current_state];
-+			}
-+
-+		YY_DO_BEFORE_ACTION;
-+
-+do_action:	/* This label is used only to access EOF actions. */
-+
-+		switch ( yy_act )
-+	{ /* beginning of action switch */
-+			case 0: /* must back up */
-+			/* undo the effects of YY_DO_BEFORE_ACTION */
-+			*yy_cp = (yy_hold_char);
-+			yy_cp = (yy_last_accepting_cpos);
-+			yy_current_state = (yy_last_accepting_state);
-+			goto yy_find_action;
-+
-+case 1:
-+YY_RULE_SETUP
-+#line 69 "tokenparser.l"
-+{}
-+	YY_BREAK
-+case 2:
-+/* rule 2 can match eol */
-+YY_RULE_SETUP
-+#line 70 "tokenparser.l"
-+{}
-+	YY_BREAK
-+case 3:
-+YY_RULE_SETUP
-+#line 71 "tokenparser.l"
-+{ eval_key(tptext, ListKeys); }
-+	YY_BREAK
-+case 4:
-+YY_RULE_SETUP
-+#line 72 "tokenparser.l"
-+{}
-+	YY_BREAK
-+case 5:
-+YY_RULE_SETUP
-+#line 73 "tokenparser.l"
-+{ eval_value(tptext, ListValues); }
-+	YY_BREAK
-+case 6:
-+YY_RULE_SETUP
-+#line 74 "tokenparser.l"
-+{ tperrorCheck(tptext); }
-+	YY_BREAK
-+case 7:
-+YY_RULE_SETUP
-+#line 75 "tokenparser.l"
-+ECHO;
-+	YY_BREAK
-+#line 872 "tokenparser.c"
-+case YY_STATE_EOF(INITIAL):
-+	yyterminate();
-+
-+	case YY_END_OF_BUFFER:
-+		{
-+		/* Amount of text matched not including the EOB char. */
-+		int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
-+
-+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
-+		*yy_cp = (yy_hold_char);
-+		YY_RESTORE_YY_MORE_OFFSET
-+
-+		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
-+			{
-+			/* We're scanning a new file or input source.  It's
-+			 * possible that this happened because the user
-+			 * just pointed tpin at a new source and called
-+			 * tplex().  If so, then we have to assure
-+			 * consistency between YY_CURRENT_BUFFER and our
-+			 * globals.  Here is the right place to do so, because
-+			 * this is the first action (other than possibly a
-+			 * back-up) that will match for the new input source.
-+			 */
-+			(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-+			YY_CURRENT_BUFFER_LVALUE->yy_input_file = tpin;
-+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
-+			}
-+
-+		/* Note that here we test for yy_c_buf_p "<=" to the position
-+		 * of the first EOB in the buffer, since yy_c_buf_p will
-+		 * already have been incremented past the NUL character
-+		 * (since all states make transitions on EOB to the
-+		 * end-of-buffer state).  Contrast this with the test
-+		 * in input().
-+		 */
-+		if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
-+			{ /* This was really a NUL. */
-+			yy_state_type yy_next_state;
-+
-+			(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
-+
-+			yy_current_state = yy_get_previous_state(  );
-+
-+			/* Okay, we're now positioned to make the NUL
-+			 * transition.  We couldn't have
-+			 * yy_get_previous_state() go ahead and do it
-+			 * for us because it doesn't know how to deal
-+			 * with the possibility of jamming (and we don't
-+			 * want to build jamming into it because then it
-+			 * will run more slowly).
-+			 */
-+
-+			yy_next_state = yy_try_NUL_trans( yy_current_state );
-+
-+			yy_bp = (yytext_ptr) + YY_MORE_ADJ;
-+
-+			if ( yy_next_state )
-+				{
-+				/* Consume the NUL. */
-+				yy_cp = ++(yy_c_buf_p);
-+				yy_current_state = yy_next_state;
-+				goto yy_match;
-+				}
-+
-+			else
-+				{
-+				yy_cp = (yy_c_buf_p);
-+				goto yy_find_action;
-+				}
-+			}
-+
-+		else switch ( yy_get_next_buffer(  ) )
-+			{
-+			case EOB_ACT_END_OF_FILE:
-+				{
-+				(yy_did_buffer_switch_on_eof) = 0;
-+
-+				if ( tpwrap( ) )
-+					{
-+					/* Note: because we've taken care in
-+					 * yy_get_next_buffer() to have set up
-+					 * tptext, we can now set up
-+					 * yy_c_buf_p so that if some total
-+					 * hoser (like flex itself) wants to
-+					 * call the scanner after we return the
-+					 * YY_NULL, it'll still work - another
-+					 * YY_NULL will get returned.
-+					 */
-+					(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
-+
-+					yy_act = YY_STATE_EOF(YY_START);
-+					goto do_action;
-+					}
-+
-+				else
-+					{
-+					if ( ! (yy_did_buffer_switch_on_eof) )
-+						YY_NEW_FILE;
-+					}
-+				break;
-+				}
-+
-+			case EOB_ACT_CONTINUE_SCAN:
-+				(yy_c_buf_p) =
-+					(yytext_ptr) + yy_amount_of_matched_text;
-+
-+				yy_current_state = yy_get_previous_state(  );
-+
-+				yy_cp = (yy_c_buf_p);
-+				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
-+				goto yy_match;
-+
-+			case EOB_ACT_LAST_MATCH:
-+				(yy_c_buf_p) =
-+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
-+
-+				yy_current_state = yy_get_previous_state(  );
-+
-+				yy_cp = (yy_c_buf_p);
-+				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
-+				goto yy_find_action;
-+			}
-+		break;
-+		}
-+
-+	default:
-+		YY_FATAL_ERROR(
-+			"fatal flex scanner internal error--no action found" );
-+	} /* end of action switch */
-+		} /* end of scanning one token */
-+	} /* end of user's declarations */
-+} /* end of tplex */
-+
-+/* yy_get_next_buffer - try to read in a new buffer
-+ *
-+ * Returns a code representing an action:
-+ *	EOB_ACT_LAST_MATCH -
-+ *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
-+ *	EOB_ACT_END_OF_FILE - end of file
-+ */
-+static int yy_get_next_buffer (void)
-+{
-+    	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
-+	register char *source = (yytext_ptr);
-+	register int number_to_move, i;
-+	int ret_val;
-+
-+	if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
-+		YY_FATAL_ERROR(
-+		"fatal flex scanner internal error--end of buffer missed" );
-+
-+	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
-+		{ /* Don't try to fill the buffer, so this is an EOF. */
-+		if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
-+			{
-+			/* We matched a single character, the EOB, so
-+			 * treat this as a final EOF.
-+			 */
-+			return EOB_ACT_END_OF_FILE;
-+			}
-+
-+		else
-+			{
-+			/* We matched some text prior to the EOB, first
-+			 * process it.
-+			 */
-+			return EOB_ACT_LAST_MATCH;
-+			}
-+		}
-+
-+	/* Try to read more data. */
-+
-+	/* First move last chars to start of buffer. */
-+	number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
-+
-+	for ( i = 0; i < number_to_move; ++i )
-+		*(dest++) = *(source++);
-+
-+	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
-+		/* don't do the read, it's not guaranteed to return an EOF,
-+		 * just force an EOF
-+		 */
-+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
-+
-+	else
-+		{
-+			yy_size_t num_to_read =
-+			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
-+
-+		while ( num_to_read <= 0 )
-+			{ /* Not enough room in the buffer - grow it. */
-+
-+			/* just a shorter name for the current buffer */
-+			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
-+
-+			int yy_c_buf_p_offset =
-+				(int) ((yy_c_buf_p) - b->yy_ch_buf);
-+
-+			if ( b->yy_is_our_buffer )
-+				{
-+				yy_size_t new_size = b->yy_buf_size * 2;
-+
-+				if ( new_size <= 0 )
-+					b->yy_buf_size += b->yy_buf_size / 8;
-+				else
-+					b->yy_buf_size *= 2;
-+
-+				b->yy_ch_buf = (char *)
-+					/* Include room in for 2 EOB chars. */
-+					tprealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
-+				}
-+			else
-+				/* Can't grow it, we don't own it. */
-+				b->yy_ch_buf = 0;
-+
-+			if ( ! b->yy_ch_buf )
-+				YY_FATAL_ERROR(
-+				"fatal error - scanner input buffer overflow" );
-+
-+			(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
-+
-+			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
-+						number_to_move - 1;
-+
-+			}
-+
-+		if ( num_to_read > YY_READ_BUF_SIZE )
-+			num_to_read = YY_READ_BUF_SIZE;
-+
-+		/* Read in more data. */
-+		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-+			(yy_n_chars), num_to_read );
-+
-+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
-+		}
-+
-+	if ( (yy_n_chars) == 0 )
-+		{
-+		if ( number_to_move == YY_MORE_ADJ )
-+			{
-+			ret_val = EOB_ACT_END_OF_FILE;
-+			tprestart(tpin  );
-+			}
-+
-+		else
-+			{
-+			ret_val = EOB_ACT_LAST_MATCH;
-+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
-+				YY_BUFFER_EOF_PENDING;
-+			}
-+		}
-+
-+	else
-+		ret_val = EOB_ACT_CONTINUE_SCAN;
-+
-+	if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
-+		/* Extend the array by 50%, plus the number we really need. */
-+		yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
-+		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) tprealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
-+		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
-+			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
-+	}
-+
-+	(yy_n_chars) += number_to_move;
-+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
-+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
-+
-+	(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
-+
-+	return ret_val;
-+}
-+
-+/* yy_get_previous_state - get the state just before the EOB char was reached */
-+
-+    static yy_state_type yy_get_previous_state (void)
-+{
-+	register yy_state_type yy_current_state;
-+	register char *yy_cp;
-+    
-+	yy_current_state = (yy_start);
-+
-+	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
-+		{
-+		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
-+		if ( yy_accept[yy_current_state] )
-+			{
-+			(yy_last_accepting_state) = yy_current_state;
-+			(yy_last_accepting_cpos) = yy_cp;
-+			}
-+		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-+			{
-+			yy_current_state = (int) yy_def[yy_current_state];
-+			if ( yy_current_state >= 39 )
-+				yy_c = yy_meta[(unsigned int) yy_c];
-+			}
-+		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-+		}
-+
-+	return yy_current_state;
-+}
-+
-+/* yy_try_NUL_trans - try to make a transition on the NUL character
-+ *
-+ * synopsis
-+ *	next_state = yy_try_NUL_trans( current_state );
-+ */
-+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
-+{
-+	register int yy_is_jam;
-+    	register char *yy_cp = (yy_c_buf_p);
-+
-+	register YY_CHAR yy_c = 1;
-+	if ( yy_accept[yy_current_state] )
-+		{
-+		(yy_last_accepting_state) = yy_current_state;
-+		(yy_last_accepting_cpos) = yy_cp;
-+		}
-+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-+		{
-+		yy_current_state = (int) yy_def[yy_current_state];
-+		if ( yy_current_state >= 39 )
-+			yy_c = yy_meta[(unsigned int) yy_c];
-+		}
-+	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-+	yy_is_jam = (yy_current_state == 38);
-+
-+		return yy_is_jam ? 0 : yy_current_state;
-+}
-+
-+#ifndef YY_NO_INPUT
-+#ifdef __cplusplus
-+    static int yyinput (void)
-+#else
-+    static int input  (void)
-+#endif
-+
-+{
-+	int c;
-+    
-+	*(yy_c_buf_p) = (yy_hold_char);
-+
-+	if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
-+		{
-+		/* yy_c_buf_p now points to the character we want to return.
-+		 * If this occurs *before* the EOB characters, then it's a
-+		 * valid NUL; if not, then we've hit the end of the buffer.
-+		 */
-+		if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
-+			/* This was really a NUL. */
-+			*(yy_c_buf_p) = '\0';
-+
-+		else
-+			{ /* need more input */
-+			yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
-+			++(yy_c_buf_p);
-+
-+			switch ( yy_get_next_buffer(  ) )
-+				{
-+				case EOB_ACT_LAST_MATCH:
-+					/* This happens because yy_g_n_b()
-+					 * sees that we've accumulated a
-+					 * token and flags that we need to
-+					 * try matching the token before
-+					 * proceeding.  But for input(),
-+					 * there's no matching to consider.
-+					 * So convert the EOB_ACT_LAST_MATCH
-+					 * to EOB_ACT_END_OF_FILE.
-+					 */
-+
-+					/* Reset buffer status. */
-+					tprestart(tpin );
-+
-+					/*FALLTHROUGH*/
-+
-+				case EOB_ACT_END_OF_FILE:
-+					{
-+					if ( tpwrap( ) )
-+						return EOF;
-+
-+					if ( ! (yy_did_buffer_switch_on_eof) )
-+						YY_NEW_FILE;
-+#ifdef __cplusplus
-+					return yyinput();
-+#else
-+					return input();
-+#endif
-+					}
-+
-+				case EOB_ACT_CONTINUE_SCAN:
-+					(yy_c_buf_p) = (yytext_ptr) + offset;
-+					break;
-+				}
-+			}
-+		}
-+
-+	c = *(unsigned char *) (yy_c_buf_p);	/* cast for 8-bit char's */
-+	*(yy_c_buf_p) = '\0';	/* preserve tptext */
-+	(yy_hold_char) = *++(yy_c_buf_p);
-+
-+	return c;
-+}
-+#endif	/* ifndef YY_NO_INPUT */
-+
-+/** Immediately switch to a different input stream.
-+ * @param input_file A readable stream.
-+ * 
-+ * @note This function does not reset the start condition to @c INITIAL .
-+ */
-+    void tprestart  (FILE * input_file )
-+{
-+    
-+	if ( ! YY_CURRENT_BUFFER ){
-+        tpensure_buffer_stack ();
-+		YY_CURRENT_BUFFER_LVALUE =
-+            tp_create_buffer(tpin,YY_BUF_SIZE );
-+	}
-+
-+	tp_init_buffer(YY_CURRENT_BUFFER,input_file );
-+	tp_load_buffer_state( );
-+}
-+
-+/** Switch to a different input buffer.
-+ * @param new_buffer The new input buffer.
-+ * 
-+ */
-+    void tp_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
-+{
-+    
-+	/* TODO. We should be able to replace this entire function body
-+	 * with
-+	 *		tppop_buffer_state();
-+	 *		tppush_buffer_state(new_buffer);
-+     */
-+	tpensure_buffer_stack ();
-+	if ( YY_CURRENT_BUFFER == new_buffer )
-+		return;
-+
-+	if ( YY_CURRENT_BUFFER )
-+		{
-+		/* Flush out information for old buffer. */
-+		*(yy_c_buf_p) = (yy_hold_char);
-+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
-+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
-+		}
-+
-+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
-+	tp_load_buffer_state( );
-+
-+	/* We don't actually know whether we did this switch during
-+	 * EOF (tpwrap()) processing, but the only time this flag
-+	 * is looked at is after tpwrap() is called, so it's safe
-+	 * to go ahead and always set it.
-+	 */
-+	(yy_did_buffer_switch_on_eof) = 1;
-+}
-+
-+static void tp_load_buffer_state  (void)
-+{
-+    	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-+	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
-+	tpin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
-+	(yy_hold_char) = *(yy_c_buf_p);
-+}
-+
-+/** Allocate and initialize an input buffer state.
-+ * @param file A readable stream.
-+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
-+ * 
-+ * @return the allocated buffer state.
-+ */
-+    YY_BUFFER_STATE tp_create_buffer  (FILE * file, int  size )
-+{
-+	YY_BUFFER_STATE b;
-+    
-+	b = (YY_BUFFER_STATE) tpalloc(sizeof( struct yy_buffer_state )  );
-+	if ( ! b )
-+		YY_FATAL_ERROR( "out of dynamic memory in tp_create_buffer()" );
-+
-+	b->yy_buf_size = size;
-+
-+	/* yy_ch_buf has to be 2 characters longer than the size given because
-+	 * we need to put in 2 end-of-buffer characters.
-+	 */
-+	b->yy_ch_buf = (char *) tpalloc(b->yy_buf_size + 2  );
-+	if ( ! b->yy_ch_buf )
-+		YY_FATAL_ERROR( "out of dynamic memory in tp_create_buffer()" );
-+
-+	b->yy_is_our_buffer = 1;
-+
-+	tp_init_buffer(b,file );
-+
-+	return b;
-+}
-+
-+/** Destroy the buffer.
-+ * @param b a buffer created with tp_create_buffer()
-+ * 
-+ */
-+    void tp_delete_buffer (YY_BUFFER_STATE  b )
-+{
-+    
-+	if ( ! b )
-+		return;
-+
-+	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
-+		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
-+
-+	if ( b->yy_is_our_buffer )
-+		tpfree((void *) b->yy_ch_buf  );
-+
-+	tpfree((void *) b  );
-+}
-+
-+/* Initializes or reinitializes a buffer.
-+ * This function is sometimes called more than once on the same buffer,
-+ * such as during a tprestart() or at EOF.
-+ */
-+    static void tp_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
-+
-+{
-+	int oerrno = errno;
-+    
-+	tp_flush_buffer(b );
-+
-+	b->yy_input_file = file;
-+	b->yy_fill_buffer = 1;
-+
-+    /* If b is the current buffer, then tp_init_buffer was _probably_
-+     * called from tprestart() or through yy_get_next_buffer.
-+     * In that case, we don't want to reset the lineno or column.
-+     */
-+    if (b != YY_CURRENT_BUFFER){
-+        b->yy_bs_lineno = 1;
-+        b->yy_bs_column = 0;
-+    }
-+
-+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
-+    
-+	errno = oerrno;
-+}
-+
-+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
-+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
-+ * 
-+ */
-+    void tp_flush_buffer (YY_BUFFER_STATE  b )
-+{
-+    	if ( ! b )
-+		return;
-+
-+	b->yy_n_chars = 0;
-+
-+	/* We always need two end-of-buffer characters.  The first causes
-+	 * a transition to the end-of-buffer state.  The second causes
-+	 * a jam in that state.
-+	 */
-+	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
-+	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
-+
-+	b->yy_buf_pos = &b->yy_ch_buf[0];
-+
-+	b->yy_at_bol = 1;
-+	b->yy_buffer_status = YY_BUFFER_NEW;
-+
-+	if ( b == YY_CURRENT_BUFFER )
-+		tp_load_buffer_state( );
-+}
-+
-+/** Pushes the new state onto the stack. The new state becomes
-+ *  the current state. This function will allocate the stack
-+ *  if necessary.
-+ *  @param new_buffer The new state.
-+ *  
-+ */
-+void tppush_buffer_state (YY_BUFFER_STATE new_buffer )
-+{
-+    	if (new_buffer == NULL)
-+		return;
-+
-+	tpensure_buffer_stack();
-+
-+	/* This block is copied from tp_switch_to_buffer. */
-+	if ( YY_CURRENT_BUFFER )
-+		{
-+		/* Flush out information for old buffer. */
-+		*(yy_c_buf_p) = (yy_hold_char);
-+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
-+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
-+		}
-+
-+	/* Only push if top exists. Otherwise, replace top. */
-+	if (YY_CURRENT_BUFFER)
-+		(yy_buffer_stack_top)++;
-+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
-+
-+	/* copied from tp_switch_to_buffer. */
-+	tp_load_buffer_state( );
-+	(yy_did_buffer_switch_on_eof) = 1;
-+}
-+
-+/** Removes and deletes the top of the stack, if present.
-+ *  The next element becomes the new top.
-+ *  
-+ */
-+void tppop_buffer_state (void)
-+{
-+    	if (!YY_CURRENT_BUFFER)
-+		return;
-+
-+	tp_delete_buffer(YY_CURRENT_BUFFER );
-+	YY_CURRENT_BUFFER_LVALUE = NULL;
-+	if ((yy_buffer_stack_top) > 0)
-+		--(yy_buffer_stack_top);
-+
-+	if (YY_CURRENT_BUFFER) {
-+		tp_load_buffer_state( );
-+		(yy_did_buffer_switch_on_eof) = 1;
-+	}
-+}
-+
-+/* Allocates the stack if it does not exist.
-+ *  Guarantees space for at least one push.
-+ */
-+static void tpensure_buffer_stack (void)
-+{
-+	yy_size_t num_to_alloc;
-+    
-+	if (!(yy_buffer_stack)) {
-+
-+		/* First allocation is just for 2 elements, since we don't know if this
-+		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
-+		 * immediate realloc on the next call.
-+         */
-+		num_to_alloc = 1;
-+		(yy_buffer_stack) = (struct yy_buffer_state**)tpalloc
-+								(num_to_alloc * sizeof(struct yy_buffer_state*)
-+								);
-+		if ( ! (yy_buffer_stack) )
-+			YY_FATAL_ERROR( "out of dynamic memory in tpensure_buffer_stack()" );
-+								  
-+		memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
-+				
-+		(yy_buffer_stack_max) = num_to_alloc;
-+		(yy_buffer_stack_top) = 0;
-+		return;
-+	}
-+
-+	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
-+
-+		/* Increase the buffer to prepare for a possible push. */
-+		int grow_size = 8 /* arbitrary grow size */;
-+
-+		num_to_alloc = (yy_buffer_stack_max) + grow_size;
-+		(yy_buffer_stack) = (struct yy_buffer_state**)tprealloc
-+								((yy_buffer_stack),
-+								num_to_alloc * sizeof(struct yy_buffer_state*)
-+								);
-+		if ( ! (yy_buffer_stack) )
-+			YY_FATAL_ERROR( "out of dynamic memory in tpensure_buffer_stack()" );
-+
-+		/* zero only the new slots.*/
-+		memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
-+		(yy_buffer_stack_max) = num_to_alloc;
-+	}
-+}
-+
-+/** Setup the input buffer state to scan directly from a user-specified character buffer.
-+ * @param base the character buffer
-+ * @param size the size in bytes of the character buffer
-+ * 
-+ * @return the newly allocated buffer state object. 
-+ */
-+YY_BUFFER_STATE tp_scan_buffer  (char * base, yy_size_t  size )
-+{
-+	YY_BUFFER_STATE b;
-+    
-+	if ( size < 2 ||
-+	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
-+	     base[size-1] != YY_END_OF_BUFFER_CHAR )
-+		/* They forgot to leave room for the EOB's. */
-+		return 0;
-+
-+	b = (YY_BUFFER_STATE) tpalloc(sizeof( struct yy_buffer_state )  );
-+	if ( ! b )
-+		YY_FATAL_ERROR( "out of dynamic memory in tp_scan_buffer()" );
-+
-+	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
-+	b->yy_buf_pos = b->yy_ch_buf = base;
-+	b->yy_is_our_buffer = 0;
-+	b->yy_input_file = 0;
-+	b->yy_n_chars = b->yy_buf_size;
-+	b->yy_is_interactive = 0;
-+	b->yy_at_bol = 1;
-+	b->yy_fill_buffer = 0;
-+	b->yy_buffer_status = YY_BUFFER_NEW;
-+
-+	tp_switch_to_buffer(b  );
-+
-+	return b;
-+}
-+
-+/** Setup the input buffer state to scan a string. The next call to tplex() will
-+ * scan from a @e copy of @a str.
-+ * @param yystr a NUL-terminated string to scan
-+ * 
-+ * @return the newly allocated buffer state object.
-+ * @note If you want to scan bytes that may contain NUL values, then use
-+ *       tp_scan_bytes() instead.
-+ */
-+YY_BUFFER_STATE tp_scan_string (yyconst char * yystr )
-+{
-+    
-+	return tp_scan_bytes(yystr,strlen(yystr) );
-+}
-+
-+/** Setup the input buffer state to scan the given bytes. The next call to tplex() will
-+ * scan from a @e copy of @a bytes.
-+ * @param yybytes the byte buffer to scan
-+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
-+ * 
-+ * @return the newly allocated buffer state object.
-+ */
-+YY_BUFFER_STATE tp_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len )
-+{
-+	YY_BUFFER_STATE b;
-+	char *buf;
-+	yy_size_t n;
-+	yy_size_t i;
-+    
-+	/* Get memory for full buffer, including space for trailing EOB's. */
-+	n = _yybytes_len + 2;
-+	buf = (char *) tpalloc(n  );
-+	if ( ! buf )
-+		YY_FATAL_ERROR( "out of dynamic memory in tp_scan_bytes()" );
-+
-+	for ( i = 0; i < _yybytes_len; ++i )
-+		buf[i] = yybytes[i];
-+
-+	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
-+
-+	b = tp_scan_buffer(buf,n );
-+	if ( ! b )
-+		YY_FATAL_ERROR( "bad buffer in tp_scan_bytes()" );
-+
-+	/* It's okay to grow etc. this buffer, and we should throw it
-+	 * away when we're done.
-+	 */
-+	b->yy_is_our_buffer = 1;
-+
-+	return b;
-+}
-+
-+#ifndef YY_EXIT_FAILURE
-+#define YY_EXIT_FAILURE 2
-+#endif
-+
-+static void yy_fatal_error (yyconst char* msg )
-+{
-+    	(void) fprintf( stderr, "%s\n", msg );
-+	exit( YY_EXIT_FAILURE );
-+}
-+
-+/* Redefine yyless() so it works in section 3 code. */
-+
-+#undef yyless
-+#define yyless(n) \
-+	do \
-+		{ \
-+		/* Undo effects of setting up tptext. */ \
-+        int yyless_macro_arg = (n); \
-+        YY_LESS_LINENO(yyless_macro_arg);\
-+		tptext[tpleng] = (yy_hold_char); \
-+		(yy_c_buf_p) = tptext + yyless_macro_arg; \
-+		(yy_hold_char) = *(yy_c_buf_p); \
-+		*(yy_c_buf_p) = '\0'; \
-+		tpleng = yyless_macro_arg; \
-+		} \
-+	while ( 0 )
-+
-+/* Accessor  methods (get/set functions) to struct members. */
-+
-+/** Get the current line number.
-+ * 
-+ */
-+int tpget_lineno  (void)
-+{
-+        
-+    return tplineno;
-+}
-+
-+/** Get the input stream.
-+ * 
-+ */
-+FILE *tpget_in  (void)
-+{
-+        return tpin;
-+}
-+
-+/** Get the output stream.
-+ * 
-+ */
-+FILE *tpget_out  (void)
-+{
-+        return tpout;
-+}
-+
-+/** Get the length of the current token.
-+ * 
-+ */
-+yy_size_t tpget_leng  (void)
-+{
-+        return tpleng;
-+}
-+
-+/** Get the current token.
-+ * 
-+ */
-+
-+char *tpget_text  (void)
-+{
-+        return tptext;
-+}
-+
-+/** Set the current line number.
-+ * @param line_number
-+ * 
-+ */
-+void tpset_lineno (int  line_number )
-+{
-+    
-+    tplineno = line_number;
-+}
-+
-+/** Set the input stream. This does not discard the current
-+ * input buffer.
-+ * @param in_str A readable stream.
-+ * 
-+ * @see tp_switch_to_buffer
-+ */
-+void tpset_in (FILE *  in_str )
-+{
-+        tpin = in_str ;
-+}
-+
-+void tpset_out (FILE *  out_str )
-+{
-+        tpout = out_str ;
-+}
-+
-+int tpget_debug  (void)
-+{
-+        return tp_flex_debug;
-+}
-+
-+void tpset_debug (int  bdebug )
-+{
-+        tp_flex_debug = bdebug ;
-+}
-+
-+static int yy_init_globals (void)
-+{
-+        /* Initialization is the same as for the non-reentrant scanner.
-+     * This function is called from tplex_destroy(), so don't allocate here.
-+     */
-+
-+    (yy_buffer_stack) = 0;
-+    (yy_buffer_stack_top) = 0;
-+    (yy_buffer_stack_max) = 0;
-+    (yy_c_buf_p) = (char *) 0;
-+    (yy_init) = 0;
-+    (yy_start) = 0;
-+
-+/* Defined in main.c */
-+#ifdef YY_STDINIT
-+    tpin = stdin;
-+    tpout = stdout;
-+#else
-+    tpin = (FILE *) 0;
-+    tpout = (FILE *) 0;
-+#endif
-+
-+    /* For future reference: Set errno on error, since we are called by
-+     * tplex_init()
-+     */
-+    return 0;
-+}
-+
-+/* tplex_destroy is for both reentrant and non-reentrant scanners. */
-+int tplex_destroy  (void)
-+{
-+    
-+    /* Pop the buffer stack, destroying each element. */
-+	while(YY_CURRENT_BUFFER){
-+		tp_delete_buffer(YY_CURRENT_BUFFER  );
-+		YY_CURRENT_BUFFER_LVALUE = NULL;
-+		tppop_buffer_state();
-+	}
-+
-+	/* Destroy the stack itself. */
-+	tpfree((yy_buffer_stack) );
-+	(yy_buffer_stack) = NULL;
-+
-+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
-+     * tplex() is called, initialization will occur. */
-+    yy_init_globals( );
-+
-+    return 0;
-+}
-+
-+/*
-+ * Internal utility routines.
-+ */
-+
-+#ifndef yytext_ptr
-+static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
-+{
-+	register int i;
-+	for ( i = 0; i < n; ++i )
-+		s1[i] = s2[i];
-+}
-+#endif
-+
-+#ifdef YY_NEED_STRLEN
-+static int yy_flex_strlen (yyconst char * s )
-+{
-+	register int n;
-+	for ( n = 0; s[n]; ++n )
-+		;
-+
-+	return n;
-+}
-+#endif
-+
-+void *tpalloc (yy_size_t  size )
-+{
-+	return (void *) malloc( size );
-+}
-+
-+void *tprealloc  (void * ptr, yy_size_t  size )
-+{
-+	/* The cast to (char *) in the following accommodates both
-+	 * implementations that use char* generic pointers, and those
-+	 * that use void* generic pointers.  It works with the latter
-+	 * because both ANSI C and C++ allow castless assignment from
-+	 * any pointer type to void*, and deal with argument conversions
-+	 * as though doing an assignment.
-+	 */
-+	return (void *) realloc( (char *) ptr, size );
-+}
-+
-+void tpfree (void * ptr )
-+{
-+	free( (char *) ptr );	/* see tprealloc() for (char *) cast */
-+}
-+
-+#define YYTABLES_NAME "yytables"
-+
-+#line 74 "tokenparser.l"
-+
-+
-+
-+
-+static void eval_key(char *pcToken, list_t *list_key)
-+{
-+	struct bundleElt *elt;
-+	int r;
-+	size_t len;
-+
-+	/* create a new list element */
-+	elt = malloc(sizeof(*elt));
-+	assert(elt);
-+
-+	/* <key>foobar</key>
-+	 * 012345 : 5 is the first key character index */
-+
-+	/* calculate the argument length */
-+	for (len=0; pcToken[len+5] != '<'; len++)
-+		;
-+	len++;	/* final NULL byte */
-+
-+	elt->key = malloc(len);
-+	memcpy(elt->key, &pcToken[5], len-1);
-+	elt->key[len-1] = '\0';
-+
-+	r = list_init(&elt->values);
-+	assert(r >= 0);
-+	(void)r;
-+
-+	/* add the key/values */
-+	list_append(list_key, elt);
-+
-+	/* set the list to store the values */
-+	ListValues = &elt->values;
-+}
-+
-+static void eval_value(char *pcToken, list_t *list_values)
-+{
-+	int r;
-+	size_t len;
-+	char *value;
-+	char *amp;
-+
-+	/* <string>foobar</string>
-+	 * 012345678 : 8 is the first string character index */
-+
-+	/* calculate the argument length */
-+	for (len=0; pcToken[len+8] != '<'; len++)
-+		;
-+	len++;	/* final NULL byte */
-+
-+	value = malloc(len);
-+	assert(value);
-+
-+	memcpy(value, &pcToken[8], len-1);
-+	value[len-1] = '\0';
-+
-+	/* for all &amp; in the string */
-+	amp = value;
-+	while ((amp = strstr(amp, "&amp;")) != NULL)
-+	{
-+		char *p;
-+
-+		/* just skip "amp;" substring (4 letters) */
-+		for (p = amp+1; *(p+4); p++)
-+		{
-+			*p = *(p+4);
-+		}
-+		/* terminate the now shorter string */
-+		*p = '\0';
-+
-+		/* skip the & and continue */
-+		amp++;
-+	}
-+
-+	r = list_append(list_values, value);
-+	assert(r >= 0);
-+	(void)r;
-+}
-+
-+void tperrorCheck (char *token_error)
-+{
-+    (void)token_error;
-+}
-+
-+/**
-+ * Find an optional key in a configuration file
-+ * No error is logged if the key is not found
-+ *
-+ * @param l list generated by bundleParse()
-+ * @param key searched key
-+ * @param[out] values list of token value (if key found)
-+ * @retval 0 OK
-+ * @retval 1 key not found
-+ */
-+int LTPBundleFindValueWithKey(list_t *l, const char *key, list_t **values)
-+{
-+	unsigned int i;
-+	int ret = 1;
-+
-+	for (i=0; i < list_size(l); i++)
-+	{
-+		struct bundleElt *elt;
-+
-+		elt = list_get_at(l, i);
-+		assert(elt);
-+
-+		if (0 == strcmp(elt->key, key))
-+		{
-+			*values = &elt->values;
-+			ret = 0;
-+		}
-+	}
-+
-+	return ret;
-+}
-+
-+
-+/**
-+ * Parse a Info.plist file and file a list
-+ *
-+ * @param fileName file name
-+ * @param l list containing the results
-+ * @retval -1 configuration file not found
-+ * @retval 0 OK
-+ */
-+int bundleParse(const char *fileName, list_t *l)
-+{
-+	FILE *file = NULL;
-+	int r;
-+#ifndef NDEBUG
-+	int i;
-+#endif
-+
-+	file = fopen(fileName, "r");
-+	if (!file)
-+	{
-+		Log3(PCSC_LOG_CRITICAL, "Could not open bundle file %s: %s",
-+			fileName, strerror(errno));
-+		return 1;
-+	}
-+
-+	r = list_init(l);
-+	assert(r >= 0);
-+	(void)r;
-+
-+	ListKeys = l;
-+	tpin = file;
-+
-+	do
-+	{
-+		(void)tplex();
-+	} while (!feof(file));
-+	tplex_destroy();
-+
-+	(void)fclose(file);
-+
-+#ifndef NDEBUG
-+	printf("size: %d\n", list_size(l));
-+	for (i=0; i < list_size(l); i++)
-+	{
-+		struct bundleElt *elt;
-+		unsigned int j;
-+
-+		elt = list_get_at(l, i);
-+		assert(elt);
-+		printf("Key: %s\n", elt->key);
-+
-+		for (j=0; j<list_size(&elt->values); j++)
-+		{
-+			char *v = list_get_at(&elt->values, j);
-+			printf(" value: %s\n", v);
-+		}
-+	}
-+#endif
-+
-+	return 0;
-+}
-+
-+/**
-+ * Free the list created by bundleParse()
-+ *
-+ * @param l list containing the results
-+ */
-+void bundleRelease(list_t *l)
-+{
-+	unsigned int i;
-+
-+	for (i=0; i < list_size(l); i++)
-+	{
-+		struct bundleElt *elt;
-+		unsigned int j;
-+
-+		elt = list_get_at(l, i);
-+		assert(elt);
-+
-+		/* free all the values */
-+		for (j=0; j<list_size(&elt->values); j++)
-+			free(list_get_at(&elt->values, j));
-+		list_destroy(&elt->values);
-+
-+		/* free the key */
-+		free(elt->key);
-+		free(elt);
-+	}
-+
-+	list_destroy(l);
-+}
-+
--- 
-2.9.0
-
diff --git a/pkg/pcsc/rev b/pkg/pcsc/rev
deleted file mode 100644
index d00491fd..00000000
--- a/pkg/pcsc/rev
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/pkg/pcsc/src b/pkg/pcsc/src
deleted file mode 160000
-Subproject f74dc1feea4c7a2345abb3e1861b350d46946c8