0.3.1 release (EXI codec)

git-svn-id: https://svn.code.sf.net/p/openv2g/code/trunk@28 d9f2db14-54d0-4bde-b00c-16405c910529

src/codec/BitDecoderChannel.c

@@ -0,0 +1,288 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ * Bit decoding functionalities
+ *
+ ********************************************************************/
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+
+#include "BitDecoderChannel.h"
+#include "BitInputStream.h"
+#include "EXITypes.h"
+
+#ifndef BIT_DECODER_CHANNEL_C
+#define BIT_DECODER_CHANNEL_C
+
+/* only the least significant 8 bits are filled properly */
+int _decode(bitstream_t* stream, uint32_t* b) {
+	return readBits(stream, 8, b);
+}
+
+int decodeBoolean(bitstream_t* stream, int* b) {
+	uint32_t ub;
+	int errn = readBits(stream, 1, &ub);
+	*b = (ub == 0) ? 0 : 1;
+	return errn;
+}
+
+int decodeNBitUnsignedInteger(bitstream_t* stream, uint16_t nbits, uint32_t* uint32) {
+	if (nbits == 0) {
+		*uint32 = 0;
+		return 0;
+	} else {
+		return readBits(stream, nbits, uint32);
+	}
+}
+
+int decodeUnsignedInteger16(bitstream_t* stream, uint16_t* uint16) {
+	unsigned int mShift = 0;
+	int errn = 0;
+	uint32_t b;
+	*uint16 = 0;
+
+	do {
+		/* 1. Read the next octet */
+		errn = _decode(stream, &b);
+		/* 2. Multiply the value of the unsigned number represented by the 7
+		 * least significant
+		 * bits of the octet by the current multiplier and add the result to
+		 * the current value */
+		*uint16 += (b & 127) << mShift;
+		/* 3. Multiply the multiplier by 128 */
+		mShift += 7;
+		/* 4. If the most significant bit of the octet was 1, go back to step 1 */
+	} while (errn >= 0 && (b >> 7) == 1);
+
+	return errn;
+}
+
+int decodeUnsignedInteger32(bitstream_t* stream, uint32_t* uint32) {
+	/* 0XXXXXXX ... 1XXXXXXX 1XXXXXXX */
+	unsigned int mShift = 0;
+	int errn = 0;
+	uint32_t b;
+	*uint32 = 0;
+
+	do {
+		/* 1. Read the next octet */
+		errn = _decode(stream, &b);
+		/* 2. Multiply the value of the unsigned number represented by the 7
+		 * least significant
+		 * bits of the octet by the current multiplier and add the result to
+		 * the current value */
+		*uint32 += (b & 127) << mShift;
+		/* 3. Multiply the multiplier by 128 */
+		mShift += 7;
+		/* 4. If the most significant bit of the octet was 1, go back to step 1 */
+	} while (errn >= 0 && (b >> 7) == 1);
+
+	return errn;
+}
+
+/**
+ * Decode an arbitrary precision non negative integer using a sequence of
+ * octets. The most significant bit of the last octet is set to zero to
+ * indicate sequence termination. Only seven bits per octet are used to
+ * store the integer's value.
+ */
+int decodeUnsignedInteger64(bitstream_t* stream, uint64_t* uint64) {
+	unsigned int mShift = 0;
+	int errn = 0;
+	uint32_t b;
+	*uint64 = 0L;
+
+	do {
+		errn = _decode(stream, &b);
+		*uint64 += ((uint64_t) (b & 127)) << mShift;
+		mShift += 7;
+	} while (errn >= 0 && (b >> 7) == 1);
+
+	return errn;
+}
+
+/**
+ * Decode an arbitrary precision integer using a sign bit followed by a
+ * sequence of octets. The most significant bit of the last octet is set to
+ * zero to indicate sequence termination. Only seven bits per octet are used
+ * to store the integer's value.
+ */
+int decodeInteger32(bitstream_t* stream, int32_t* int32) {
+	int b;
+	uint32_t uint32;
+	int errn = decodeBoolean(stream, &b);
+
+	if (errn < 0) {
+		return errn;
+	}
+
+	if (b) {
+		/* For negative values, the Unsigned Integer holds the
+		 * magnitude of the value minus 1 */
+		errn = decodeUnsignedInteger32(stream, &uint32);
+		*int32 = -(uint32 + 1);
+	} else {
+		/* positive */
+		errn = decodeUnsignedInteger32(stream, &uint32);
+		*int32 = (int32_t)(uint32);
+	}
+
+	return errn;
+}
+
+/**
+ * Decode an arbitrary precision integer using a sign bit followed by a
+ * sequence of octets. The most significant bit of the last octet is set to
+ * zero to indicate sequence termination. Only seven bits per octet are used
+ * to store the integer's value.
+ */
+int decodeInteger64(bitstream_t* stream, int64_t* int64) {
+	int b;
+	uint64_t uint64;
+	int errn = decodeBoolean(stream, &b);
+
+	if (errn < 0) {
+		return errn;
+	}
+
+	if (b) {
+		/* For negative values, the Unsigned Integer holds the
+		 * magnitude of the value minus 1 */
+		errn = decodeUnsignedInteger64(stream, &uint64);
+		*int64 = -(uint64 + 1);
+	} else {
+		/* positive */
+		errn = decodeUnsignedInteger64(stream, &uint64);
+		*int64 = (int64_t)(uint64);
+	}
+
+	return errn;
+}
+
+/**
+ * Decode a Float datatype as two consecutive Integers.
+ * The first Integer represents the mantissa of the floating point
+ * number and the second Integer represents the base-10 exponent
+ * of the floating point number.
+ */
+int decodeFloat(bitstream_t* stream, float_me_t* f) {
+	int errn = decodeInteger64(stream, &f->mantissa);
+	if (errn < 0) {
+		return errn;
+	}
+	return decodeInteger32(stream, &f->exponent);
+}
+
+/**
+ * Decode a sequence of characters for a given length.
+ */
+int decodeStringOnly(bitstream_t* stream, uint16_t len, string_ucs_t* s) {
+	decodeCharacters(stream, len, s->codepoints);
+	s->len = len;
+	return 0;
+}
+
+/**
+ * Decode a length prefixed sequence of characters.
+ */
+int decodeString(bitstream_t* stream, string_ucs_t* s) {
+	int errn = decodeUnsignedInteger16(stream, &s->len);
+	if (errn < 0) {
+		return errn;
+	}
+	return decodeStringOnly(stream, s->len, s);
+}
+
+int decodeStringValue(bitstream_t* stream, string_ucs_t* s) {
+	int errn = decodeUnsignedInteger16(stream, &s->len);
+	if (errn < 0) {
+		return errn;
+	}
+
+	switch (s->len) {
+	case 0:
+		/* local value partition */
+		printf("[ERROR] String local value partition hit not supported \n");
+		return -2;
+	case 1:
+		/* found in global value partition */
+		printf("[ERROR] String global value partition hit not supported \n");
+		return -3;
+	default:
+		/* not found in global value (and local value) partition
+		 * ==> string literal is encoded as a String with the length
+		 * incremented by two */
+		return decodeStringOnly(stream, ((s->len) - 2), s);
+		/* After encoding the string value, it is added to both the
+		 * associated "local" value string table partition and the global
+		 * value string table partition */
+		/* addValue(context, value); */
+	}
+}
+
+/**
+ * Decode a sequence of characters according to a given length.
+ * Each character is represented by its UCS [ISO/IEC 10646]
+ * code point encoded as an Unsigned Integer
+ */
+int decodeCharacters(bitstream_t* stream, uint16_t len, uint32_t* chars) {
+	unsigned int i;
+	int errn = 0;
+	for (i = 0; i < len && errn >= 0; i++) {
+		errn = decodeUnsignedInteger32(stream, &chars[i]);
+		if (errn < 0) {
+			return errn;
+		}
+	}
+
+	return errn;
+}
+
+/**
+ * Decode a binary value as a length-prefixed sequence of octets.
+ */
+int decodeBinary(bitstream_t* stream, bytes_t* bytes) {
+	unsigned int i;
+	uint32_t b;
+	int errn = decodeUnsignedInteger16(stream, &bytes->len);
+	if (errn < 0) {
+		return errn;
+	}
+
+	for (i = 0; i < bytes->len && errn >= 0; i++) {
+		errn = _decode(stream, &b);
+		if (errn < 0) {
+			return errn;
+		}
+		bytes->data[i] = (uint8_t)b;
+	}
+
+	return errn;
+}
+
+#endif
+

src/codec/BitDecoderChannel.h

@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "EXITypes.h"
+
+#ifndef BIT_DECODER_CHANNEL_H
+#define BIT_DECODER_CHANNEL_H
+
+/**
+ * Decode a single boolean value. The value false is represented by the bit
+ * 0, and the value true is represented by the bit 1.
+ */
+int decodeBoolean(bitstream_t* stream, int* b);
+
+/**
+ * Decodes and returns an n-bit unsigned integer.
+ */
+int decodeNBitUnsignedInteger(bitstream_t* stream, uint16_t nbits, uint32_t* uint32);
+
+/**
+ * Decode an arbitrary precision non negative integer using a sequence of
+ * octets. The most significant bit of the last octet is set to zero to
+ * indicate sequence termination. Only seven bits per octet are used to
+ * store the integer's value.
+ */
+int decodeUnsignedInteger16(bitstream_t* stream, uint16_t* uint16);
+
+/**
+ * Decode an arbitrary precision non negative integer using a sequence of
+ * octets. The most significant bit of the last octet is set to zero to
+ * indicate sequence termination. Only seven bits per octet are used to
+ * store the integer's value.
+ */
+int decodeUnsignedInteger32(bitstream_t* stream, uint32_t* uint32);
+
+/**
+ * Decode an arbitrary precision non negative integer using a sequence of
+ * octets. The most significant bit of the last octet is set to zero to
+ * indicate sequence termination. Only seven bits per octet are used to
+ * store the integer's value.
+ */
+int decodeUnsignedInteger64(bitstream_t* stream, uint64_t* uint64);
+
+/**
+ * Decode an arbitrary precision integer using a sign bit followed by a
+ * sequence of octets. The most significant bit of the last octet is set to
+ * zero to indicate sequence termination. Only seven bits per octet are used
+ * to store the integer's value.
+ */
+int decodeInteger32(bitstream_t* stream, int32_t* int32);
+
+/**
+ * Decode an arbitrary precision integer using a sign bit followed by a
+ * sequence of octets. The most significant bit of the last octet is set to
+ * zero to indicate sequence termination. Only seven bits per octet are used
+ * to store the integer's value.
+ */
+int decodeInteger64(bitstream_t* stream, int64_t* int64);
+
+/**
+ * Decode a Float datatype as two consecutive Integers.
+ * The first Integer represents the mantissa of the floating point
+ * number and the second Integer represents the base-10 exponent
+ * of the floating point number.
+ */
+int decodeFloat(bitstream_t* stream, float_me_t* f);
+
+
+/**
+ * Decode a sequence of characters for a given length.
+ */
+int decodeStringOnly(bitstream_t* stream, uint16_t len, string_ucs_t* s);
+
+/**
+ * Decode a length prefixed sequence of characters.
+ */
+int decodeString(bitstream_t* stream, string_ucs_t* s);
+
+/**
+ * Decode a length prefixed sequence of characters in the sense of string tables.
+ * length == 0, local value partition hit
+ * length == 1, global value partition hit
+ * --> string literal is encoded as a String with the length incremented by two
+ */
+int decodeStringValue(bitstream_t* stream, string_ucs_t* s);
+
+
+/**
+ * Decode a sequence of characters according to a given length.
+ */
+int decodeCharacters(bitstream_t* stream, uint16_t len, uint32_t* chars);
+
+/**
+ * Decode a binary value as a length-prefixed sequence of octets.
+ */
+int decodeBinary(bitstream_t* stream, bytes_t* bytes);
+
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+

src/codec/BitEncoderChannel.c

@@ -0,0 +1,298 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+#include "BitEncoderChannel.h"
+#include "BitOutputStream.h"
+#include "EXITypes.h"
+
+#ifndef BIT_ENCODER_CHANNEL_C
+#define BIT_ENCODER_CHANNEL_C
+
+/**
+ * Returns the least number of 7 bit-blocks that is needed to represent the
+ * int <param>n</param>. Returns 1 if <param>n</param> is 0.
+ *
+ * @param n
+ *            integer value
+ *
+ */
+uint8_t numberOf7BitBlocksToRepresent(int n) {
+	/* assert (n >= 0); */
+
+	/* 7 bits */
+	if (n < 128) {
+		return 1;
+	}
+	/* 14 bits */
+	else if (n < 16384) {
+		return 2;
+	}
+	/* 21 bits */
+	else if (n < 2097152) {
+		return 3;
+	}
+	/* 28 bits */
+	else if (n < 268435456) {
+		return 4;
+	}
+	/* 35 bits */
+	else {
+		/* int, 32 bits */
+		return 5;
+	}
+}
+
+
+int encode(bitstream_t* stream, uint8_t b) {
+	return writeBits(stream, 8, b);
+}
+
+/**
+ * Encode a single boolean value. A false value is encoded as bit 0 and true
+ * value is encode as bit 1.
+ */
+int encodeBoolean(bitstream_t* stream, int b) {
+	uint8_t val = b ? 1 : 0;
+	return writeBits(stream, 1, val);
+}
+
+
+/**
+ * Encode n-bit unsigned integer. The n least significant bits of parameter
+ * b starting with the most significant, i.e. from left to right.
+ */
+int encodeNBitUnsignedInteger(bitstream_t* stream, uint16_t nbits, uint32_t val)  {
+	return writeBits(stream, nbits, val);
+}
+
+
+
+
+/**
+ * Encode an arbitrary precision non negative integer using a sequence of
+ * octets. The most significant bit of the last octet is set to zero to
+ * indicate sequence termination. Only seven bits per octet are used to
+ * store the integer's value.
+ */
+int encodeUnsignedInteger32(bitstream_t* stream, uint32_t n) {
+	int errn = 0;
+	if (n < 128) {
+		/* write byte as is */
+		errn = encode(stream, (uint8_t)n);
+	} else {
+		uint8_t n7BitBlocks = numberOf7BitBlocksToRepresent(n);
+
+		switch (n7BitBlocks) {
+		case 5:
+			errn = encode(stream, (uint8_t)(128 | n));
+			n = n >> 7;
+			if (errn < 0) {
+				break;
+			}
+		case 4:
+			errn = encode(stream, (uint8_t)(128 | n));
+			n = n >> 7;
+			if (errn < 0) {
+				break;
+			}
+		case 3:
+			errn = encode(stream, (uint8_t)(128 | n));
+			n = n >> 7;
+			if (errn < 0) {
+				break;
+			}
+		case 2:
+			errn = encode(stream, (uint8_t)(128 | n));
+			n = n >> 7;
+			if (errn < 0) {
+				break;
+			}
+		case 1:
+			/* 0 .. 7 (last byte) */
+			errn = encode(stream, (uint8_t)(0 | n));
+		}
+	}
+
+	return errn;
+}
+
+/**
+ * Encode an arbitrary precision non negative integer using a sequence of
+ * octets. The most significant bit of the last octet is set to zero to
+ * indicate sequence termination. Only seven bits per octet are used to
+ * store the integer's value.
+ */
+int encodeUnsignedInteger64(bitstream_t* stream, uint64_t n) {
+	int errn = 0;
+	uint8_t lastEncode = (uint8_t) n;
+	n >>= 7;
+
+	while (n != 0) {
+		errn = encode(stream, lastEncode | 128);
+		if (errn < 0) {
+			return errn;
+		}
+		lastEncode = (uint8_t) n;
+		n >>= 7;
+	}
+
+	return encode(stream, lastEncode);
+}
+
+
+/**
+ * Encode an arbitrary precision integer using a sign bit followed by a
+ * sequence of octets. The most significant bit of the last octet is set to
+ * zero to indicate sequence termination. Only seven bits per octet are used
+ * to store the integer's value.
+ */
+int encodeInteger32(bitstream_t* stream, int32_t n) {
+	int errn;
+	/* signalize sign */
+	if (n < 0) {
+		errn = encodeBoolean(stream, 1);
+		/* For negative values, the Unsigned Integer holds the
+		 * magnitude of the value minus 1 */
+		n = (-n) - 1;
+	} else {
+		errn = encodeBoolean(stream, 0);
+	}
+	if (errn < 0) {
+		return errn;
+	}
+	return encodeUnsignedInteger32(stream, n);
+}
+
+/**
+ * Encode an arbitrary precision integer using a sign bit followed by a
+ * sequence of octets. The most significant bit of the last octet is set to
+ * zero to indicate sequence termination. Only seven bits per octet are used
+ * to store the integer's value.
+ */
+int encodeInteger64(bitstream_t* stream, int64_t n) {
+	int errn;
+	/* signalize sign */
+	if (n < 0) {
+		errn = encodeBoolean(stream, 1);
+		/* For negative values, the Unsigned Integer holds the
+		 * magnitude of the value minus 1 */
+		n = (-n) - 1;
+	} else {
+		errn = encodeBoolean(stream, 0);
+	}
+	if (errn < 0) {
+		return errn;
+	}
+	return encodeUnsignedInteger64(stream, n);
+}
+
+
+/**
+ * The Float datatype representation is two consecutive Integers.
+ * The first Integer represents the mantissa of the floating point
+ * number and the second Integer represents the base-10 exponent
+ * of the floating point number.
+ */
+int encodeFloat(bitstream_t* stream, float_me_t* f) {
+	int errn = encodeInteger64(stream, f->mantissa);
+	if (errn >= 0) {
+		errn = encodeInteger32(stream, f->exponent);
+	}
+	return errn;
+}
+
+
+/**
+ * Encode a length prefixed sequence of characters.
+ */
+int encodeString(bitstream_t* stream, string_ucs_t* string) {
+	int errn = encodeUnsignedInteger32(stream, string->len);
+	if (errn >= 0) {
+		errn = encodeCharacters(stream, string->codepoints, string->len);
+	}
+	return errn;
+}
+
+int encodeStringValue(bitstream_t* stream, string_ucs_t* string) {
+	/* encode string as string table miss */
+	int errn = encodeUnsignedInteger32(stream, string->len+2);
+	if (errn >= 0) {
+		errn = encodeCharacters(stream, string->codepoints, string->len);
+	}
+	return errn;
+}
+
+/**
+ * Encode a sequence of characters according to a given length.
+ * Each character is represented by its UCS [ISO/IEC 10646]
+ * code point encoded as an Unsigned Integer
+ */
+int encodeCharacters(bitstream_t* stream, uint32_t* chars, uint16_t len) {
+	unsigned int i;
+	int errn = 0;
+	for(i=0; i<len && errn>=0; i++) {
+		errn = encodeUnsignedInteger32(stream, chars[i]);
+	}
+	return errn;
+}
+
+
+/**
+ * Encode a binary value as a length-prefixed sequence of octets.
+ */
+int encodeBinary(bitstream_t* stream, bytes_t* bytes)  {
+	unsigned int i;
+	int errn = encodeUnsignedInteger32(stream, bytes->len);
+
+	for(i=0; i<bytes->len && errn>=0; i++) {
+		errn = encode(stream, bytes->data[i]);
+	}
+	return errn;
+}
+
+/**
+ * Flush underlying bit output stream.
+ */
+int encodeFinish(bitstream_t* stream) {
+	return flush(stream);
+}
+
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
+

src/codec/BitEncoderChannel.h

@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#include "EXITypes.h"
+
+#ifndef BIT_ENCODER_CHANNEL_H
+#define BIT_ENCODER_CHANNEL_H
+
+/**
+ * Encode a single boolean value. A false value is encoded as bit 0 and true
+ * value is encode as bit 1.
+ */
+int encodeBoolean(bitstream_t* stream, int b);
+
+
+/**
+ * Encode n-bit unsigned integer. The n least significant bits of parameter
+ * b starting with the most significant, i.e. from left to right.
+ */
+int encodeNBitUnsignedInteger(bitstream_t* stream, uint16_t nbits, uint32_t val);
+
+
+/**
+ * Encode an arbitrary precision non negative integer using a sequence of
+ * octets. The most significant bit of the last octet is set to zero to
+ * indicate sequence termination. Only seven bits per octet are used to
+ * store the integer's value.
+ */
+int encodeUnsignedInteger32(bitstream_t* stream, uint32_t n);
+
+/**
+ * Encode an arbitrary precision non negative integer using a sequence of
+ * octets. The most significant bit of the last octet is set to zero to
+ * indicate sequence termination. Only seven bits per octet are used to
+ * store the integer's value.
+ */
+int encodeUnsignedInteger64(bitstream_t* stream, uint64_t n);
+
+/**
+ * Encode an arbitrary precision integer using a sign bit followed by a
+ * sequence of octets. The most significant bit of the last octet is set to
+ * zero to indicate sequence termination. Only seven bits per octet are used
+ * to store the integer's value.
+ */
+int encodeInteger32(bitstream_t* stream, int32_t n);
+
+/**
+ * Encode an arbitrary precision integer using a sign bit followed by a
+ * sequence of octets. The most significant bit of the last octet is set to
+ * zero to indicate sequence termination. Only seven bits per octet are used
+ * to store the integer's value.
+ */
+int encodeInteger64(bitstream_t* stream, int64_t n);
+
+/**
+ * Encode a Float datatype as two consecutive Integers.
+ * The first Integer represents the mantissa of the floating point
+ * number and the second Integer represents the base-10 exponent
+ * of the floating point number.
+ */
+int encodeFloat(bitstream_t* stream, float_me_t* f);
+
+
+/**
+ * Encode a length prefixed sequence of characters.
+ */
+int encodeString(bitstream_t* stream, string_ucs_t* string);
+
+/**
+ * Encode a length prefixed sequence of characters in the sense of string tables
+ */
+int encodeStringValue(bitstream_t* stream, string_ucs_t* string);
+
+/**
+ * Encode a sequence of characters according to a given length.
+ * Each character is represented by its UCS [ISO/IEC 10646]
+ * code point encoded as an Unsigned Integer
+ */
+int encodeCharacters(bitstream_t* stream, uint32_t* chars, uint16_t len);
+
+/**
+ * Encode a binary value as a length-prefixed sequence of octets.
+ */
+int encodeBinary(bitstream_t* stream, bytes_t* bytes);
+
+/**
+ * Flush underlying bit output stream
+ */
+int encodeFinish(bitstream_t* stream);
+
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+
+
+
+
+

src/codec/BitInputStream.c

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+#include "EXITypes.h"
+#include "BitInputStream.h"
+
+#ifndef BIT_INPUT_STREAM_C
+#define BIT_INPUT_STREAM_C
+
+/* internal method to (re)fill buffer */
+int readBuffer(bitstream_t* stream)
+{
+	int errn = 0;
+	if(stream->capacity==0)
+	{
+		if ( (*stream->pos) < stream->size ) {
+			stream->buffer = stream->data[(*stream->pos)++];
+			stream->capacity = BITS_IN_BYTE;
+		} else {
+			errn = -1;
+		}
+	}
+	return errn;
+}
+
+int readBits(bitstream_t* stream, uint16_t num_bits, uint32_t* b)
+{
+	int errn = readBuffer(stream);
+	if (errn < 0) {
+		return errn;
+	}
+
+	/* read the bits in one step */
+	if(num_bits <= stream->capacity)
+	{
+		stream->capacity -= num_bits;
+		*b = (stream->buffer >> stream->capacity) & (0xff >> (BITS_IN_BYTE - num_bits));
+	}
+	else
+	{
+		/* read bits as much as possible */
+		*b = stream->buffer & (0xff >> (BITS_IN_BYTE - stream->capacity));
+		num_bits -= stream->capacity;
+		stream->capacity = 0;
+
+		/* read whole bytes */
+		while(num_bits >= 8)
+		{
+			errn = readBuffer(stream);
+			if (errn < 0) {
+				return errn;
+			}
+			*b = ((*b) << BITS_IN_BYTE) | stream->buffer;
+			num_bits -= BITS_IN_BYTE;
+			stream->capacity = 0;
+		}
+
+		/* read the spare bits in the buffer */
+		if(num_bits>0)
+		{
+			errn = readBuffer(stream);
+			if (errn < 0) {
+				return errn;
+			}
+			*b = ((*b) << num_bits) | (stream->buffer >> (BITS_IN_BYTE - num_bits));
+			stream->capacity = BITS_IN_BYTE - num_bits;
+		}
+		
+	}
+
+	return errn;
+}
+
+#endif

src/codec/BitInputStream.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "EXITypes.h"
+
+#ifndef BIT_INPUT_STREAM_H
+#define BIT_INPUT_STREAM_H
+
+int readBits(bitstream_t* stream, uint16_t num_bits, uint32_t* b);
+
+int flush();
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif

src/codec/BitOutputStream.c

@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#include <string.h>
+
+#include "EXITypes.h"
+#include "BitOutputStream.h"
+
+#ifndef BIT_OUTPUT_STREAM_C
+#define BIT_OUTPUT_STREAM_C
+
+/*	NOTE: nbits <= 8 */
+int writeBits(bitstream_t* stream, uint16_t nbits, uint32_t val) {
+	/*  is there enough space in the buffer */
+	if (nbits <= stream->capacity) {
+		/* all bits fit into the current buffer */
+		stream->buffer = (stream->buffer << (nbits)) | (val & (0xff
+				>> (BITS_IN_BYTE - nbits)));
+		stream->capacity -= nbits;
+		/* if the buffer is full write it into the data */
+		if (stream->capacity == 0) {
+			if ((*stream->pos) >= stream->size) {
+				return -1;
+			}
+			stream->data[(*stream->pos)++] = 0xFF & stream->buffer;
+			stream->capacity = BITS_IN_BYTE;
+			stream->buffer = 0;
+		}
+	} else {
+		/* the buffer is not enough
+		 * fill the buffer */
+		stream->buffer = (stream->buffer << stream->capacity) | ((val >> (nbits
+				- stream->capacity)) & (0xff >> (BITS_IN_BYTE
+				- stream->capacity)));
+
+		nbits -= stream->capacity;
+		if ((*stream->pos) >= stream->size) {
+			return -1;
+		}
+		stream->data[(*stream->pos)++] = 0xFF & stream->buffer;
+		stream->buffer = 0;
+
+		/* write whole bytes */
+		while (nbits >= BITS_IN_BYTE) {
+			nbits -= BITS_IN_BYTE;
+			if ((*stream->pos) >= stream->size) {
+				return -1;
+			}
+			stream->data[(*stream->pos)++] = 0xFF & (val >> (nbits));
+		}
+
+		/* spared bits are kept in the buffer */
+		stream->buffer = val; /* Note: the high bits will be shifted out during further filling */
+		stream->capacity = BITS_IN_BYTE - (nbits);
+	}
+
+	return 0;
+}
+
+/**
+ * Flush output
+ */
+int flush(bitstream_t* stream) {
+	if (stream->capacity == BITS_IN_BYTE) {
+		/* nothing to do, no bits in buffer */
+		return 0;
+	} else {
+		return writeBits(stream, stream->capacity, 0);
+	}
+}
+
+#endif
+

src/codec/BitOutputStream.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#include "EXITypes.h"
+
+#ifndef BIT_OUTPUT_STREAM_H
+#define BIT_OUTPUT_STREAM_H
+
+int writeBits(bitstream_t* stream, uint16_t nbits, uint32_t bits);
+
+/* flush output */
+int flush(bitstream_t* stream);
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+

src/codec/ByteStream.c

@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#define _CRT_SECURE_NO_DEPRECATE 1
+
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "EXITypes.h"
+
+#ifndef BYTE_STREAM_C
+#define BYTE_STREAM_C
+
+int readBytesFromFile(const char * filename, uint8_t* data, uint16_t size, uint16_t pos) {
+	FILE* f;
+	int character;
+
+	f = fopen(filename, "rb");
+
+	if (f == NULL) {
+		printf("\n[Error] no valid file handle !\n");
+		return -1;
+	} else {
+		/* read bytes */
+		while ((character = getc(f)) != EOF) {
+			if (pos >= size) {
+				return -1;
+			}
+			data[pos++] = (uint8_t) character;
+			/* printf("%u \n", character); */
+		}
+		fclose(f);
+	}
+
+	return pos;
+}
+
+int writeBytesToFile(uint8_t* data, uint16_t len, const char * filename) {
+	uint16_t rlen;
+	FILE* f = fopen(filename, "wb+");
+
+	if (f == NULL) {
+		return -1;
+	} else {
+		rlen = fwrite(data, sizeof(uint8_t), len, f);
+		fflush(f);
+		fclose(f);
+		if(rlen == len) {
+			return 0;
+		} else {
+			return -1;
+		}
+	}
+}
+
+
+#endif
+

src/codec/ByteStream.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+
+#include "EXITypes.h"
+
+#ifndef BYTE_STREAM_H
+#define BYTE_STREAM_H
+
+int writeBytesToFile(uint8_t* data, uint16_t len, const char * filename);
+
+int readBytesFromFile(const char * filename, uint8_t* data, uint16_t size, uint16_t pos);
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif

src/codec/EXICoder.c

@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#ifndef EXI_CODER_C
+#define EXI_CODER_C
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "EXITypes.h"
+#include "BitInputStream.h"
+#include "BitDecoderChannel.h"
+
+#include "assert.h"
+#include "EXICoder.h"
+
+/*
+ uint16_t exiGetCurrentState(struct exiState* state) {
+ return state->grammarStates[state->currentStack];
+ // return 0;
+ }
+ */
+
+int exiPushStack(exi_state_t* state, uint16_t newState, eqname_t* eqn) {
+	if ((state->stackIndex + 1) < EXI_ELEMENT_STACK_SIZE) {
+		state->grammarStack[++state->stackIndex] = newState;
+		/* copy qname */
+		state->elementStack[state->stackIndex].localPart = eqn->localPart;
+		state->elementStack[state->stackIndex].namespaceURI = eqn->namespaceURI;
+		return 0;
+	} else {
+		return EXI_ERROR_OUT_OF_BOUNDS;
+	}
+}
+
+int exiPopStack(exi_state_t* state) {
+	if (state->stackIndex >= 1) {
+		state->stackIndex--;
+		return 0;
+	} else {
+		return EXI_ERROR_OUT_OF_BOUNDS;
+	}
+}
+
+#endif
+

src/codec/EXICoder.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXI_CODER_H
+#define EXI_CODER_H
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "EXITypes.h"
+
+
+/* uint16_t exiGetCurrentState(struct exiState* state); */
+
+int exiPushStack(exi_state_t* state, uint16_t newState, eqname_t* eqn);
+
+int exiPopStack(exi_state_t* state);
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+

src/codec/EXIDecoder.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXI_DECODER_H
+#define EXI_DECODER_H
+
+#include "EXITypes.h"
+
+int exiInitDecoder(bitstream_t* stream, exi_state_t* state);
+
+int exiDecodeNextEvent(bitstream_t* stream, exi_state_t* state,
+		exi_event_t* nextEvent);
+
+int exiDecodeStartDocument(bitstream_t* stream, exi_state_t* state);
+
+int exiDecodeEndDocument(bitstream_t* stream, exi_state_t* state);
+
+int exiDecodeStartElement(bitstream_t* stream, exi_state_t* state,
+		eqname_t* se);
+
+int exiDecodeStartElementGeneric(bitstream_t* stream, exi_state_t* state,
+		eqname_t* se);
+
+int exiDecodeEndElement(bitstream_t* stream, exi_state_t* state,
+		eqname_t* ee);
+
+int exiDecodeCharacters(bitstream_t* stream, exi_state_t* state,
+		exi_value_t* val);
+
+int exiDecodeAttribute(bitstream_t* stream, exi_state_t* state,
+		eqname_t* at, exi_value_t* val);
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+

src/codec/EXIEncoder.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXI_ENCODER_H
+#define EXI_ENCODER_H
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "EXITypes.h"
+
+int exiInitEncoder(bitstream_t* stream, exi_state_t* state);
+
+int exiEncodeStartDocument(bitstream_t* stream, exi_state_t* state);
+
+int exiEncodeEndDocument(bitstream_t* stream, exi_state_t* state);
+
+int exiEncodeStartElement(bitstream_t* stream, exi_state_t* state,
+				eqname_t* se);
+
+int exiEncodeEndElement(bitstream_t* stream, exi_state_t* state, eqname_t* ee);
+
+int exiEncodeCharacters(bitstream_t* stream, exi_state_t* state,
+		exi_value_t* val);
+
+int exiEncodeAttribute(bitstream_t* stream, exi_state_t* state, eqname_t* at,
+		exi_value_t* val);
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+

src/codec/EXIHeaderDecoder.c

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "EXIHeaderDecoder.h"
+#include "BitInputStream.h"
+#include "BitDecoderChannel.h"
+
+#ifndef EXI_HEADER_DECODER_C
+#define EXI_HEADER_DECODER_C
+
+int readEXIHeader(bitstream_t* stream) {
+	uint32_t header = 0;
+	int errn = readBits(stream, 8, &header);
+	if (errn < 0) {
+		return errn;
+	}
+	if(header == '$') {
+		/*	we do not support "EXI Cookie" */
+		errn = -1;
+	} else if ( header & 0x20 ) {
+		/* we do not support "Presence Bit for EXI Options" */
+		errn = -2;
+	} else {
+		/* Yes, a *simple* header */
+		errn = 0;
+	}
+	return errn;
+}
+
+
+#endif
+
+

src/codec/EXIHeaderDecoder.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+
+#include "EXITypes.h"
+
+#ifndef EXI_HEADER_DECODER_H
+#define EXI_HEADER_DECODER_H
+
+int readEXIHeader(bitstream_t* stream);
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif

src/codec/EXIHeaderEncoder.c

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "EXIHeaderEncoder.h"
+#include "BitOutputStream.h"
+#include "BitEncoderChannel.h"
+
+#ifndef EXI_HEADER_ENCODER_C
+#define EXI_HEADER_ENCODER_C
+
+int writeEXIHeader(bitstream_t* stream) {
+	return writeBits(stream, 8, 144);
+}
+
+
+#endif
+
+

src/codec/EXIHeaderEncoder.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+
+#include "EXITypes.h"
+
+#ifndef EXI_HEADER_ENCODER_H
+#define EXI_HEADER_ENCODER_H
+
+int writeEXIHeader(bitstream_t* stream);
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif

src/codec/EXITypes.h

@@ -0,0 +1,187 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <string.h>
+#include <stdint.h>
+
+#ifndef EXI_TYPES_H
+#define EXI_TYPES_H
+
+#define BITS_IN_BYTE 8
+
+#define UINT_MAX_VALUE 65535
+
+#define EXI_ELEMENT_STACK_SIZE 16
+
+/* EXI automaton methods prefixes such as "inline" etc. */
+#ifndef EXI_MPFX
+#define EXI_MPFX
+#endif
+
+#define FLOAT_EXPONENT_SPECIAL_VALUES -16384
+#define FLOAT_MANTISSA_INFINITY 1
+#define FLOAT_MANTISSA_MINUS_INFINITY -1
+#define FLOAT_MANTISSA_NOT_A_NUMBER 0
+
+typedef struct {
+	/*	Integer Array */
+	uint16_t size; /* array size */
+	uint8_t* data; /* int data array */
+	uint16_t* pos; /* next position in array */
+	/* Current byte buffer & its remaining bit capacity */
+	uint8_t buffer;
+	uint16_t capacity;
+} bitstream_t;
+
+typedef struct {
+	/* Bytes Size and array container */
+	uint16_t size;
+	uint8_t* data;
+	/* current length (len <= size) */
+	uint16_t len;
+} bytes_t;
+
+/* Universal Character Set (UCS) strings */
+typedef struct {
+	/* UCS size and UCS character container*/
+	uint16_t size;
+	uint32_t* codepoints;
+	/* current length == number of code-points, (len <= size) */
+	uint16_t len;
+} string_ucs_t;
+
+typedef struct {
+	/* range of the mantissa is -(2^63) to 2^63-1 */
+	int64_t mantissa;
+	/* range of the exponent is - (2^14-1) to 2^14-1 */
+	int32_t exponent; /* base-10 */
+} float_me_t;
+
+
+typedef enum
+{
+	/* Binary */
+	BINARY_BASE64, BINARY_HEX,
+	/* Boolean */
+	BOOLEAN,
+	/* Decimal */
+	DECIMAL,
+	/* Float */
+	FLOAT, DOUBLE,
+	/* N-Bit Integer */
+	NBIT_INTEGER_32, NBIT_INTEGER_64, NBIT_INTEGER_BIG,
+	/* Unsigned Integer */
+	UNSIGNED_INTEGER_16, UNSIGNED_INTEGER_32, UNSIGNED_INTEGER_64, UNSIGNED_INTEGER_BIG,
+	/* (Signed) Integer */
+	INTEGER_16, INTEGER_32, INTEGER_64, INTEGER_BIG,
+	/* Datetime */
+	DATETIME,
+	/* String */
+	STRING,
+	/* Enumeration */
+	ENUMERATION,
+	/* List */
+	LIST
+}  exi_datatype_t;
+
+
+typedef enum
+{
+	START_DOCUMENT,
+	END_DOCUMENT,
+	START_ELEMENT,
+	START_ELEMENT_GENERIC, /* not supported yet */
+	END_ELEMENT,
+	CHARACTERS,
+	CHARACTERS_GENERIC, /* not supported yet */
+	ATTRIBUTE,
+	ATTRIBUTE_GENERIC, /* not supported yet */
+	/* error state */
+	ERROR
+} exi_event_t;
+
+/* TODO list support */
+typedef struct {
+	/* List container with memory size */
+	uint16_t size;
+	uint8_t* data;
+	/* list item type */
+	exi_datatype_t type;
+	/* number of items */
+	uint16_t len;
+} list_t;
+
+
+typedef struct {
+	uint16_t namespaceURI;
+	uint16_t localPart;
+} eqname_t;
+
+typedef struct  {
+	/* stack of grammar states and elements */
+	uint16_t grammarStack [EXI_ELEMENT_STACK_SIZE];
+	eqname_t elementStack [EXI_ELEMENT_STACK_SIZE];
+	uint16_t stackIndex;
+	/* event-code */
+	uint32_t eventCode;
+} exi_state_t;
+
+
+typedef struct  {
+	/* type of value */
+	exi_datatype_t type;
+
+	/* base types */
+	int boolean;
+	uint32_t uint32;
+	uint64_t uint64;
+	int32_t int32;
+	int64_t int64;
+	uint32_t enumeration;
+
+	/* Bytes, Strings and Lists are not native types anymore */
+	bytes_t binary;
+	string_ucs_t string;
+	float_me_t float_me;
+	list_t list;
+} exi_value_t;
+
+
+/*
+ * ERROR-Codes
+ */
+# define EXI_ERROR_OUT_OF_BOUNDS -100
+
+# define EXI_ERROR_UNKOWN_EVENT_CODE -110
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif

src/codec/StringTable.c

@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#ifndef STRING_TABLE_C
+#define STRING_TABLE_C
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "StringTable.h"
+
+#include "StringTableEntries.h"
+
+#include "assert.h"
+
+int exiGetUri(uint16_t uriID, const char** uri) {
+	if ( uriID < stringTable.len ) {
+		*uri = stringTable.uris[uriID];
+	} else {
+		return EXI_ERROR_OUT_OF_BOUNDS;
+	}
+
+	return 0;
+}
+
+int exiGetUriLength(uint16_t* uriLength) {
+	*uriLength =  stringTable.len;
+	return 0;
+}
+
+
+int exiGetUriID(const char* uri, uint16_t* uriID) {
+	unsigned int i;
+	for(i=0; i<stringTable.len; i++) {
+		if ( strcmp ( uri, stringTable.uris[i] ) == 0 ) {
+			*uriID = i;
+			return 0;
+		}
+	}
+	return -1;
+}
+
+
+int exiGetLocalName(uint16_t uriID, uint16_t localNameID, const char** localName) {
+	if ( uriID < stringTable.len ) {
+		if ( localNameID < stringTable.localNames[uriID].len ) {
+			*localName = stringTable.localNames[uriID].entries[localNameID];
+		} else {
+			return EXI_ERROR_OUT_OF_BOUNDS;
+		}
+	} else {
+		return EXI_ERROR_OUT_OF_BOUNDS;
+	}
+	return 0;
+}
+
+int exiGetLocalNameLength(uint16_t uriID, uint16_t* localNameLength) {
+	if ( uriID < stringTable.len ) {
+		*localNameLength =  stringTable.localNames[uriID].len;
+	} else {
+		return EXI_ERROR_OUT_OF_BOUNDS;
+	}
+
+	return 0;
+}
+
+int exiGetLocalNameID(uint16_t uriID, const char* localName, uint16_t* localNameID) {
+	unsigned int i;
+	if ( uriID < stringTable.len ) {
+		/* TODO binary search */
+		for(i=0; i<stringTable.localNames[uriID].len; i++) {
+			if ( strcmp ( localName, stringTable.localNames[uriID].entries[i] ) == 0 ) {
+				*localNameID = i;
+				return 0;
+			}
+		}
+	} else {
+		return EXI_ERROR_OUT_OF_BOUNDS;
+	}
+
+	return -1;
+}
+
+#endif
+

src/codec/StringTable.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef STRING_TABLE_H
+#define STRING_TABLE_H
+
+#include "EXITypes.h"
+
+int exiGetUri(uint16_t uriID, const char** uri);
+
+int exiGetUriLength(uint16_t* uriLength);
+
+int exiGetUriID(const char* uri, uint16_t* uriID);
+
+int exiGetLocalName(uint16_t uriID, uint16_t localNameID, const char** localName);
+
+int exiGetLocalNameLength(uint16_t uriID, uint16_t* localNameLength);
+
+int exiGetLocalNameID(uint16_t uriID, const char* localName, uint16_t* localNameID);
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+

src/codec/StringTableEntries.c

@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#ifndef STRING_TABLE_ENTRIES_C
+#define STRING_TABLE_ENTRIES_C
+
+#include "StringTableEntries.h"
+
+
+/* ==================================== */
+/* String Table Population */
+
+/* localName entries for URI id = 0 */
+const char * localNames0[] = {
+ NULL 
+};
+/* localName entries for URI id = 1 */
+const char * localNames1[] = {
+  "base",  "id",  "lang",  "space"
+};
+/* localName entries for URI id = 2 */
+const char * localNames2[] = {
+  "nil",  "type"
+};
+/* localName entries for URI id = 3 */
+const char * localNames3[] = {
+  "ENTITIES",  "ENTITY",  "ID",  "IDREF",  "IDREFS",
+  "NCName",  "NMTOKEN",  "NMTOKENS",  "NOTATION",  "Name",
+  "QName",  "anySimpleType",  "anyType",  "anyURI",  "base64Binary",
+  "boolean",  "byte",  "date",  "dateTime",  "decimal",
+  "double",  "duration",  "float",  "gDay",  "gMonth",
+  "gMonthDay",  "gYear",  "gYearMonth",  "hexBinary",  "int",
+  "integer",  "language",  "long",  "negativeInteger",  "nonNegativeInteger",
+  "nonPositiveInteger",  "normalizedString",  "positiveInteger",  "short",  "string",
+  "time",  "token",  "unsignedByte",  "unsignedInt",  "unsignedLong",
+  "unsignedShort"
+};
+/* localName entries for URI id = 4 */
+const char * localNames4[] = {
+  "ContractID",  "EAmount",  "EVSEID",  "EVSEIMax",  "EVSEMaxPhases",
+  "EVSEMaxPower",  "EVSEStatus",  "EVSEVoltage",  "EnergyProvider",  "EoC",
+  "LineLockReq",  "LineLockReqType",  "LineLockRes",  "LineLockResType",  "MeterInfo",
+  "MeteringReceiptReq",  "MeteringReceiptReqType",  "MeteringReceiptRes",  "MeteringReceiptResType",  "MeteringStatusReq",
+  "MeteringStatusReqType",  "MeteringStatusRes",  "MeteringStatusResType",  "PCurrent",  "PEVID",
+  "PEVMaxPhases",  "PEVMaxPower",  "PEVMaxVoltage",  "PEVMinVoltage",  "PEVStatus",
+  "PaymentDetailsReq",  "PaymentDetailsReqType",  "PaymentDetailsRes",  "PaymentDetailsResType",  "PowerDeliveryReq",
+  "PowerDeliveryReqType",  "PowerDeliveryRes",  "PowerDeliveryResType",  "PowerDiscoveryReq",  "PowerDiscoveryReqType",
+  "PowerDiscoveryRes",  "PowerDiscoveryResType",  "ReqLockStatus",  "ReqSwitchStatus",  "ResponseCode",
+  "ServiceDiscoveryReq",  "ServiceDiscoveryReqType",  "ServiceDiscoveryRes",  "ServiceDiscoveryResType",  "ServiceList",
+  "ServicePaymentSelectionReq",  "ServicePaymentSelectionReqType",  "ServicePaymentSelectionRes",  "ServicePaymentSelectionResType",  "ServiceScope",
+  "ServiceType",  "SessionSetupReq",  "SessionSetupReqType",  "SessionSetupRes",  "SessionSetupResType",
+  "TCurrent",  "Tariff",  "TariffTable"
+};
+/* localName entries for URI id = 5 */
+const char * localNames5[] = {
+  "ChargerStandby",  "ChargingProfileEntryMaxPower",  "ChargingProfileEntryStart",  "ChargingProfileType",  "ConnectorLocked",
+  "Currency",  "EPrice",  "EVSEStandby",  "EVSEStatusType",  "Event",
+  "EventList",  "EventListType",  "FatalError",  "FaultCode",  "FaultMsg",
+  "FloatingValueType",  "MeterID",  "MeterInfoType",  "MeterReading",  "MeterStatus",
+  "Multiplier",  "NotificationType",  "PEVStatusType",  "PowerSwitchClosed",  "ProtocolVersion",
+  "RCD",  "Service",  "ServiceDescriptionType",  "ServiceID",  "ServiceListType",
+  "ServiceName",  "ServiceScope",  "ServiceSessionID",  "ServiceType",  "SessionID",
+  "SessionInformationType",  "ShutDownTime",  "TMeter",  "Tariff",  "TariffDescrType",
+  "TariffDescription",  "TariffEntries",  "TariffEntriesType",  "TariffEntry",  "TariffEntryType",
+  "TariffID",  "TariffPMax",  "TariffStart",  "TariffTableType",  "Unit",
+  "Value",  "contractIDType",  "currencyType",  "energyProviderType",  "eventEntryType",
+  "evseIDType",  "fatalErrorType",  "faultCodeType",  "lockStatusType",  "maxPhasesType",
+  "meterIDType",  "meterStatusType",  "paymentOptionListType",  "paymentOptionType",  "pevIDType",
+  "protocolVersionType",  "pubKeyType",  "rcdType",  "responseCode_LineLockType",  "responseCode_MeteringReceiptType",
+  "responseCode_MeteringStatusType",  "responseCode_PaymentDetailsType",  "responseCode_PowerDeliveryType",  "responseCode_PowerDiscoveryType",  "responseCode_ServiceDiscoveryType",
+  "responseCode_ServicePaymentSelectionType",  "responseCode_SessionSetupType",  "serviceDetailsType",  "serviceIDType",  "serviceNameType",
+  "serviceScopeType",  "serviceTypeType",  "sessionIDType",  "standbyType",  "switchStatusType",
+  "tariffDescriptionType",  "tariffIDType",  "tariffStartType",  "timeType",  "unitMultiplierType",
+  "unitSymbolType"
+};
+/* localName entries for URI id = 6 */
+const char * localNames6[] = {
+  "Body",  "BodyBaseType",  "BodyElement",  "BodyType",  "Header",
+  "V2G_Message"
+};
+/* localName entries for URI id = 7 */
+const char * localNames7[] = {
+  "HeaderType",  "Notification",  "SessionInformation"
+};
+struct exiPartition localNamePartitions[8] = {
+ { 0, localNames0 },
+ { 4, localNames1 },
+ { 2, localNames2 },
+ { 46, localNames3 },
+ { 63, localNames4 },
+ { 91, localNames5 },
+ { 6, localNames6 },
+ { 3, localNames7 }
+};
+const char * uris[] = {
+  "",  "http://www.w3.org/XML/1998/namespace",  "http://www.w3.org/2001/XMLSchema-instance",  "http://www.w3.org/2001/XMLSchema",  "urn:iso:15118:2:2010:eval1.0:MsgBody",  "urn:iso:15118:2:2010:eval1.0:MsgDataTypes",  "urn:iso:15118:2:2010:eval1.0:MsgDef",  "urn:iso:15118:2:2010:eval1.0:MsgHeader"
+};
+struct exiStringTable stringTable = { 8, uris, localNamePartitions };
+
+
+
+
+#endif
+

src/codec/StringTableEntries.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#ifndef STRING_TABLE_ENTRIES_H
+#define STRING_TABLE_ENTRIES_H
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+
+/* ==================================== */
+/* String Table Structures */
+
+struct exiPartition {
+	/* length of array */
+	uint16_t len;
+	/* array of string entries */
+	const char** entries;
+};
+
+struct exiStringTable {
+	/* length of both arrays (uris & localNames) */
+	uint16_t len;
+	/* URI entries*/
+	const char** uris;
+	/* localName entries divided by URI */
+	struct exiPartition * localNames;
+};
+
+
+/* ==================================== */
+/* String Table Population */
+
+extern struct exiStringTable stringTable;
+
+#endif
+

src/codec/UCSString.c

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include <stdint.h>
+
+#include "BitDecoderChannel.h"
+#include "BitInputStream.h"
+#include "EXITypes.h"
+
+#ifndef UCS_STRING_C
+#define UCS_STRING_C
+
+int toUCSString(char* chars, string_ucs_t* s) {
+	unsigned int i;
+	s->len = strlen(chars);
+
+	if (s->len <= s->size) {
+		for(i=0; i<s->len; i++) {
+			s->codepoints[i] = chars[i];
+		}
+		return 0;
+	} else {
+		return -1;
+	}
+}
+
+/* Note: fails if string contains non ASCII characters */
+int toASCIIString(string_ucs_t* string, char* outASCII) {
+	unsigned int i;
+	for(i=0; i<string->len; i++) {
+		outASCII[i] = (char)string->codepoints[i];
+	}
+	outASCII[string->len] = '\0';
+
+	return 0;
+}
+
+#endif
+

src/codec/UCSString.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2007-2010 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.3.1
+ * @contact Joerg.Heuer@siemens.com
+ *
+ ********************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "EXITypes.h"
+
+/* TODO utf8/cstring//wchar_t/char16_t/char32_t methods */
+
+
+#ifndef UCS_STRING_H
+#define UCS_STRING_H
+
+int toUCSString(char* chars, string_ucs_t* s);
+
+/* Note: fails if string contains non ASCII characters */
+int toASCIIString(string_ucs_t* string, char* outASCII);
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif