summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorMichael Forney <mforney@mforney.org>2016-07-06 00:17:13 -0700
committerMichael Forney <mforney@mforney.org>2016-07-06 00:19:12 -0700
commit4ded268f11872e82b413fe2e20b7e79de95a29a3 (patch)
tree3def17e698efebccfab65d4ccaab40529f7ff66d
parent1c7b711ae20de4d55728693863b6efc2d3c1deb1 (diff)
Add ccid 1.4.24
Diffstat
-rw-r--r--.gitmodules4
-rw-r--r--extra/ccid/.rev1
-rw-r--r--extra/ccid/config.h27
-rw-r--r--extra/ccid/gen.rc31
-rw-r--r--extra/ccid/info_plist.awk31
-rw-r--r--extra/ccid/patch/0001-Check-in-source-files-from-ccid-1.4.24-distribution.patch5181
m---------extra/ccid/src0
-rw-r--r--extra/gen.rc1
8 files changed, 5276 insertions, 0 deletions
diff --git a/.gitmodules b/.gitmodules
index 7e61810f..35894379 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -100,6 +100,10 @@
[submodule "devel/qbe/src"]
path = devel/qbe/src
url = git://c9x.me/qbe.git
+[submodule "extra/ccid/src"]
+ path = extra/ccid/src
+ url = https://anonscm.debian.org/git/pcsclite/CCID.git
+ ignore = all
[submodule "extra/efibootmgr/src"]
path = extra/efibootmgr/src
url = https://github.com/rhinstaller/efibootmgr
diff --git a/extra/ccid/.rev b/extra/ccid/.rev
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/extra/ccid/.rev
@@ -0,0 +1 @@
+1
diff --git a/extra/ccid/config.h b/extra/ccid/config.h
new file mode 100644
index 00000000..cc49a808
--- /dev/null
+++ b/extra/ccid/config.h
@@ -0,0 +1,27 @@
+#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/extra/ccid/gen.rc b/extra/ccid/gen.rc
new file mode 100644
index 00000000..1bc2363b
--- /dev/null
+++ b/extra/ccid/gen.rc
@@ -0,0 +1,31 @@
+version=1.4.24
+cflags\
+ -D HAVE_CONFIG_H\
+ -isystem '$builddir'/extra/libusb/include\
+ -isystem '$builddir'/extra/pcsc/include\
+ -I include\
+ -I '$dir' \
+ -I '$srcdir'/src\
+
+deps=phony/extra/^(libusb pcsc)^/headers
+
+lib libccid.a -d $"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/extra/ccid/info_plist.awk b/extra/ccid/info_plist.awk
new file mode 100644
index 00000000..50b3fcf7
--- /dev/null
+++ b/extra/ccid/info_plist.awk
@@ -0,0 +1,31 @@
+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/extra/ccid/patch/0001-Check-in-source-files-from-ccid-1.4.24-distribution.patch b/extra/ccid/patch/0001-Check-in-source-files-from-ccid-1.4.24-distribution.patch
new file mode 100644
index 00000000..75f32470
--- /dev/null
+++ b/extra/ccid/patch/0001-Check-in-source-files-from-ccid-1.4.24-distribution.patch
@@ -0,0 +1,5181 @@
+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/extra/ccid/src b/extra/ccid/src
new file mode 160000
+Subproject a1197c49cee479f4187dfd05c900224b99127e1
diff --git a/extra/gen.rc b/extra/gen.rc
index fa009db2..3a9e873a 100644
--- a/extra/gen.rc
+++ b/extra/gen.rc
@@ -1,3 +1,4 @@
+subgen ccid
subgen efibootmgr
subgen efivar
subgen hostap
generated by cgit v1.2.3 (git 2.25.1) at 2026-02-14 19:45:06 +0000