github-mirrors/OpenV2G
1
0
Fork 0
mirror of https://github.com/Martin-P/OpenV2G.git synced 2024-11-18 12:53:58 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

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

Browse source
This commit is contained in:
sebastiankb 2010-12-22 14:34:31 +00:00
parent 3b16a44a99
commit e1e0b55598
27 changed files with 0 additions and 5144 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

257
src/codec/BitDecoderChannel.c
View file

@ -1,257 +0,0 @@
/*
* 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
* @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
int decode(bitstream_t* stream, uint8_t* b) {
return readBits(stream, 8, b);
}
int decodeBoolean(bitstream_t* stream, int* b) {
uint8_t ub;
int errn = readBits(stream, 1, &ub);
*b = (ub == 0) ? 0 : 1;
return errn;
}
int decodeNBitUnsignedInteger(bitstream_t* stream, size_t nbits, uint8_t* uint8) {
if (nbits == 0) {
*uint8 = 0;
return 0;
} else {
return readBits(stream, nbits, uint8);
}
}
int decodeUnsignedInteger32(bitstream_t* stream, uint32_t* uint32) {
/* 0XXXXXXX ... 1XXXXXXX 1XXXXXXX */
unsigned int mShift = 0;
int errn = 0;
uint8_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;
uint8_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, size_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 = decodeUnsignedInteger32(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 = decodeUnsignedInteger32(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, size_t len, uint32_t* chars) {
unsigned int i;
int errn = 0;
for (i = 0; i < len && errn >= 0; i++) {
errn = decodeUnsignedInteger32(stream, &chars[i]);
}
return errn;
}
/**
* Decode a binary value as a length-prefixed sequence of octets.
*/
int decodeBinary(bitstream_t* stream, bytes_t* bytes) {
unsigned int i;
int errn = decodeUnsignedInteger32(stream, &bytes->len);
if (errn < 0) {
return errn;
}
for (i = 0; i < bytes->len && errn >= 0; i++) {
errn = decode(stream, &bytes->data[i]);
}
return errn;
}
#endif

117
src/codec/BitDecoderChannel.h
View file

@ -1,117 +0,0 @@
/*
* 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
* @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, size_t nbits, uint8_t* uint8);
/**
* 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 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, size_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

298
src/codec/BitEncoderChannel.c
View file

@ -1,298 +0,0 @@
/*
* 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
* @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, size_t nbits, uint8_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, size_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

133
src/codec/BitEncoderChannel.h
View file

@ -1,133 +0,0 @@
/*
* 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
* @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, size_t nbits, uint8_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, size_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

100
src/codec/BitInputStream.c
View file

@ -1,100 +0,0 @@
/*
* 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
* @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, size_t num_bits, uint8_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

44
src/codec/BitInputStream.h
View file

@ -1,44 +0,0 @@
/*
* 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
* @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, size_t num_bits, uint8_t* b);
int flush();
#endif
#ifdef __cplusplus
}
#endif

95
src/codec/BitOutputStream.c
View file

@ -1,95 +0,0 @@
/*
* 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
* @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, size_t nbits, uint8_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

48
src/codec/BitOutputStream.h
View file

@ -1,48 +0,0 @@
/*
* 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
* @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, size_t nbits, uint8_t bits);
/* flush output */
int flush(bitstream_t* stream);
#endif
#ifdef __cplusplus
}
#endif

83
src/codec/ByteStream.c
View file

@ -1,83 +0,0 @@
/*
* 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
* @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, size_t size, size_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, size_t len, const char * filename) {
size_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

46
src/codec/ByteStream.h
View file

@ -1,46 +0,0 @@
/*
* 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
* @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, size_t len, const char * filename);
int readBytesFromFile(const char * filename, uint8_t* data, size_t size, size_t pos);
#endif
#ifdef __cplusplus
}
#endif

70
src/codec/EXICoder.c
View file

@ -1,70 +0,0 @@
/*
* 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
* @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"
/*
size_t exiGetCurrentState(struct exiState* state) {
return state->grammarStates[state->currentStack];
// return 0;
}
*/
int exiPushStack(exi_state_t* state, size_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

51
src/codec/EXICoder.h
View file

@ -1,51 +0,0 @@
/*
* 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
* @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"
/* size_t exiGetCurrentState(struct exiState* state); */
int exiPushStack(exi_state_t* state, size_t newState, eqname_t* eqn);
int exiPopStack(exi_state_t* state);
#endif
#ifdef __cplusplus
}
#endif

1512
src/codec/EXIDecoder.c
View file

File diff suppressed because it is too large Load diff

61
src/codec/EXIDecoder.h
View file

@ -1,61 +0,0 @@
/*
* 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
* @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 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

1335
src/codec/EXIEncoder.c
View file

File diff suppressed because it is too large Load diff

61
src/codec/EXIEncoder.h
View file

@ -1,61 +0,0 @@
/*
* 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
* @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

58
src/codec/EXIHeaderDecoder.c
View file

@ -1,58 +0,0 @@
/*
* 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
* @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) {
uint8_t header;
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

44
src/codec/EXIHeaderDecoder.h
View file

@ -1,44 +0,0 @@
/*
* 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
* @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

43
src/codec/EXIHeaderEncoder.c
View file

@ -1,43 +0,0 @@
/*
* 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
* @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

44
src/codec/EXIHeaderEncoder.h
View file

@ -1,44 +0,0 @@
/*
* 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
* @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

185
src/codec/EXITypes.h
View file

@ -1,185 +0,0 @@
/*
* 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
* @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 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 */
size_t size; /* array size */
uint8_t* data; /* int data array */
size_t* pos; /* next position in array */
/* Current byte buffer & its remaining bit capacity */
uint8_t buffer;
size_t capacity;
} bitstream_t;
typedef struct {
/* Bytes Size and array container */
size_t size;
uint8_t* data;
/* current length (len <= size) */
size_t len;
} bytes_t;
/* Universal Character Set (UCS) strings */
typedef struct {
/* UCS size and UCS character container*/
size_t size;
uint32_t* codepoints;
/* current length == number of code-points, (len <= size) */
size_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 */
size_t size;
uint8_t* data;
/* list item type */
exi_datatype_t type;
/* number of items */
size_t len;
} list_t;
typedef struct {
unsigned int namespaceURI;
unsigned int localPart;
} eqname_t;
typedef struct {
/* stack of grammar states and elements */
size_t grammarStack [EXI_ELEMENT_STACK_SIZE];
eqname_t elementStack [EXI_ELEMENT_STACK_SIZE];
size_t stackIndex;
/* event-code */
uint8_t eventCode;
} exi_state_t;
typedef struct {
/* type of value */
exi_datatype_t type;
/* base types */
int boolean;
int8_t int8;
uint8_t uint8;
uint32_t uint32;
int32_t int32;
int64_t int64;
uint8_t enumeration;
/* Bytes, Strings and Lists are not native types anymore */
bytes_t binary;
string_ucs_t string;
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

112
src/codec/StringTable.c
View file

@ -1,112 +0,0 @@
/*
* 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
* @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 "EXITypes.h"
#include "BitInputStream.h"
#include "BitDecoderChannel.h"
#include "StringTableEntries.h"
#include "assert.h"
int exiGetUri(size_t uriID, const char** uri) {
if ( uriID < stringTable.len ) {
*uri = stringTable.uris[uriID];
} else {
return EXI_ERROR_OUT_OF_BOUNDS;
}
return 0;
}
int exiGetUriLength(size_t* uriLength) {
*uriLength = stringTable.len;
return 0;
}
int exiGetUriID(const char* uri, size_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(size_t uriID, size_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(size_t uriID, size_t* localNameLength) {
if ( uriID < stringTable.len ) {
*localNameLength = stringTable.localNames[uriID].len;
} else {
return EXI_ERROR_OUT_OF_BOUNDS;
}
return 0;
}
int exiGetLocalNameID(size_t uriID, const char* localName, size_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

53
src/codec/StringTable.h
View file

@ -1,53 +0,0 @@
/*
* 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
* @contact Joerg.Heuer@siemens.com
*
********************************************************************/
#ifdef __cplusplus
extern "C" {
#endif
#ifndef STRING_TABLE_H
#define STRING_TABLE_H
#include "EXITypes.h"
int exiGetUri(size_t uriID, const char** uri);
int exiGetUriLength(size_t* uriLength);
int exiGetUriID(const char* uri, size_t* uriID);
int exiGetLocalName(size_t uriID, size_t localNameID, const char** localName);
int exiGetLocalNameLength(size_t uriID, size_t* localNameLength);
int exiGetLocalNameID(size_t uriID, const char* localName, size_t* localNameID);
#endif
#ifdef __cplusplus
}
#endif

122
src/codec/StringTableEntries.c
View file

@ -1,122 +0,0 @@
/*
* 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
* @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[] = {
"ChargingProfile", "ContractID", "EAmount", "EVSEID", "EVSEIMax",
"EVSEMaxPhases", "EVSEMaxPower", "EVSEStatus", "EVSEVoltage", "EnergyProvider",
"EoC", "LineLockReq", "LineLockReqType", "LineLockRes", "LineLockResType",
"MeterInfo", "MeteringAuthPubKey", "MeteringReceiptReq", "MeteringReceiptReqType", "MeteringReceiptRes",
"MeteringReceiptResType", "MeteringStatusReq", "MeteringStatusReqType", "MeteringStatusRes", "MeteringStatusResType",
"PCurrent", "PEVID", "PEVMaxPhases", "PEVMaxPower", "PEVMaxVoltage",
"PEVMinVoltage", "PEVPubKey", "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",
"HeaderType", "Notification", "SessionInformation", "V2G_Message"
};
struct exiPartition localNamePartitions[7] = {
{ 0, localNames0 },
{ 4, localNames1 },
{ 2, localNames2 },
{ 46, localNames3 },
{ 66, localNames4 },
{ 91, localNames5 },
{ 9, localNames6 }
};
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:MsgBody", "urn:iso:15118:2:2010:MsgDataTypes", "urn:iso:15118:2:2010:MsgDef"
};
struct exiStringTable stringTable = { 7, uris, localNamePartitions };
#endif

60
src/codec/StringTableEntries.h
View file

@ -1,60 +0,0 @@
/*
* 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
* @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 */
size_t len;
/* array of string entries */
const char** entries;
};
struct exiStringTable {
/* length of both arrays (uris & localNames) */
size_t len;
/* URI entries*/
const char** uris;
/* localName entries divided by URI */
struct exiPartition * localNames;
};
/* ==================================== */
/* String Table Population */
extern struct exiStringTable stringTable;
#endif

64
src/codec/UCSString.c
View file

@ -1,64 +0,0 @@
/*
* 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
* @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

48
src/codec/UCSString.h
View file

@ -1,48 +0,0 @@
/*
* 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
* @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