* initial check-in for 15118:2:2016

* fix for https://sourceforge.net/p/openv2g/tickets/5/

git-svn-id: https://svn.code.sf.net/p/openv2g/code/trunk@98 d9f2db14-54d0-4bde-b00c-16405c910529
This commit is contained in:
daniel_peintner 2017-03-21 14:27:31 +00:00 committed by Martin-P
parent 33c295e2d9
commit be7e03c52e
49 changed files with 174554 additions and 28360 deletions

View file

@ -4,51 +4,39 @@
# Add inputs and outputs from these tool invocations to the build variables
C_SRCS += \
../src/codec/AbstractDecoderChannel.c \
../src/codec/AbstractEncoderChannel.c \
../src/codec/BitDecoderChannel.c \
../src/codec/BitEncoderChannel.c \
../src/codec/BitInputStream.c \
../src/codec/BitOutputStream.c \
../src/codec/ByteDecoderChannel.c \
../src/codec/ByteEncoderChannel.c \
../src/codec/ByteStream.c \
../src/codec/DecoderChannel.c \
../src/codec/EXIHeaderDecoder.c \
../src/codec/EXIHeaderEncoder.c \
../src/codec/EncoderChannel.c \
../src/codec/MethodsBag.c \
../src/codec/v2gEXIDatatypes.c \
../src/codec/v2gEXIDatatypesDecoder.c \
../src/codec/v2gEXIDatatypesEncoder.c
OBJS += \
./src/codec/AbstractDecoderChannel.o \
./src/codec/AbstractEncoderChannel.o \
./src/codec/BitDecoderChannel.o \
./src/codec/BitEncoderChannel.o \
./src/codec/BitInputStream.o \
./src/codec/BitOutputStream.o \
./src/codec/ByteDecoderChannel.o \
./src/codec/ByteEncoderChannel.o \
./src/codec/ByteStream.o \
./src/codec/DecoderChannel.o \
./src/codec/EXIHeaderDecoder.o \
./src/codec/EXIHeaderEncoder.o \
./src/codec/EncoderChannel.o \
./src/codec/MethodsBag.o \
./src/codec/v2gEXIDatatypes.o \
./src/codec/v2gEXIDatatypesDecoder.o \
./src/codec/v2gEXIDatatypesEncoder.o
C_DEPS += \
./src/codec/AbstractDecoderChannel.d \
./src/codec/AbstractEncoderChannel.d \
./src/codec/BitDecoderChannel.d \
./src/codec/BitEncoderChannel.d \
./src/codec/BitInputStream.d \
./src/codec/BitOutputStream.d \
./src/codec/ByteDecoderChannel.d \
./src/codec/ByteEncoderChannel.d \
./src/codec/ByteStream.d \
./src/codec/DecoderChannel.d \
./src/codec/EXIHeaderDecoder.d \
./src/codec/EXIHeaderEncoder.d \
./src/codec/EncoderChannel.d \
./src/codec/MethodsBag.d \
./src/codec/v2gEXIDatatypes.d \
./src/codec/v2gEXIDatatypesDecoder.d \

30
Debug/src/din/subdir.mk Normal file
View file

@ -0,0 +1,30 @@
################################################################################
# Automatically-generated file. Do not edit!
################################################################################
# Add inputs and outputs from these tool invocations to the build variables
C_SRCS += \
../src/din/dinEXIDatatypes.c \
../src/din/dinEXIDatatypesDecoder.c \
../src/din/dinEXIDatatypesEncoder.c
OBJS += \
./src/din/dinEXIDatatypes.o \
./src/din/dinEXIDatatypesDecoder.o \
./src/din/dinEXIDatatypesEncoder.o
C_DEPS += \
./src/din/dinEXIDatatypes.d \
./src/din/dinEXIDatatypesDecoder.d \
./src/din/dinEXIDatatypesEncoder.d
# Each subdirectory must supply rules for building sources it contributes
src/din/%.o: ../src/din/%.c
@echo 'Building file: $<'
@echo 'Invoking: GCC C Compiler'
gcc -I"../src/codec" -I"../src/din" -I"../src/xmldsig" -I"../src/appHandshake" -I"../src/transport" -I"../src/test" -O0 -g3 -Wall -c -fmessage-length=0 -ansi -MMD -MP -MF"$(@:%.o=%.d)" -MT"$(@:%.o=%.d)" -o "$@" "$<"
@echo 'Finished building: $<'
@echo ' '

View file

@ -0,0 +1,30 @@
################################################################################
# Automatically-generated file. Do not edit!
################################################################################
# Add inputs and outputs from these tool invocations to the build variables
C_SRCS += \
../src/xmldsig/xmldsigEXIDatatypes.c \
../src/xmldsig/xmldsigEXIDatatypesDecoder.c \
../src/xmldsig/xmldsigEXIDatatypesEncoder.c
OBJS += \
./src/xmldsig/xmldsigEXIDatatypes.o \
./src/xmldsig/xmldsigEXIDatatypesDecoder.o \
./src/xmldsig/xmldsigEXIDatatypesEncoder.o
C_DEPS += \
./src/xmldsig/xmldsigEXIDatatypes.d \
./src/xmldsig/xmldsigEXIDatatypesDecoder.d \
./src/xmldsig/xmldsigEXIDatatypesEncoder.d
# Each subdirectory must supply rules for building sources it contributes
src/xmldsig/%.o: ../src/xmldsig/%.c
@echo 'Building file: $<'
@echo 'Invoking: GCC C Compiler'
gcc -I"../src/codec" -I"../src/din" -I"../src/xmldsig" -I"../src/appHandshake" -I"../src/transport" -I"../src/test" -O0 -g3 -Wall -c -fmessage-length=0 -ansi -MMD -MP -MF"$(@:%.o=%.d)" -MT"$(@:%.o=%.d)" -o "$@" "$<"
@echo 'Finished building: $<'
@echo ' '

View file

@ -1,12 +1,12 @@
-------------------------------------------------------------------------
OpenV2G - an open source project implementing the basic functionality of the ISO IEC 15118 vehicle to grid (V2G) communication interface
Version 0.9.3, released February 25, 2015
Version 1.0.0alpha, released March/April ??, 2017
http://openv2g.sourceforge.net/
Please report bugs via the SourceForge bug tracking system at http://sourceforge.net/tracker/?group_id=350113.
Thank you.
Copyright (C) 2007-2015 Siemens AG
Copyright (C) 2007-2017 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
@ -21,6 +21,13 @@ 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/>.
-------------------------------------------------------------------------
CHANGES from version 0.9.3:
-------------------------------------------------------------------------
* Support for 15118-2-2016 XML schema
* internal coding updates
-------------------------------------------------------------------------
CHANGES from version 0.9.2:
-------------------------------------------------------------------------

View file

@ -4,51 +4,39 @@
# Add inputs and outputs from these tool invocations to the build variables
C_SRCS += \
../src/codec/AbstractDecoderChannel.c \
../src/codec/AbstractEncoderChannel.c \
../src/codec/BitDecoderChannel.c \
../src/codec/BitEncoderChannel.c \
../src/codec/BitInputStream.c \
../src/codec/BitOutputStream.c \
../src/codec/ByteDecoderChannel.c \
../src/codec/ByteEncoderChannel.c \
../src/codec/ByteStream.c \
../src/codec/DecoderChannel.c \
../src/codec/EXIHeaderDecoder.c \
../src/codec/EXIHeaderEncoder.c \
../src/codec/EncoderChannel.c \
../src/codec/MethodsBag.c \
../src/codec/v2gEXIDatatypes.c \
../src/codec/v2gEXIDatatypesDecoder.c \
../src/codec/v2gEXIDatatypesEncoder.c
OBJS += \
./src/codec/AbstractDecoderChannel.o \
./src/codec/AbstractEncoderChannel.o \
./src/codec/BitDecoderChannel.o \
./src/codec/BitEncoderChannel.o \
./src/codec/BitInputStream.o \
./src/codec/BitOutputStream.o \
./src/codec/ByteDecoderChannel.o \
./src/codec/ByteEncoderChannel.o \
./src/codec/ByteStream.o \
./src/codec/DecoderChannel.o \
./src/codec/EXIHeaderDecoder.o \
./src/codec/EXIHeaderEncoder.o \
./src/codec/EncoderChannel.o \
./src/codec/MethodsBag.o \
./src/codec/v2gEXIDatatypes.o \
./src/codec/v2gEXIDatatypesDecoder.o \
./src/codec/v2gEXIDatatypesEncoder.o
C_DEPS += \
./src/codec/AbstractDecoderChannel.d \
./src/codec/AbstractEncoderChannel.d \
./src/codec/BitDecoderChannel.d \
./src/codec/BitEncoderChannel.d \
./src/codec/BitInputStream.d \
./src/codec/BitOutputStream.d \
./src/codec/ByteDecoderChannel.d \
./src/codec/ByteEncoderChannel.d \
./src/codec/ByteStream.d \
./src/codec/DecoderChannel.d \
./src/codec/EXIHeaderDecoder.d \
./src/codec/EXIHeaderEncoder.d \
./src/codec/EncoderChannel.d \
./src/codec/MethodsBag.d \
./src/codec/v2gEXIDatatypes.d \
./src/codec/v2gEXIDatatypesDecoder.d \

30
Release/src/din/subdir.mk Normal file
View file

@ -0,0 +1,30 @@
################################################################################
# Automatically-generated file. Do not edit!
################################################################################
# Add inputs and outputs from these tool invocations to the build variables
C_SRCS += \
../src/din/dinEXIDatatypes.c \
../src/din/dinEXIDatatypesDecoder.c \
../src/din/dinEXIDatatypesEncoder.c
OBJS += \
./src/din/dinEXIDatatypes.o \
./src/din/dinEXIDatatypesDecoder.o \
./src/din/dinEXIDatatypesEncoder.o
C_DEPS += \
./src/din/dinEXIDatatypes.d \
./src/din/dinEXIDatatypesDecoder.d \
./src/din/dinEXIDatatypesEncoder.d
# Each subdirectory must supply rules for building sources it contributes
src/din/%.o: ../src/din/%.c
@echo 'Building file: $<'
@echo 'Invoking: GCC C Compiler'
gcc -I"../src/codec" -I"../src/din" -I"../src/xmldsig" -I"../src/appHandshake" -I"../src/transport" -I"../src/test" -Os -Wall -c -fmessage-length=0 -MMD -MP -MF"$(@:%.o=%.d)" -MT"$(@:%.o=%.d)" -o "$@" "$<"
@echo 'Finished building: $<'
@echo ' '

View file

@ -0,0 +1,30 @@
################################################################################
# Automatically-generated file. Do not edit!
################################################################################
# Add inputs and outputs from these tool invocations to the build variables
C_SRCS += \
../src/xmldsig/xmldsigEXIDatatypes.c \
../src/xmldsig/xmldsigEXIDatatypesDecoder.c \
../src/xmldsig/xmldsigEXIDatatypesEncoder.c
OBJS += \
./src/xmldsig/xmldsigEXIDatatypes.o \
./src/xmldsig/xmldsigEXIDatatypesDecoder.o \
./src/xmldsig/xmldsigEXIDatatypesEncoder.o
C_DEPS += \
./src/xmldsig/xmldsigEXIDatatypes.d \
./src/xmldsig/xmldsigEXIDatatypesDecoder.d \
./src/xmldsig/xmldsigEXIDatatypesEncoder.d
# Each subdirectory must supply rules for building sources it contributes
src/xmldsig/%.o: ../src/xmldsig/%.c
@echo 'Building file: $<'
@echo 'Invoking: GCC C Compiler'
gcc -I"../src/codec" -I"../src/din" -I"../src/xmldsig" -I"../src/appHandshake" -I"../src/transport" -I"../src/test" -Os -Wall -c -fmessage-length=0 -MMD -MP -MF"$(@:%.o=%.d)" -MT"$(@:%.o=%.d)" -o "$@" "$<"
@echo 'Finished building: $<'
@echo ' '

View file

@ -1,16 +1,15 @@
<?xml version="1.0" encoding="UTF-8"?>
<v2gci_d:V2G_Message xmlns:ds="http://www.w3.org/2000/09/xmldsig#"
xmlns:v2gci_t="urn:iso:15118:2:2013:MsgDataTypes"
xmlns:v2gci_d="urn:iso:15118:2:2013:MsgDef"
xmlns:v2gci_h="urn:iso:15118:2:2013:MsgHeader"
xmlns:v2gci_b="urn:iso:15118:2:2013:MsgBody"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<v2gci_d:V2G_Message xmlns:v2gci_b="urn:iso:15118:2:2016:MsgBody"
xmlns:ns2="urn:iso:15118:2:2016:MsgDataTypes"
xmlns:v2gci_h="urn:iso:15118:2:2016:MsgHeader"
xmlns:xmlsig="http://www.w3.org/2000/09/xmldsig#"
xmlns:v2gci_d="urn:iso:15118:2:2016:MsgDef">
<v2gci_d:Header>
<v2gci_h:SessionID>00</v2gci_h:SessionID>
<v2gci_h:SessionID>0000000000000000</v2gci_h:SessionID>
</v2gci_d:Header>
<v2gci_d:Body>
<v2gci_b:SessionSetupReq>
<v2gci_b:EVCCID>01</v2gci_b:EVCCID>
</v2gci_b:SessionSetupReq>
</v2gci_d:Body>
</v2gci_d:V2G_Message>
</v2gci_d:V2G_Message>

Binary file not shown.

View file

@ -1,17 +1,16 @@
<?xml version="1.0" encoding="UTF-8"?>
<v2gci_d:V2G_Message xmlns:v2gci_h="urn:iso:15118:2:2013:MsgHeader"
xmlns:v2gci_b="urn:iso:15118:2:2013:MsgBody"
xmlns:ds="http://www.w3.org/2000/09/xmldsig#"
xmlns:v2gci_t="urn:iso:15118:2:2013:MsgDataTypes"
xmlns:v2gci_d="urn:iso:15118:2:2013:MsgDef"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<v2gci_d:V2G_Message xmlns:v2gci_b="urn:iso:15118:2:2016:MsgBody"
xmlns:ns2="urn:iso:15118:2:2016:MsgDataTypes"
xmlns:v2gci_h="urn:iso:15118:2:2016:MsgHeader"
xmlns:xmlsig="http://www.w3.org/2000/09/xmldsig#"
xmlns:v2gci_d="urn:iso:15118:2:2016:MsgDef">
<v2gci_d:Header>
<v2gci_h:SessionID>010203040506</v2gci_h:SessionID>
<v2gci_h:SessionID>0000000000000010</v2gci_h:SessionID>
</v2gci_d:Header>
<v2gci_d:Body>
<v2gci_b:SessionSetupRes>
<v2gci_b:ResponseCode>OK</v2gci_b:ResponseCode>
<v2gci_b:EVSEID>ABC01234</v2gci_b:EVSEID>
<v2gci_b:EVSEID>1234567</v2gci_b:EVSEID>
<v2gci_b:EVSETimeStamp>123456789</v2gci_b:EVSETimeStamp>
</v2gci_b:SessionSetupRes>
</v2gci_d:Body>

Binary file not shown.

View file

@ -75,13 +75,10 @@ static int decode_appHandAppProtocolType(bitstream_t* stream, struct appHandAppP
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &appHandAppProtocolType->ProtocolNamespace.charactersLen);
if (errn == 0) {
errn = (appHandAppProtocolType->ProtocolNamespace.charactersLen - 2) <= appHandAppProtocolType_ProtocolNamespace_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (appHandAppProtocolType->ProtocolNamespace.charactersLen >= 2) {
appHandAppProtocolType->ProtocolNamespace.charactersLen = (uint16_t)(appHandAppProtocolType->ProtocolNamespace.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, appHandAppProtocolType->ProtocolNamespace.charactersLen, appHandAppProtocolType->ProtocolNamespace.characters);
errn = decodeCharacters(stream, appHandAppProtocolType->ProtocolNamespace.charactersLen, appHandAppProtocolType->ProtocolNamespace.characters, appHandAppProtocolType_ProtocolNamespace_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;

View file

@ -1,77 +0,0 @@
/*
* Copyright (C) 2007-2015 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.9.3
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
* <p>Schema: V2G_CI_MsgDef.xsd</p>
*
*
********************************************************************/
#include "DecoderChannel.h"
#include "BitInputStream.h"
#include "EXITypes.h"
#include "ErrorCodes.h"
#ifndef BIT_DECODER_CHANNEL_C
#define BIT_DECODER_CHANNEL_C
#if EXI_OPTION_ALIGNMENT == BIT_PACKED
int decode(bitstream_t* stream, uint8_t* b) {
uint32_t bb;
int errn = readBits(stream, 8, &bb);
if (errn == 0) {
if (bb > 256) {
errn = EXI_ERROR_UNEXPECTED_BYTE_VALUE;
} else {
*b = (uint8_t)bb;
}
}
return errn;
}
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) {
int errn = 0;
if (nbits == 0) {
*uint32 = 0;
} else {
errn= readBits(stream, nbits, uint32);
}
return errn;
}
#endif
#endif

View file

@ -1,92 +0,0 @@
/*
* Copyright (C) 2007-2015 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.9.3
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
* <p>Schema: V2G_CI_MsgDef.xsd</p>
*
*
********************************************************************/
#include "EncoderChannel.h"
#include "EXIOptions.h"
#include "BitOutputStream.h"
#include "EXITypes.h"
#ifndef BIT_ENCODER_CHANNEL_C
#define BIT_ENCODER_CHANNEL_C
#if EXI_OPTION_ALIGNMENT == BIT_PACKED
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) {
int errn = 0;
if (nbits > 0) {
errn = writeBits(stream, nbits, val);
}
return errn;
}
/**
* Flush underlying bit output stream.
*/
int encodeFinish(bitstream_t* stream) {
return flush(stream);
}
#endif /* alignment */
#endif

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
@ -64,7 +64,7 @@ static int readBuffer(bitstream_t* stream)
return errn;
}
int readBits(bitstream_t* stream, uint16_t num_bits, uint32_t* b)
int readBits(bitstream_t* stream, size_t num_bits, uint32_t* b)
{
int errn = readBuffer(stream);
if (errn == 0) {
@ -75,7 +75,7 @@ int readBits(bitstream_t* stream, uint16_t num_bits, uint32_t* b)
} else {
/* read bits as much as possible */
*b = (uint32_t)(stream->buffer & (0xff >> (BITS_IN_BYTE - stream->capacity)));
num_bits = (uint16_t)(num_bits - stream->capacity);
num_bits = (num_bits - stream->capacity);
stream->capacity = 0;
/* read whole bytes */
@ -83,7 +83,7 @@ int readBits(bitstream_t* stream, uint16_t num_bits, uint32_t* b)
{
errn = readBuffer(stream);
*b = ((*b) << BITS_IN_BYTE) | stream->buffer;
num_bits = (uint16_t)(num_bits - BITS_IN_BYTE);
num_bits = (num_bits - BITS_IN_BYTE);
stream->capacity = 0;
}

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
@ -57,7 +57,7 @@ extern "C" {
* \return Error-Code <> 0
*
*/
int readBits(bitstream_t* stream, uint16_t num_bits, uint32_t* b);
int readBits(bitstream_t* stream, size_t num_bits, uint32_t* b);
#ifdef __cplusplus

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
@ -37,7 +37,7 @@
#ifndef BIT_OUTPUT_STREAM_C
#define BIT_OUTPUT_STREAM_C
int writeBits(bitstream_t* stream, uint16_t nbits, uint32_t val) {
int writeBits(bitstream_t* stream, size_t nbits, uint32_t val) {
int errn = 0;
/* is there enough space in the buffer */
if (nbits <= stream->capacity) {
@ -67,7 +67,7 @@ int writeBits(bitstream_t* stream, uint16_t nbits, uint32_t val) {
stream->buffer = (uint8_t)(stream->buffer << stream->capacity) |
( (uint8_t)(val >> (nbits - stream->capacity)) & (uint8_t)(0xff >> (BITS_IN_BYTE - stream->capacity)) );
nbits = (uint16_t)(nbits - stream->capacity);
nbits = (nbits - stream->capacity);
#if EXI_STREAM == BYTE_ARRAY
if ((*stream->pos) >= stream->size) {
errn = EXI_ERROR_OUTPUT_STREAM_EOF;
@ -84,7 +84,7 @@ int writeBits(bitstream_t* stream, uint16_t nbits, uint32_t val) {
/* write whole bytes */
while (errn == 0 && nbits >= BITS_IN_BYTE) {
nbits = (uint16_t)(nbits - BITS_IN_BYTE);
nbits = (nbits - BITS_IN_BYTE);
#if EXI_STREAM == BYTE_ARRAY
if ((*stream->pos) >= stream->size) {
errn = EXI_ERROR_OUTPUT_STREAM_EOF;

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
@ -60,7 +60,7 @@ extern "C" {
* \return Error-Code <> 0
*
*/
int writeBits(bitstream_t* stream, uint16_t nbits, uint32_t bits);
int writeBits(bitstream_t* stream, size_t nbits, uint32_t bits);
/**

View file

@ -1,93 +0,0 @@
/*
* Copyright (C) 2007-2015 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.9.3
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
* <p>Schema: V2G_CI_MsgDef.xsd</p>
*
*
********************************************************************/
#include "DecoderChannel.h"
#include "EXIOptions.h"
#include "BitInputStream.h"
#include "EXITypes.h"
#include "ErrorCodes.h"
#ifndef BYTE_DECODER_CHANNEL_C
#define BYTE_DECODER_CHANNEL_C
#if EXI_OPTION_ALIGNMENT == BYTE_ALIGNMENT
int decode(bitstream_t* stream, uint8_t* b) {
int errn = 0;
#if EXI_STREAM == BYTE_ARRAY
if ( (*stream->pos) < stream->size ) {
*b = stream->data[(*stream->pos)++];
} else {
errn = EXI_ERROR_INPUT_STREAM_EOF;
}
#endif /* EXI_STREAM == BYTE_ARRAY */
#if EXI_STREAM == FILE_STREAM
*b = (uint8_t)(getc(stream->file));
/* EOF cannot be used, 0xFF valid value */
if ( feof(stream->file) || ferror(stream->file) ) {
errn = EXI_ERROR_INPUT_STREAM_EOF;
}
#endif /* EXI_STREAM == FILE_STREAM */
return errn;
}
int decodeBoolean(bitstream_t* stream, int* b) {
uint8_t bb;
int errn = decode(stream, &bb);
*b = (bb == 0) ? 0 : 1;
return errn;
}
/**
* Decodes and returns an n-bit unsigned integer using the minimum number of
* bytes required for n bits.
*/
int decodeNBitUnsignedInteger(bitstream_t* stream, uint16_t nbits, uint32_t* uint32) {
uint16_t bitsRead = 0;
uint8_t b;
int errn = 0;
*uint32 = 0;
while (errn == 0 && bitsRead < nbits) {
errn = decode(stream, &b);
*uint32 = *uint32 + (uint32_t)(b << bitsRead);
bitsRead = (uint16_t)(bitsRead + 8);
}
return errn;
}
#endif
#endif

View file

@ -1,143 +0,0 @@
/*
* Copyright (C) 2007-2015 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.9.3
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
* <p>Schema: V2G_CI_MsgDef.xsd</p>
*
*
********************************************************************/
#include "EncoderChannel.h"
#include "EXIOptions.h"
#include "BitOutputStream.h"
#include "EXITypes.h"
#include "MethodsBag.h"
#include "ErrorCodes.h"
#ifndef BYTE_ENCODER_CHANNEL_C
#define BYTE_ENCODER_CHANNEL_C
#if EXI_OPTION_ALIGNMENT == BYTE_ALIGNMENT
int encode(bitstream_t* stream, uint8_t b) {
int errn = 0;
#if EXI_STREAM == BYTE_ARRAY
if ( (*stream->pos) < stream->size ) {
stream->data[(*stream->pos)++] = b;
} else {
errn = EXI_ERROR_OUTPUT_STREAM_EOF;
}
#endif /* EXI_STREAM == BYTE_ARRAY */
#if EXI_STREAM == FILE_STREAM
if ( putc(b, stream->file) == EOF ) {
errn = EXI_ERROR_OUTPUT_STREAM_EOF;
}
#endif /* EXI_STREAM == FILE_STREAM */
return errn;
}
/**
* Encode a single boolean value. A false value is encoded as byte 0 and true
* value is encode as byte 1.
*/
int encodeBoolean(bitstream_t* stream, int b) {
uint8_t val = b ? 1 : 0;
return encode(stream, 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) {
int errn = 0;
if (nbits > 0) {
if (nbits < 9) {
/* 1 byte */
errn = encode(stream, val & 0xff);
} else if (nbits < 17) {
/* 2 bytes */
errn = encode(stream, val & 0x00ff);
if(errn == 0) {
errn = encode(stream, (uint8_t)((val & 0xff00) >> 8));
}
} else if (nbits < 25) {
/* 3 bytes */
errn = encode(stream, val & 0x0000ff);
if(errn == 0) {
errn = encode(stream, (uint8_t)((val & 0x00ff00) >> 8));
if(errn == 0) {
errn = encode(stream, (uint8_t)((val & 0xff0000) >> 16));
}
}
} else if (nbits < 33) {
/* 4 bytes */
errn = encode(stream, val & 0x000000ff);
if(errn == 0) {
errn = encode(stream, (uint8_t)((val & 0x0000ff00) >> 8));
if(errn == 0) {
errn = encode(stream, (uint8_t)((val & 0x00ff0000) >> 16));
if(errn == 0) {
errn = encode(stream, (uint8_t)((val & 0xff000000) >> 24));
}
}
}
} else {
/* TODO Currently not more than 4 Bytes allowed for NBitUnsignedInteger */
errn = EXI_UNSUPPORTED_NBIT_INTEGER_LENGTH;
}
}
return errn;
}
/**
* Flush underlying bit output stream.
*/
#pragma warning( disable : 4100 ) /* warning unreferenced parameter 'stream' */
int encodeFinish(bitstream_t* stream) {
/* no pending bits in byte-aligned mode */
return 0;
}
#pragma warning( default : 4100 ) /* warning unreferenced parameter 'stream' */
#endif /* alignment */
#endif

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
@ -41,7 +41,7 @@
#ifndef BYTE_STREAM_C
#define BYTE_STREAM_C
int readBytesFromFile(const char * filename, uint8_t* data, uint16_t size, uint16_t* pos) {
int readBytesFromFile(const char * filename, uint8_t* data, size_t size, size_t* pos) {
FILE* f;
int character;
int errn = 0;
@ -65,7 +65,7 @@ int readBytesFromFile(const char * filename, uint8_t* data, uint16_t size, uint1
return errn;
}
int writeBytesToFile(uint8_t* data, uint16_t len, const char * filename) {
int writeBytesToFile(uint8_t* data, size_t len, const char * filename) {
size_t rlen;
FILE* f = fopen(filename, "wb+");

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
@ -53,7 +53,7 @@ extern "C" {
* \return Error-Code <> 0
*
*/
int writeBytesToFile(uint8_t* data, uint16_t len, const char * filename);
int writeBytesToFile(uint8_t* data, size_t len, const char * filename);
/**
@ -66,7 +66,7 @@ int writeBytesToFile(uint8_t* data, uint16_t len, const char * filename);
* \return Error-Code <> 0
*
*/
int readBytesFromFile(const char * filename, uint8_t* data, uint16_t size, uint16_t* pos);
int readBytesFromFile(const char * filename, uint8_t* data, size_t size, size_t* pos);
#ifdef __cplusplus
}

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
@ -43,8 +43,8 @@
#include "DynamicMemory.h"
#endif /* DYNAMIC_ALLOCATION */
#ifndef ABSTRACT_DECODER_CHANNEL_C
#define ABSTRACT_DECODER_CHANNEL_C
#ifndef DECODER_CHANNEL_C
#define DECODER_CHANNEL_C
/* unsigned long == 64 bits, 10 * 7bits = 70 bits */
#define MAX_OCTETS_FOR_UNSIGNED_INTEGER_64 10
@ -209,6 +209,38 @@ int decodeUnsignedInteger32(bitstream_t* stream, uint32_t* uint32) {
return errn;
}
int decodeUnsignedIntegerSizeT(bitstream_t* stream, size_t* sizeT) {
int errn = 0;
/* TODO is there a better way to detect the actual size of size_t */
if(SIZE_MAX == UINT16_MAX) {
/* 16bit */
uint16_t uint16;
errn = decodeUnsignedInteger16(stream, &uint16);
if(errn == 0) {
*sizeT = (size_t)uint16;
}
} else if(SIZE_MAX == UINT32_MAX) {
/* 32bit */
uint32_t uint32;
errn = decodeUnsignedInteger32(stream, &uint32);
if(errn == 0) {
*sizeT = (size_t)uint32;
}
} else {
/* 64bit */
uint64_t uint64;
errn = decodeUnsignedInteger64(stream, &uint64);
if(errn == 0) {
*sizeT = (size_t)uint64;
}
}
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
@ -360,9 +392,9 @@ int decodeDecimal(bitstream_t* stream, exi_decimal_t* d) {
/**
* Decode a sequence of characters for a given length.
*/
int decodeStringOnly(bitstream_t* stream, uint16_t len, exi_string_t* s) {
int decodeStringOnly(bitstream_t* stream, size_t len, exi_string_t* s) {
int errn = 0;
int extraChar = 0;
unsigned int extraChar = 0;
#if STRING_REPRESENTATION == STRING_REPRESENTATION_ASCII
extraChar = 1; /* null terminator */
#endif /* STRING_REPRESENTATION_ASCII */
@ -378,11 +410,11 @@ int decodeStringOnly(bitstream_t* stream, uint16_t len, exi_string_t* s) {
return errn;
}
}
errn = exiAllocateDynamicStringMemory(s, s->len);
errn = exiAllocateDynamicStringMemory(s, (len + extraChar)); /*s->len*/
#endif /* DYNAMIC_ALLOCATION */
}
if(errn == 0) {
errn = decodeCharacters(stream, len, s->characters);
errn = decodeCharacters(stream, len, s->characters, s->size);
s->len = len;
}
@ -393,165 +425,31 @@ int decodeStringOnly(bitstream_t* stream, uint16_t len, exi_string_t* s) {
* Decode a length prefixed sequence of characters.
*/
int decodeString(bitstream_t* stream, exi_string_t* s) {
int errn = decodeUnsignedInteger16(stream, &s->len);
int errn = decodeUnsignedIntegerSizeT(stream, &s->len);
if (errn == 0) {
errn = decodeStringOnly(stream, s->len, s);
}
return errn;
}
static int _readStringValueLocalHit(bitstream_t* stream, exi_state_t* state, uint16_t qnameID, uint32_t* localID) {
int errn;
uint16_t codingLength;
if( state->stringTable.sizeLocalStrings > qnameID ) {
errn = exiGetCodingLength(state->stringTable.numberOfLocalStrings[qnameID], &codingLength);
if(errn == 0) {
errn = decodeNBitUnsignedInteger(stream, codingLength, localID);
}
} else {
errn = EXI_ERROR_OUT_OF_BOUNDS;
}
return errn;
}
static int _readStringValueGlobalHit(bitstream_t* stream, exi_state_t* state, uint32_t* globalID) {
int errn;
uint16_t codingLength;
errn = exiGetCodingLength(state->stringTable.numberOfGlobalStrings, &codingLength);
if(errn == 0) {
errn = decodeNBitUnsignedInteger(stream, codingLength, globalID);
}
return errn;
}
int decodeStringValue(bitstream_t* stream, exi_state_t* state, uint16_t qnameID, exi_string_value_t* s) {
uint16_t L;
int errn = decodeUnsignedInteger16(stream, &L);
if (errn == 0) {
switch (L) {
case 0:
/* local value partition */
s->type = EXI_STRING_VALUE_LOCAL_HIT;
errn = _readStringValueLocalHit(stream, state, qnameID, &s->localID);
break;
case 1:
/* found in global value partition */
s->type = EXI_STRING_VALUE_GLOBAL_HIT;
errn = _readStringValueGlobalHit(stream, state, &s->globalID);
break;
default:
/* not found in global value (and local value) partition
* ==> string literal is encoded as a String with the length
* incremented by two */
s->type = EXI_STRING_VALUE_MISS;
s->miss.len = L = (uint16_t)(L - 2);
errn = decodeStringOnly(stream, L, &(s->miss));
if(errn == 0) {
#if EXI_OPTION_VALUE_PARTITION_CAPACITY != 0
#if EXI_OPTION_VALUE_MAX_LENGTH != 0
/* If length L is greater than zero the string S is added */
if(L > 0) {
/* After encoding the string value, it is added to both the
* associated "local" value string table partition and the global
* value string table partition */
#if EXI_OPTION_VALUE_MAX_LENGTH < 0
errn = exiAddStringValue(&state->stringTable, &(s->miss), qnameID);
# else /* EXI_v2gVALUE_MAX_LENGTH < 0 */
if (L <= EXI_OPTION_VALUE_MAX_LENGTH) {
errn = exiAddStringValue(&state->stringTable, &(s->miss), qnameID);
}
#endif /* EXI_OPTION_VALUE_MAX_LENGTH < 0 */
}
#endif /* EXI_OPTION_VALUE_MAX_LENGTH != 0 */
#endif /* EXI_OPTION_VALUE_PARTITION_CAPACITY != 0 */
}
break;
}
}
return errn;
}
int decodeRCSStringValue(bitstream_t* stream, exi_state_t* state, uint16_t qnameID, exi_rcs_t* rcs, exi_string_value_t* s) {
unsigned int i;
uint32_t cp;
uint16_t L;
int errn = decodeUnsignedInteger16(stream, &L);
if (errn == 0) {
switch (L) {
case 0:
/* local value partition */
s->type = EXI_STRING_VALUE_LOCAL_HIT;
errn = _readStringValueLocalHit(stream, state, qnameID, &s->localID);
break;
case 1:
/* found in global value partition */
s->type = EXI_STRING_VALUE_GLOBAL_HIT;
errn = _readStringValueGlobalHit(stream, state, &s->globalID);
break;
default:
/* not found in global value (and local value) partition
* ==> string literal is encoded as a String with the length
* incremented by two */
s->type = EXI_STRING_VALUE_MISS;
s->miss.len = L = (uint16_t)(L - 2);
if (L > s->miss.size) {
#if MEMORY_ALLOCATION == STATIC_ALLOCATION
errn = EXI_ERROR_OUT_OF_STRING_BUFFER;
#endif /* STATIC_ALLOCATION */
#if MEMORY_ALLOCATION == DYNAMIC_ALLOCATION
if(s->miss.size > 0) {
errn = exiFreeDynamicStringMemory(&(s->miss));
}
if(errn == 0) {
errn = exiAllocateDynamicStringMemory(&(s->miss), L);
}
#endif /* DYNAMIC_ALLOCATION */
}
if(errn == 0) {
for (i = 0; i < L && errn >= 0; i++) {
errn = decodeNBitUnsignedInteger(stream, rcs->codingLength, &cp);
s->miss.characters[i] = rcs->characters[cp];
}
#if EXI_OPTION_VALUE_PARTITION_CAPACITY != 0
#if EXI_OPTION_VALUE_MAX_LENGTH != 0
/* If length L is greater than zero the string S is added */
if(errn == 0 && L > 0) {
/* After encoding the string value, it is added to both the
* associated "local" value string table partition and the global
* value string table partition */
#if EXI_OPTION_VALUE_MAX_LENGTH < 0
errn = exiAddStringValue(&state->stringTable, &(s->miss), qnameID);
# else /* EXI_OPTION_VALUE_MAX_LENGTH < 0 */
if (L <= EXI_OPTION_VALUE_MAX_LENGTH) {
errn = exiAddStringValue(&state->stringTable, &(s->miss), qnameID);
}
#endif /* EXI_OPTION_VALUE_MAX_LENGTH < 0 */
}
#endif /* EXI_OPTION_VALUE_MAX_LENGTH != 0 */
#endif /* EXI_OPTION_VALUE_PARTITION_CAPACITY != 0 */
}
break;
}
}
return errn;
}
/**
* 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, exi_string_character_t* chars) {
int decodeCharacters(bitstream_t* stream, size_t len, exi_string_character_t* chars, size_t charsSize) {
unsigned int i;
int errn = 0;
int errn = 0;
unsigned int extraChar = 0;
#if STRING_REPRESENTATION == STRING_REPRESENTATION_ASCII
extraChar = 1; /* null terminator */
#endif /* STRING_REPRESENTATION_ASCII */
if ( (len + extraChar) > charsSize) {
errn = EXI_ERROR_OUT_OF_STRING_BUFFER;
return errn;
}
#if STRING_REPRESENTATION == STRING_REPRESENTATION_ASCII
uint8_t b;
@ -579,13 +477,20 @@ int decodeCharacters(bitstream_t* stream, uint16_t len, exi_string_character_t*
return errn;
}
int decodeRCSCharacters(bitstream_t* stream, uint16_t len, exi_string_character_t* chars, uint16_t rcsCodeLength, uint16_t rcsSize, const exi_string_character_t rcsSet[]) {
int decodeRCSCharacters(bitstream_t* stream, size_t len, exi_string_character_t* chars, size_t charsSize, size_t rcsCodeLength, size_t rcsSize, const exi_string_character_t rcsSet[]) {
unsigned int i;
int errn = 0;
uint32_t uint32;
#if STRING_REPRESENTATION == STRING_REPRESENTATION_ASCII
uint8_t b;
#endif /* STRING_REPRESENTATION_ASCII */
unsigned int extraChar = 0;
#if STRING_REPRESENTATION == STRING_REPRESENTATION_ASCII
uint8_t b;
extraChar = 1; /* null terminator */
#endif /* STRING_REPRESENTATION_ASCII */
if ( (len + extraChar) > charsSize) {
errn = EXI_ERROR_OUT_OF_STRING_BUFFER;
return errn;
}
for (i = 0; i < len && errn == 0; i++) {
@ -625,7 +530,7 @@ int decodeRCSCharacters(bitstream_t* stream, uint16_t len, exi_string_character_
* Decode a binary value as a length-prefixed sequence of octets.
*/
int decodeBinary(bitstream_t* stream, exi_bytes_t* bytes) {
int errn = decodeUnsignedInteger16(stream, &bytes->len);
int errn = decodeUnsignedIntegerSizeT(stream, &bytes->len);
if (errn == 0) {
if (bytes->len > bytes->size) {
#if MEMORY_ALLOCATION == STATIC_ALLOCATION
@ -646,7 +551,7 @@ int decodeBinary(bitstream_t* stream, exi_bytes_t* bytes) {
}
int decodeBytes(bitstream_t* stream, uint16_t len, uint8_t* data) {
int decodeBytes(bitstream_t* stream, size_t len, uint8_t* data) {
unsigned int i;
int errn = 0;
uint8_t b;
@ -738,5 +643,90 @@ int decodeDateTime(bitstream_t* stream, exi_datetime_type_t type, exi_datetime_t
return errn;
}
int decode(bitstream_t* stream, uint8_t* b) {
#if EXI_OPTION_ALIGNMENT == BIT_PACKED
uint32_t bb;
int errn = readBits(stream, 8, &bb);
if (errn == 0) {
if (bb > 256) {
errn = EXI_ERROR_UNEXPECTED_BYTE_VALUE;
} else {
*b = (uint8_t)bb;
}
}
return errn;
#endif /* EXI_OPTION_ALIGNMENT == BIT_PACKED */
#if EXI_OPTION_ALIGNMENT == BYTE_ALIGNMENT
int errn = 0;
#if EXI_STREAM == BYTE_ARRAY
if ( (*stream->pos) < stream->size ) {
*b = stream->data[(*stream->pos)++];
} else {
errn = EXI_ERROR_INPUT_STREAM_EOF;
}
#endif /* EXI_STREAM == BYTE_ARRAY */
#if EXI_STREAM == FILE_STREAM
*b = (uint8_t)(getc(stream->file));
/* EOF cannot be used, 0xFF valid value */
if ( feof(stream->file) || ferror(stream->file) ) {
errn = EXI_ERROR_INPUT_STREAM_EOF;
}
#endif /* EXI_STREAM == FILE_STREAM */
return errn;
#endif /* EXI_OPTION_ALIGNMENT == BYTE_ALIGNMENT */
}
int decodeBoolean(bitstream_t* stream, int* b) {
#if EXI_OPTION_ALIGNMENT == BIT_PACKED
uint32_t ub;
int errn = readBits(stream, 1, &ub);
*b = (ub == 0) ? 0 : 1;
return errn;
#endif /* EXI_OPTION_ALIGNMENT == BIT_PACKED */
#if EXI_OPTION_ALIGNMENT == BYTE_ALIGNMENT
uint8_t bb;
int errn = decode(stream, &bb);
*b = (bb == 0) ? 0 : 1;
return errn;
#endif /* EXI_OPTION_ALIGNMENT == BYTE_ALIGNMENT */
}
/**
* Decodes and returns an n-bit unsigned integer using the minimum number of
* bytes required for n bits.
*/
int decodeNBitUnsignedInteger(bitstream_t* stream, size_t nbits, uint32_t* uint32) {
#if EXI_OPTION_ALIGNMENT == BIT_PACKED
int errn = 0;
if (nbits == 0) {
*uint32 = 0;
} else {
errn= readBits(stream, nbits, uint32);
}
return errn;
#endif /* EXI_OPTION_ALIGNMENT == BIT_PACKED */
#if EXI_OPTION_ALIGNMENT == BYTE_ALIGNMENT
size_t bitsRead = 0;
uint8_t b;
int errn = 0;
*uint32 = 0;
while (errn == 0 && bitsRead < nbits) {
errn = decode(stream, &b);
*uint32 = *uint32 + (uint32_t)(b << bitsRead);
bitsRead = (bitsRead + 8);
}
return errn;
#endif /* EXI_OPTION_ALIGNMENT == BYTE_ALIGNMENT */
}
#endif

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
@ -81,7 +81,7 @@ int decodeBoolean(bitstream_t* stream, int* b);
* \return Error-Code <> 0
*
*/
int decodeNBitUnsignedInteger(bitstream_t* stream, uint16_t nbits, uint32_t* uint32);
int decodeNBitUnsignedInteger(bitstream_t* stream, size_t nbits, uint32_t* uint32);
/**
@ -132,6 +132,22 @@ int decodeUnsignedInteger16(bitstream_t* stream, uint16_t* uint16);
int decodeUnsignedInteger32(bitstream_t* stream, uint32_t* uint32);
/**
* \brief Decode unsigned integer
*
* 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.
*
* \param stream Input Stream
* \param sizeT Unsigned Integer Value (out)
* \return Error-Code <> 0
*
*/
int decodeUnsignedIntegerSizeT(bitstream_t* stream, size_t* sizeT);
/**
* \brief Decode unsigned integer
*
@ -258,7 +274,7 @@ int decodeDecimal(bitstream_t* stream, exi_decimal_t* d);
* \return Error-Code <> 0
*
*/
int decodeStringOnly(bitstream_t* stream, uint16_t len, exi_string_t* s);
int decodeStringOnly(bitstream_t* stream, size_t len, exi_string_t* s);
/**
@ -284,27 +300,30 @@ int decodeString(bitstream_t* stream, exi_string_t* s);
* length > 1: string literal is encoded as a String with the length incremented by two
*
* \param stream Input Stream
* \param state Codec state
* \param stringTable String Table
* \param qnameID Qualified Name ID
* \param namespaceUriID Qualified Namespace ID
* \param localNameID Qualified LocalName ID
* \param s String Value (out)
* \return Error-Code <> 0
*
*/
int decodeStringValue(bitstream_t* stream, exi_state_t* state, uint16_t qnameID, exi_string_value_t* s);
int decodeStringValue(bitstream_t* stream, exi_value_string_table_t* stringTable, size_t namespaceUriID, size_t localNameID, exi_string_value_t* s);
/**
* \brief Decode Restricted characters set string value
*
* \param stream Input Stream
* \param state Codec state
* \param qnameID Qualified Name ID
* \param stringTable StringTable
* \param namespaceUriID qualified namespace ID
* \param localNameID qualified localName ID
* \param rcs Restricted character set
* \param s String Value (out)
* \return Error-Code <> 0
*
*/
int decodeRCSStringValue(bitstream_t* stream, exi_state_t* state, uint16_t qnameID, exi_rcs_t* rcs, exi_string_value_t* s);
int decodeRCSStringValue(bitstream_t* stream, exi_value_string_table_t* stringTable, size_t namespaceUriID, size_t localNameID, exi_rcs_t* rcs, exi_string_value_t* s);
/**
@ -314,11 +333,12 @@ int decodeRCSStringValue(bitstream_t* stream, exi_state_t* state, uint16_t qname
*
* \param stream Input Stream
* \param len Length
* \param chars Characters (out)
* \param chars Characters (out)
* \param charsSize Size of possible characters
* \return Error-Code <> 0
*
*/
int decodeCharacters(bitstream_t* stream, uint16_t len, exi_string_character_t* chars);
int decodeCharacters(bitstream_t* stream, size_t len, exi_string_character_t* chars, size_t charsSize);
/**
@ -328,14 +348,15 @@ int decodeCharacters(bitstream_t* stream, uint16_t len, exi_string_character_t*
*
* \param stream Input Stream
* \param len Length
* \param chars Characters (out)
* \param chars Characters (out)
* \param charsSize Size of possible characters
* \param rcsCodeLength RCS code-length
* \param rcsCodeLength RCS size
* \param rcsCodeLength RCS set
* \return Error-Code <> 0
*
*/
int decodeRCSCharacters(bitstream_t* stream, uint16_t len, exi_string_character_t* chars, uint16_t rcsCodeLength, uint16_t rcsSize, const exi_string_character_t rcsSet[]);
int decodeRCSCharacters(bitstream_t* stream, size_t len, exi_string_character_t* chars, size_t charsSize, size_t rcsCodeLength, size_t rcsSize, const exi_string_character_t rcsSet[]);
@ -362,7 +383,7 @@ int decodeBinary(bitstream_t* stream, exi_bytes_t* bytes);
* \return Error-Code <> 0
*
*/
int decodeBytes(bitstream_t* stream, uint16_t len, uint8_t* data);
int decodeBytes(bitstream_t* stream, size_t len, uint8_t* data);
/**
* \brief Decode DateTime

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
@ -27,67 +27,67 @@
*
********************************************************************/
/**
* \file EXIOptions.h
* \brief EXI Options for the EXI Codec
*
*/
#ifndef EXI_OPTIONS_H
#define EXI_OPTIONS_H
#ifdef __cplusplus
extern "C" {
#endif
/** EXI alignment - Option bit-packed */
#define BIT_PACKED 1
/** EXI alignment - Option byte-packed */
#define BYTE_ALIGNMENT 2
/** EXI alignment */
/**
* \brief EXI Option 'alignment'
*
* The alignment option is used to control the alignment of event codes and content items.
* Default Value: bit-packed
*/
#define EXI_OPTION_ALIGNMENT BIT_PACKED
/**
* \brief EXI Option 'strict'
*
* Strict interpretation of schemas is used to achieve better compactness.
* Default Value: false
*/
#define EXI_OPTION_STRICT 0
/**
* \brief EXI Option 'valueMaxLength'
*
* Specifies the maximum string length of value content items to be
* considered for addition to the string table.
* Default Value: unbounded (-1)
*/
#define EXI_OPTION_VALUE_MAX_LENGTH -1
/**
* \brief EXI Option 'valuePartitionCapacity'
*
* Specifies the total capacity of value partitions in a string table.
* Default Value: unbounded (-1)
*/
#define EXI_OPTION_VALUE_PARTITION_CAPACITY 0
#ifdef __cplusplus
}
#endif
#endif /* EXI_OPTIONS_H */
/**
* \file EXIOptions.h
* \brief EXI Options for the EXI Codec
*
*/
#ifndef EXI_OPTIONS_H
#define EXI_OPTIONS_H
#ifdef __cplusplus
extern "C" {
#endif
/** EXI alignment - Option bit-packed */
#define BIT_PACKED 1
/** EXI alignment - Option byte-packed */
#define BYTE_ALIGNMENT 2
/** EXI alignment */
/**
* \brief EXI Option 'alignment'
*
* The alignment option is used to control the alignment of event codes and content items.
* Default Value: bit-packed
*/
#define EXI_OPTION_ALIGNMENT BIT_PACKED
/**
* \brief EXI Option 'strict'
*
* Strict interpretation of schemas is used to achieve better compactness.
* Default Value: false
*/
#define EXI_OPTION_STRICT 0
/**
* \brief EXI Option 'valueMaxLength'
*
* Specifies the maximum string length of value content items to be
* considered for addition to the string table.
* Default Value: unbounded (-1)
*/
#define EXI_OPTION_VALUE_MAX_LENGTH -1
/**
* \brief EXI Option 'valuePartitionCapacity'
*
* Specifies the total capacity of value partitions in a string table.
* Default Value: unbounded (-1)
*/
#define EXI_OPTION_VALUE_PARTITION_CAPACITY 0
#ifdef __cplusplus
}
#endif
#endif /* EXI_OPTIONS_H */

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
@ -43,6 +43,7 @@ extern "C" {
#endif
#include <stdint.h>
#include <stdio.h>
#include "EXIConfig.h"
#if EXI_STREAM == FILE_STREAM
#include <stdio.h>
@ -157,11 +158,11 @@ typedef enum {
typedef struct {
#if EXI_STREAM == BYTE_ARRAY
/** byte array size */
uint16_t size;
size_t size;
/** byte array data */
uint8_t* data;
/** byte array next position in array */
uint16_t* pos;
size_t* pos;
#endif
#if EXI_STREAM == FILE_STREAM
/** file pointer */
@ -275,11 +276,11 @@ typedef uint32_t exi_string_character_t;
/** \brief Universal Character Set (UCS) strings */
typedef struct {
/** container size */
uint16_t size;
size_t size;
/** string character container */
exi_string_character_t* characters;
/** current string length == number of code-points, (len <= size) */
uint16_t len;
size_t len;
} exi_string_t;
@ -290,16 +291,16 @@ typedef struct {
/** miss entry */
exi_string_t miss;
/** (local) hit entry */
uint32_t localID;
size_t localID;
/** (global) hit entry */
uint32_t globalID;
size_t globalID;
} exi_string_value_t;
/** \brief Restricted Characeter Set */
typedef struct {
/** size */
uint16_t size;
size_t size;
/** rcs codepoints */
exi_string_character_t* characters;
/** character coding length (less than 256 characters) */
@ -310,11 +311,11 @@ typedef struct {
/** \brief Byte value container */
typedef struct {
/** bytes array size */
uint16_t size;
size_t size;
/** bytes array data container */
uint8_t* data;
/** bytes array length (len <= size) */
uint16_t len;
size_t len;
} exi_bytes_t;
@ -391,7 +392,7 @@ typedef struct {
/** list item type */
exi_datatype_t type;
/** number of items */
uint16_t len;
size_t len;
/* Special datatype: integer */
/* exi_integer_type_t intType;*/
/** Special datatype: datetime */
@ -402,9 +403,9 @@ typedef struct {
/** \brief Efficient qname */
typedef struct {
/** namespace URI ID*/
uint16_t namespaceURI;
size_t namespaceURI;
/** local name ID*/
uint16_t localPart;
size_t localPart;
} exi_eqname_t;
@ -422,7 +423,7 @@ typedef struct {
/** type */
exi_name_entry_type_t type;
/** entry ID */
uint16_t id;
size_t id;
/** entry string */
exi_string_t str;
} exi_name_entry_t;
@ -448,9 +449,9 @@ typedef struct {
/* URI and LocalName Entries */
typedef struct exiNameTablePrepopulated {
/* number of namespaces AND length name-partitions array */
uint16_t len;
size_t len;
/* number of localName entries divided by URI */
uint16_t * localNames;
size_t* localNames;
} exi_name_table_prepopulated_t;
#define EXI_MAXIMUM_NUMBER_OF_NAME_PARTITION_ENTRIES 25
@ -461,13 +462,13 @@ typedef enum {
typedef struct {
char* uri;
uint16_t uriID;
size_t uriID;
} exi_uri_partition_t;
typedef struct {
char* localName;
uint16_t localNameID;
uint16_t uriID;
size_t localNameID;
size_t uriID;
} exi_localname_partition_t;
typedef struct {
@ -487,16 +488,17 @@ typedef struct exiNameTableRuntime {
namePartitionsEntries[EXI_MAXIMUM_NUMBER_OF_NAME_PARTITION_ENTRIES];
/* uint16_t numberOfUsedNamePartitions; *//* initially zero */
/* added entries */
uint16_t addedUriEntries; /* initially zero */
uint16_t addedLocalNameEntries; /* initially zero */
size_t addedUriEntries; /* initially zero */
size_t addedLocalNameEntries; /* initially zero */
} exi_name_table_runtime_t;
/* StartTagContent grammar initially empty */
/* ElementContent grammar has EE per default */
typedef struct {
uint16_t qnameID;
uint16_t numberOfProductions;
size_t namespaceUriID;
size_t localNameID;
size_t numberOfProductions;
int hasXsiType; /* StartTagContent only */
int hasEE; /* ElementContentper default TRUE */
} exi_runtime_element_t;
@ -509,58 +511,60 @@ typedef struct {
/* ==================================== */
/* Value string table */
typedef struct exiValueStringTableEntry {
/** Qualified name ID */
uint16_t qnameID;
/** Qualified namespace URI */
size_t namespaceUriID;
/** Qualified localName */
size_t localNameID;
/** Local Value ID */
uint16_t localValueID;
size_t localValueID;
/** String */
exi_string_t str;
} exi_value_string_table_entry_t;
typedef struct exiValueStringTable {
/** maximum number of global string table entry size */
uint16_t size;
size_t size;
/** string table entry array container */
exi_value_string_table_entry_t* strs;
/** current number of string table entries (len <= size) */
uint16_t len;
size_t len;
} exi_value_string_table_t;
typedef struct {
/* typedef struct { */
/** number of global strings */
uint16_t numberOfGlobalStrings;
/* uint16_t numberOfGlobalStrings; */
/** size of local-names container */
uint16_t sizeLocalStrings;
/* uint16_t sizeLocalStrings; */
/** number of local strings container */
uint16_t* numberOfLocalStrings;
/* uint16_t* numberOfLocalStrings; */
/** string values */
exi_value_string_table_t* valueStringTable;
} exi_value_table_t;
/* exi_value_string_table_t* valueStringTable;
} exi_value_table_t;*/
typedef struct {
/** stack of grammar states */
int16_t grammarStack[EXI_ELEMENT_STACK_SIZE];
/** stack of grammar elements / qnameIDs */
uint16_t elementStack[EXI_ELEMENT_STACK_SIZE];
exi_eqname_t elementStack[EXI_ELEMENT_STACK_SIZE];
/** stack index for both stacks */
uint16_t stackIndex;
size_t stackIndex;
/** event-code */
uint32_t eventCode;
/** name table entries, pre-populated */
exi_name_table_prepopulated_t nameTablePrepopulated;
exi_name_table_prepopulated_t* nameTablePrepopulated;
/** name table entries, at runtime */
exi_name_table_runtime_t nameTableRuntime;
exi_name_table_runtime_t* nameTableRuntime;
/** next qname ID */
uint16_t nextQNameID;
size_t nextQNameID;
/** string table entries */
exi_value_table_t stringTable;
exi_value_string_table_t* stringTable;
/** runtime built-in element grammars - numbers */
uint16_t numberOfRuntimeGrammars;
size_t numberOfRuntimeGrammars;
/** runtime built-in element grammars */
exi_runtime_element_t runtimeGrammars[MAX_NUMBER_OF_RUNTIME_ELEMENTS * 2];
} exi_state_t;

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
@ -37,8 +37,8 @@
#include "MethodsBag.h"
/*#include "v2gEXICoder.h"*/
#ifndef ABSTRACT_ENCODER_CHANNEL_C
#define ABSTRACT_ENCODER_CHANNEL_C
#ifndef ENCODER_CHANNEL_C
#define ENCODER_CHANNEL_C
int encodeUnsignedInteger(bitstream_t* stream, exi_integer_t* iv) {
int errn = 0;
@ -359,158 +359,12 @@ int encodeString(bitstream_t* stream, exi_string_t* string) {
return errn;
}
static int _writeStringValueLocalHit(bitstream_t* stream, exi_state_t* state,
uint16_t qnameID, uint32_t localID) {
int errn;
uint16_t codingLength;
if(state->stringTable.sizeLocalStrings > qnameID) {
errn = exiGetCodingLength(state->stringTable.numberOfLocalStrings[qnameID],
&codingLength);
if (errn == 0) {
errn = encodeNBitUnsignedInteger(stream, codingLength, localID);
}
} else {
errn = EXI_ERROR_OUT_OF_BOUNDS;
}
return errn;
}
static int _writeStringValueGlobalHit(bitstream_t* stream, exi_state_t* state,
uint32_t globalID) {
int errn;
uint16_t codingLength;
errn = exiGetCodingLength(state->stringTable.numberOfGlobalStrings, &codingLength);
if (errn == 0) {
errn = encodeNBitUnsignedInteger(stream, codingLength, globalID);
}
return errn;
}
int encodeStringValue(bitstream_t* stream, exi_state_t* state, uint16_t qnameID,
exi_string_value_t* string) {
int errn;
switch (string->type) {
case EXI_STRING_VALUE_LOCAL_HIT:
errn = encodeUnsignedInteger32(stream, 0);
if (errn == 0) {
errn = _writeStringValueLocalHit(stream, state, qnameID,
string->localID);
}
break;
case EXI_STRING_VALUE_GLOBAL_HIT:
errn = encodeUnsignedInteger32(stream, 1);
if (errn == 0) {
errn = _writeStringValueGlobalHit(stream, state, string->globalID);
}
break;
case EXI_STRING_VALUE_MISS:
/* encode string as string table miss */
errn = encodeUnsignedInteger32(stream, (uint32_t)(string->miss.len + 2));
if (errn == 0) {
errn = encodeCharacters(stream, string->miss.characters,
string->miss.len);
if (errn == 0) {
#if EXI_OPTION_VALUE_PARTITION_CAPACITY != 0
#if EXI_OPTION_VALUE_MAX_LENGTH != 0
/* If length L is greater than zero the string S is added */
if (string->miss.len > 0) {
/* After encoding the string value, it is added to both the
* associated "local" value string table partition and the global
* value string table partition */
#if EXI_OPTION_VALUE_MAX_LENGTH < 0
errn = exiAddStringValue(&state->stringTable, &(string->miss), qnameID);
# else /* EXI_OPTION_VALUE_MAX_LENGTH < 0 */
if (string->miss.len <= EXI_OPTION_VALUE_MAX_LENGTH) {
errn = exiAddStringValue(&state->stringTable, &(string->miss),
qnameID);
}
#endif /* EXI_OPTION_VALUE_MAX_LENGTH < 0 */
}
#endif /* EXI_OPTION_VALUE_MAX_LENGTH != 0 */
#endif /* EXI_OPTION_VALUE_PARTITION_CAPACITY != 0 */
}
}
break;
default:
errn = EXI_UNSUPPORTED_STRING_VALUE_TYPE;
break;
}
return errn;
}
int encodeRCSStringValue(bitstream_t* stream, exi_state_t* state,
uint16_t qnameID, exi_rcs_t* rcs, exi_string_value_t* string) {
unsigned int i;
int errn;
uint32_t k;
switch (string->type) {
case EXI_STRING_VALUE_LOCAL_HIT:
errn = encodeUnsignedInteger32(stream, 0);
if (errn == 0) {
errn = _writeStringValueLocalHit(stream, state, qnameID,
string->localID);
}
break;
case EXI_STRING_VALUE_GLOBAL_HIT:
errn = encodeUnsignedInteger32(stream, 1);
if (errn == 0) {
errn = _writeStringValueGlobalHit(stream, state, string->globalID);
}
break;
case EXI_STRING_VALUE_MISS:
/* encode string as string table miss */
errn = encodeUnsignedInteger32(stream, (uint32_t)(string->miss.len + 2));
if (errn == 0) {
for (i = 0; i < string->miss.len && errn == 0; i++) {
for (k = 0; k < rcs->size && errn == 0; k++) {
if (rcs->characters[k] == string->miss.characters[i]) {
errn = encodeNBitUnsignedInteger(stream, rcs->codingLength,
k);
break; /* break inner for loop */
}
}
}
#if EXI_OPTION_VALUE_PARTITION_CAPACITY != 0
#if EXI_OPTION_VALUE_MAX_LENGTH != 0
/* If length L is greater than zero the string S is added */
if (errn == 0 && string->miss.len > 0) {
/* After encoding the string value, it is added to both the
* associated "local" value string table partition and the global
* value string table partition */
#if EXI_OPTION_VALUE_MAX_LENGTH < 0
errn = exiAddStringValue(&state->stringTable, &(string->miss), qnameID);
#else /* EXI_OPTION_VALUE_MAX_LENGTH < 0 */
if (string->miss.len <= EXI_OPTION_VALUE_MAX_LENGTH) {
errn = exiAddStringValue(&state->stringTable, &(string->miss),
qnameID);
}
#endif /* EXI_OPTION_VALUE_MAX_LENGTH < 0 */
}
#endif /* EXI_OPTION_VALUE_MAX_LENGTH != 0 */
#endif /* EXI_OPTION_VALUE_PARTITION_CAPACITY != 0 */
}
break;
default:
errn = EXI_UNSUPPORTED_STRING_VALUE_TYPE;
break;
}
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, exi_string_character_t* chars, uint16_t len) {
int encodeCharacters(bitstream_t* stream, exi_string_character_t* chars, size_t len) {
unsigned int i;
int errn = 0;
for (i = 0; i < len && errn == 0; i++) {
@ -525,22 +379,22 @@ int encodeCharacters(bitstream_t* stream, exi_string_character_t* chars, uint16_
}
int encodeRCSCharacters(bitstream_t* stream, exi_string_character_t* chars, uint16_t len, uint16_t rcsCodeLength, uint16_t rcsSize, const exi_string_character_t rcsSet[]) {
int encodeRCSCharacters(bitstream_t* stream, exi_string_character_t* chars, size_t len, size_t rcsCodeLength, size_t rcsSize, const exi_string_character_t rcsSet[]) {
unsigned int i;
int k;
unsigned int k;
int errn = 0;
int rcsCode = -1;
size_t rcsCode = SIZE_MAX;
for (i = 0; i < len && errn == 0; i++) {
/* try to find short code */
rcsCode = -1;
for(k=0; k<rcsSize && rcsCode < 0; k++) {
rcsCode = SIZE_MAX;
for(k=0; k<rcsSize && rcsCode == SIZE_MAX; k++) {
if(rcsSet[k] == chars[i]) {
rcsCode = k;
}
}
if( rcsCode < 0) {
if( rcsCode == SIZE_MAX) {
/* RCS mis-match */
errn = encodeNBitUnsignedInteger(stream, rcsCodeLength, rcsSize);
#if STRING_REPRESENTATION == STRING_REPRESENTATION_ASCII
@ -571,7 +425,7 @@ int encodeBinary(bitstream_t* stream, exi_bytes_t* bytes) {
return errn;
}
int encodeBytes(bitstream_t* stream, uint8_t* data, uint16_t len) {
int encodeBytes(bitstream_t* stream, uint8_t* data, size_t len) {
unsigned int i;
int errn = 0;
@ -649,5 +503,115 @@ int encodeDateTime(bitstream_t* stream, exi_datetime_t* datetime) {
return errn;
}
int encode(bitstream_t* stream, uint8_t b) {
#if EXI_OPTION_ALIGNMENT == BIT_PACKED
return writeBits(stream, 8, b);
#endif /* EXI_OPTION_ALIGNMENT == BIT_PACKED */
#if EXI_OPTION_ALIGNMENT == BYTE_ALIGNMENT
int errn = 0;
#if EXI_STREAM == BYTE_ARRAY
if ( (*stream->pos) < stream->size ) {
stream->data[(*stream->pos)++] = b;
} else {
errn = EXI_ERROR_OUTPUT_STREAM_EOF;
}
#endif /* EXI_STREAM == BYTE_ARRAY */
#if EXI_STREAM == FILE_STREAM
if ( putc(b, stream->file) == EOF ) {
errn = EXI_ERROR_OUTPUT_STREAM_EOF;
}
#endif /* EXI_STREAM == FILE_STREAM */
return errn;
#endif /* EXI_OPTION_ALIGNMENT == BYTE_ALIGNMENT */
}
/**
* 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) {
#if EXI_OPTION_ALIGNMENT == BIT_PACKED
uint8_t val = b ? 1 : 0;
return writeBits(stream, 1, val);
#endif /* EXI_OPTION_ALIGNMENT == BIT_PACKED */
#if EXI_OPTION_ALIGNMENT == BYTE_ALIGNMENT
uint8_t val = b ? 1 : 0;
return encode(stream, val);
#endif /* EXI_OPTION_ALIGNMENT == BYTE_ALIGNMENT */
}
/**
* 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, uint32_t val) {
#if EXI_OPTION_ALIGNMENT == BIT_PACKED
int errn = 0;
if (nbits > 0) {
errn = writeBits(stream, nbits, val);
}
return errn;
#endif /* EXI_OPTION_ALIGNMENT == BIT_PACKED */
#if EXI_OPTION_ALIGNMENT == BYTE_ALIGNMENT
int errn = 0;
if (nbits > 0) {
if (nbits < 9) {
/* 1 byte */
errn = encode(stream, val & 0xff);
} else if (nbits < 17) {
/* 2 bytes */
errn = encode(stream, val & 0x00ff);
if(errn == 0) {
errn = encode(stream, (uint8_t)((val & 0xff00) >> 8));
}
} else if (nbits < 25) {
/* 3 bytes */
errn = encode(stream, val & 0x0000ff);
if(errn == 0) {
errn = encode(stream, (uint8_t)((val & 0x00ff00) >> 8));
if(errn == 0) {
errn = encode(stream, (uint8_t)((val & 0xff0000) >> 16));
}
}
} else if (nbits < 33) {
/* 4 bytes */
errn = encode(stream, val & 0x000000ff);
if(errn == 0) {
errn = encode(stream, (uint8_t)((val & 0x0000ff00) >> 8));
if(errn == 0) {
errn = encode(stream, (uint8_t)((val & 0x00ff0000) >> 16));
if(errn == 0) {
errn = encode(stream, (uint8_t)((val & 0xff000000) >> 24));
}
}
}
} else {
/* TODO Currently not more than 4 Bytes allowed for NBitUnsignedInteger */
errn = EXI_UNSUPPORTED_NBIT_INTEGER_LENGTH;
}
}
return errn;
#endif /* EXI_OPTION_ALIGNMENT == BYTE_ALIGNMENT */
}
/**
* Flush underlying output stream.
*/
int encodeFinish(bitstream_t* stream) {
#if EXI_OPTION_ALIGNMENT == BIT_PACKED
#endif /* EXI_OPTION_ALIGNMENT == BIT_PACKED */
return flush(stream);
#if EXI_OPTION_ALIGNMENT == BYTE_ALIGNMENT
/* no pending bits in byte-aligned mode */
return 0;
#endif /* EXI_OPTION_ALIGNMENT == BYTE_ALIGNMENT */
}
#endif

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
@ -81,7 +81,7 @@ int encodeBoolean(bitstream_t* stream, int b);
* \return Error-Code <> 0
*
*/
int encodeNBitUnsignedInteger(bitstream_t* stream, uint16_t nbits, uint32_t val);
int encodeNBitUnsignedInteger(bitstream_t* stream, size_t nbits, uint32_t val);
/**
@ -267,13 +267,14 @@ int encodeString(bitstream_t* stream, exi_string_t* string);
* in the sense of string tables
*
* \param stream Output Stream
* \param state Codec state
* \param qnameID Qualified Name ID
* \param stringTable String Table
* \param namespaceUriID Qualified Namespace ID
* \param localNameID Qualified LocalName ID
* \param string String value
* \return Error-Code <> 0
*
*/
int encodeStringValue(bitstream_t* stream, exi_state_t* state, uint16_t qnameID,
int encodeStringValue(bitstream_t* stream, exi_value_string_table_t* stringTable, size_t namespaceUriID, size_t localNameID,
exi_string_value_t* string);
@ -284,15 +285,16 @@ int encodeStringValue(bitstream_t* stream, exi_state_t* state, uint16_t qnameID,
* in the sense of string tables
*
* \param stream Output Stream
* \param state Codec state
* \param qnameID Qualified Name ID
* \param StringTable StringTable
* \param namespaceUriID Qualified Namespace ID
* \param localNameID Qualified LocalName ID
* \param rcs Restricted character set
* \param string String value
* \return Error-Code <> 0
*
*/
int encodeRCSStringValue(bitstream_t* stream, exi_state_t* state,
uint16_t qnameID, exi_rcs_t* rcs, exi_string_value_t* string);
int encodeRCSStringValue(bitstream_t* stream, exi_value_string_table_t* stringTable,
size_t namespaceUriID, size_t localNameID, exi_rcs_t* rcs, exi_string_value_t* string);
/**
@ -308,7 +310,7 @@ int encodeRCSStringValue(bitstream_t* stream, exi_state_t* state,
* \return Error-Code <> 0
*
*/
int encodeCharacters(bitstream_t* stream, exi_string_character_t* chars, uint16_t len);
int encodeCharacters(bitstream_t* stream, exi_string_character_t* chars, size_t len);
/**
@ -327,7 +329,7 @@ int encodeCharacters(bitstream_t* stream, exi_string_character_t* chars, uint16_
* \return Error-Code <> 0
*
*/
int encodeRCSCharacters(bitstream_t* stream, exi_string_character_t* chars, uint16_t len, uint16_t rcsCodeLength, uint16_t rcsSize, const exi_string_character_t rcsSet[]);
int encodeRCSCharacters(bitstream_t* stream, exi_string_character_t* chars, size_t len, size_t rcsCodeLength, size_t rcsSize, const exi_string_character_t rcsSet[]);
@ -355,7 +357,7 @@ int encodeBinary(bitstream_t* stream, exi_bytes_t* bytes);
* \return Error-Code <> 0
*
*/
int encodeBytes(bitstream_t* stream, uint8_t* data, uint16_t len);
int encodeBytes(bitstream_t* stream, uint8_t* data, size_t len);
/**
* \brief Encode datetime

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
@ -38,7 +38,7 @@
static const uint16_t smallLengths[] = { 0, 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4,
4, 4, 4 };
int exiGetCodingLength(uint16_t characteristics, uint16_t* codingLength) {
int exiGetCodingLength(size_t characteristics, size_t* codingLength) {
/* Note: we could use range expressions in switch statements but those are non-standard */
/* e.g., case 1 ... 5: */
int errn = 0;

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
@ -41,7 +41,7 @@
#include <stdint.h>
#include <stddef.h>
/**
* \brief Returns the number of bits to identify the characteristics.
@ -51,7 +51,7 @@
* \return Error-Code <> 0
*
*/
int exiGetCodingLength(uint16_t characteristics, uint16_t* codingLength);
int exiGetCodingLength(size_t characteristics, size_t* codingLength);
/**

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because one or more lines are too long

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
@ -50,10 +50,10 @@ extern "C" {
#include "v2gEXIDatatypes.h"
int decode_v2gExiDocument(bitstream_t* stream, struct v2gEXIDocument* exiDoc);
#if DEPLOY_ISO_CODEC_FRAGMENT == SUPPORT_YES
int decode_v2gExiFragment(bitstream_t* stream, struct v2gEXIFragment* exiFrag);
#endif /* DEPLOY_ISO_CODEC_FRAGMENT */
#endif /* DEPLOY_ISO_CODEC_FRAGMENT */
#endif /* DEPLOY_ISO_CODEC */

File diff suppressed because one or more lines are too long

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 2017-03-02
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
@ -51,10 +51,10 @@ extern "C" {
int encode_v2gExiDocument(bitstream_t* stream, struct v2gEXIDocument* exiDoc);
#if DEPLOY_ISO_CODEC_FRAGMENT == SUPPORT_YES
int encode_v2gExiFragment(bitstream_t* stream, struct v2gEXIFragment* exiFrag);
#endif /* DEPLOY_ISO_CODEC_FRAGMENT */
int encode_v2gExiFragment(bitstream_t* stream, struct v2gEXIFragment* exiFrag);
#endif /* DEPLOY_ISO_CODEC_FRAGMENT */
#endif /* DEPLOY_ISO_CODEC */

View file

@ -470,13 +470,10 @@ static int decode_dinCanonicalizationMethodType(bitstream_t* stream, struct dinC
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinCanonicalizationMethodType->Algorithm.charactersLen);
if (errn == 0) {
errn = (dinCanonicalizationMethodType->Algorithm.charactersLen - 2) <= dinCanonicalizationMethodType_Algorithm_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinCanonicalizationMethodType->Algorithm.charactersLen >= 2) {
dinCanonicalizationMethodType->Algorithm.charactersLen = (uint16_t)(dinCanonicalizationMethodType->Algorithm.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinCanonicalizationMethodType->Algorithm.charactersLen, dinCanonicalizationMethodType->Algorithm.characters);
errn = decodeCharacters(stream, dinCanonicalizationMethodType->Algorithm.charactersLen, dinCanonicalizationMethodType->Algorithm.characters, dinCanonicalizationMethodType_Algorithm_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -1519,13 +1516,10 @@ static int decode_dinManifestType(bitstream_t* stream, struct dinManifestType* d
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinManifestType->Id.charactersLen);
if (errn == 0) {
errn = (dinManifestType->Id.charactersLen - 2) <= dinManifestType_Id_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinManifestType->Id.charactersLen >= 2) {
dinManifestType->Id.charactersLen = (uint16_t)(dinManifestType->Id.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinManifestType->Id.charactersLen, dinManifestType->Id.characters);
errn = decodeCharacters(stream, dinManifestType->Id.charactersLen, dinManifestType->Id.characters, dinManifestType_Id_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -1965,13 +1959,10 @@ static int decode_dinDigestMethodType(bitstream_t* stream, struct dinDigestMetho
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinDigestMethodType->Algorithm.charactersLen);
if (errn == 0) {
errn = (dinDigestMethodType->Algorithm.charactersLen - 2) <= dinDigestMethodType_Algorithm_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinDigestMethodType->Algorithm.charactersLen >= 2) {
dinDigestMethodType->Algorithm.charactersLen = (uint16_t)(dinDigestMethodType->Algorithm.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinDigestMethodType->Algorithm.charactersLen, dinDigestMethodType->Algorithm.characters);
errn = decodeCharacters(stream, dinDigestMethodType->Algorithm.charactersLen, dinDigestMethodType->Algorithm.characters, dinDigestMethodType_Algorithm_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -2058,13 +2049,10 @@ static int decode_dinSalesTariffType(bitstream_t* stream, struct dinSalesTariffT
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinSalesTariffType->Id.charactersLen);
if (errn == 0) {
errn = (dinSalesTariffType->Id.charactersLen - 2) <= dinSalesTariffType_Id_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinSalesTariffType->Id.charactersLen >= 2) {
dinSalesTariffType->Id.charactersLen = (uint16_t)(dinSalesTariffType->Id.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinSalesTariffType->Id.charactersLen, dinSalesTariffType->Id.characters);
errn = decodeCharacters(stream, dinSalesTariffType->Id.charactersLen, dinSalesTariffType->Id.characters, dinSalesTariffType_Id_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -2121,13 +2109,10 @@ static int decode_dinSalesTariffType(bitstream_t* stream, struct dinSalesTariffT
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinSalesTariffType->SalesTariffDescription.charactersLen);
if (errn == 0) {
errn = (dinSalesTariffType->SalesTariffDescription.charactersLen - 2) <= dinSalesTariffType_SalesTariffDescription_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinSalesTariffType->SalesTariffDescription.charactersLen >= 2) {
dinSalesTariffType->SalesTariffDescription.charactersLen = (uint16_t)(dinSalesTariffType->SalesTariffDescription.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinSalesTariffType->SalesTariffDescription.charactersLen, dinSalesTariffType->SalesTariffDescription.characters);
errn = decodeCharacters(stream, dinSalesTariffType->SalesTariffDescription.charactersLen, dinSalesTariffType->SalesTariffDescription.characters, dinSalesTariffType_SalesTariffDescription_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -2582,13 +2567,10 @@ static int decode_dinSignaturePropertiesType(bitstream_t* stream, struct dinSign
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinSignaturePropertiesType->Id.charactersLen);
if (errn == 0) {
errn = (dinSignaturePropertiesType->Id.charactersLen - 2) <= dinSignaturePropertiesType_Id_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinSignaturePropertiesType->Id.charactersLen >= 2) {
dinSignaturePropertiesType->Id.charactersLen = (uint16_t)(dinSignaturePropertiesType->Id.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinSignaturePropertiesType->Id.charactersLen, dinSignaturePropertiesType->Id.characters);
errn = decodeCharacters(stream, dinSignaturePropertiesType->Id.charactersLen, dinSignaturePropertiesType->Id.characters, dinSignaturePropertiesType_Id_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -3016,13 +2998,10 @@ static int decode_dinNotificationType(bitstream_t* stream, struct dinNotificatio
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinNotificationType->FaultMsg.charactersLen);
if (errn == 0) {
errn = (dinNotificationType->FaultMsg.charactersLen - 2) <= dinNotificationType_FaultMsg_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinNotificationType->FaultMsg.charactersLen >= 2) {
dinNotificationType->FaultMsg.charactersLen = (uint16_t)(dinNotificationType->FaultMsg.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinNotificationType->FaultMsg.charactersLen, dinNotificationType->FaultMsg.characters);
errn = decodeCharacters(stream, dinNotificationType->FaultMsg.charactersLen, dinNotificationType->FaultMsg.characters, dinNotificationType_FaultMsg_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -3096,13 +3075,10 @@ static int decode_dinContractAuthenticationReqType(bitstream_t* stream, struct d
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinContractAuthenticationReqType->Id.charactersLen);
if (errn == 0) {
errn = (dinContractAuthenticationReqType->Id.charactersLen - 2) <= dinContractAuthenticationReqType_Id_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinContractAuthenticationReqType->Id.charactersLen >= 2) {
dinContractAuthenticationReqType->Id.charactersLen = (uint16_t)(dinContractAuthenticationReqType->Id.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinContractAuthenticationReqType->Id.charactersLen, dinContractAuthenticationReqType->Id.characters);
errn = decodeCharacters(stream, dinContractAuthenticationReqType->Id.charactersLen, dinContractAuthenticationReqType->Id.characters, dinContractAuthenticationReqType_Id_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -3117,13 +3093,10 @@ static int decode_dinContractAuthenticationReqType(bitstream_t* stream, struct d
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinContractAuthenticationReqType->GenChallenge.charactersLen);
if (errn == 0) {
errn = (dinContractAuthenticationReqType->GenChallenge.charactersLen - 2) <= dinContractAuthenticationReqType_GenChallenge_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinContractAuthenticationReqType->GenChallenge.charactersLen >= 2) {
dinContractAuthenticationReqType->GenChallenge.charactersLen = (uint16_t)(dinContractAuthenticationReqType->GenChallenge.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinContractAuthenticationReqType->GenChallenge.charactersLen, dinContractAuthenticationReqType->GenChallenge.characters);
errn = decodeCharacters(stream, dinContractAuthenticationReqType->GenChallenge.charactersLen, dinContractAuthenticationReqType->GenChallenge.characters, dinContractAuthenticationReqType_GenChallenge_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -3166,13 +3139,10 @@ static int decode_dinContractAuthenticationReqType(bitstream_t* stream, struct d
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinContractAuthenticationReqType->GenChallenge.charactersLen);
if (errn == 0) {
errn = (dinContractAuthenticationReqType->GenChallenge.charactersLen - 2) <= dinContractAuthenticationReqType_GenChallenge_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinContractAuthenticationReqType->GenChallenge.charactersLen >= 2) {
dinContractAuthenticationReqType->GenChallenge.charactersLen = (uint16_t)(dinContractAuthenticationReqType->GenChallenge.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinContractAuthenticationReqType->GenChallenge.charactersLen, dinContractAuthenticationReqType->GenChallenge.characters);
errn = decodeCharacters(stream, dinContractAuthenticationReqType->GenChallenge.charactersLen, dinContractAuthenticationReqType->GenChallenge.characters, dinContractAuthenticationReqType_GenChallenge_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -4166,13 +4136,10 @@ static int decode_dinSignatureType(bitstream_t* stream, struct dinSignatureType*
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinSignatureType->Id.charactersLen);
if (errn == 0) {
errn = (dinSignatureType->Id.charactersLen - 2) <= dinSignatureType_Id_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinSignatureType->Id.charactersLen >= 2) {
dinSignatureType->Id.charactersLen = (uint16_t)(dinSignatureType->Id.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinSignatureType->Id.charactersLen, dinSignatureType->Id.characters);
errn = decodeCharacters(stream, dinSignatureType->Id.charactersLen, dinSignatureType->Id.characters, dinSignatureType_Id_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -4399,13 +4366,10 @@ static int decode_dinParameterType(bitstream_t* stream, struct dinParameterType*
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinParameterType->Name.charactersLen);
if (errn == 0) {
errn = (dinParameterType->Name.charactersLen - 2) <= dinParameterType_Name_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinParameterType->Name.charactersLen >= 2) {
dinParameterType->Name.charactersLen = (uint16_t)(dinParameterType->Name.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinParameterType->Name.charactersLen, dinParameterType->Name.characters);
errn = decodeCharacters(stream, dinParameterType->Name.charactersLen, dinParameterType->Name.characters, dinParameterType_Name_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -4540,13 +4504,10 @@ static int decode_dinParameterType(bitstream_t* stream, struct dinParameterType*
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinParameterType->stringValue.charactersLen);
if (errn == 0) {
errn = (dinParameterType->stringValue.charactersLen - 2) <= dinParameterType_stringValue_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinParameterType->stringValue.charactersLen >= 2) {
dinParameterType->stringValue.charactersLen = (uint16_t)(dinParameterType->stringValue.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinParameterType->stringValue.charactersLen, dinParameterType->stringValue.characters);
errn = decodeCharacters(stream, dinParameterType->stringValue.charactersLen, dinParameterType->stringValue.characters, dinParameterType_stringValue_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -4616,13 +4577,10 @@ static int decode_dinSignaturePropertyType(bitstream_t* stream, struct dinSignat
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinSignaturePropertyType->Id.charactersLen);
if (errn == 0) {
errn = (dinSignaturePropertyType->Id.charactersLen - 2) <= dinSignaturePropertyType_Id_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinSignaturePropertyType->Id.charactersLen >= 2) {
dinSignaturePropertyType->Id.charactersLen = (uint16_t)(dinSignaturePropertyType->Id.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinSignaturePropertyType->Id.charactersLen, dinSignaturePropertyType->Id.characters);
errn = decodeCharacters(stream, dinSignaturePropertyType->Id.charactersLen, dinSignaturePropertyType->Id.characters, dinSignaturePropertyType_Id_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -4633,13 +4591,10 @@ static int decode_dinSignaturePropertyType(bitstream_t* stream, struct dinSignat
break;
case 1:
errn = decodeUnsignedInteger16(stream, &dinSignaturePropertyType->Target.charactersLen);
if (errn == 0) {
errn = (dinSignaturePropertyType->Target.charactersLen - 2) <= dinSignaturePropertyType_Target_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinSignaturePropertyType->Target.charactersLen >= 2) {
dinSignaturePropertyType->Target.charactersLen = (uint16_t)(dinSignaturePropertyType->Target.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinSignaturePropertyType->Target.charactersLen, dinSignaturePropertyType->Target.characters);
errn = decodeCharacters(stream, dinSignaturePropertyType->Target.charactersLen, dinSignaturePropertyType->Target.characters, dinSignaturePropertyType_Target_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -4660,13 +4615,10 @@ static int decode_dinSignaturePropertyType(bitstream_t* stream, struct dinSignat
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinSignaturePropertyType->Target.charactersLen);
if (errn == 0) {
errn = (dinSignaturePropertyType->Target.charactersLen - 2) <= dinSignaturePropertyType_Target_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinSignaturePropertyType->Target.charactersLen >= 2) {
dinSignaturePropertyType->Target.charactersLen = (uint16_t)(dinSignaturePropertyType->Target.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinSignaturePropertyType->Target.charactersLen, dinSignaturePropertyType->Target.characters);
errn = decodeCharacters(stream, dinSignaturePropertyType->Target.charactersLen, dinSignaturePropertyType->Target.characters, dinSignaturePropertyType_Target_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -5808,13 +5760,10 @@ static int decode_dinCertificateInstallationReqType(bitstream_t* stream, struct
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinCertificateInstallationReqType->Id.charactersLen);
if (errn == 0) {
errn = (dinCertificateInstallationReqType->Id.charactersLen - 2) <= dinCertificateInstallationReqType_Id_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinCertificateInstallationReqType->Id.charactersLen >= 2) {
dinCertificateInstallationReqType->Id.charactersLen = (uint16_t)(dinCertificateInstallationReqType->Id.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinCertificateInstallationReqType->Id.charactersLen, dinCertificateInstallationReqType->Id.characters);
errn = decodeCharacters(stream, dinCertificateInstallationReqType->Id.charactersLen, dinCertificateInstallationReqType->Id.characters, dinCertificateInstallationReqType_Id_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -5989,13 +5938,10 @@ static int decode_dinTransformType(bitstream_t* stream, struct dinTransformType*
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinTransformType->Algorithm.charactersLen);
if (errn == 0) {
errn = (dinTransformType->Algorithm.charactersLen - 2) <= dinTransformType_Algorithm_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinTransformType->Algorithm.charactersLen >= 2) {
dinTransformType->Algorithm.charactersLen = (uint16_t)(dinTransformType->Algorithm.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinTransformType->Algorithm.charactersLen, dinTransformType->Algorithm.characters);
errn = decodeCharacters(stream, dinTransformType->Algorithm.charactersLen, dinTransformType->Algorithm.characters, dinTransformType_Algorithm_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -6021,13 +5967,10 @@ static int decode_dinTransformType(bitstream_t* stream, struct dinTransformType*
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinTransformType->XPath.array[dinTransformType->XPath.arrayLen].charactersLen);
if (errn == 0) {
errn = (dinTransformType->XPath.array[dinTransformType->XPath.arrayLen].charactersLen - 2) <= dinTransformType_XPath_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinTransformType->XPath.array[dinTransformType->XPath.arrayLen].charactersLen >= 2) {
dinTransformType->XPath.array[dinTransformType->XPath.arrayLen].charactersLen = (uint16_t)(dinTransformType->XPath.array[dinTransformType->XPath.arrayLen].charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinTransformType->XPath.array[dinTransformType->XPath.arrayLen].charactersLen, dinTransformType->XPath.array[dinTransformType->XPath.arrayLen].characters);
errn = decodeCharacters(stream, dinTransformType->XPath.array[dinTransformType->XPath.arrayLen].charactersLen, dinTransformType->XPath.array[dinTransformType->XPath.arrayLen].characters, dinTransformType_XPath_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -6082,13 +6025,10 @@ static int decode_dinTransformType(bitstream_t* stream, struct dinTransformType*
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinTransformType->XPath.array[dinTransformType->XPath.arrayLen].charactersLen);
if (errn == 0) {
errn = (dinTransformType->XPath.array[dinTransformType->XPath.arrayLen].charactersLen - 2) <= dinTransformType_XPath_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinTransformType->XPath.array[dinTransformType->XPath.arrayLen].charactersLen >= 2) {
dinTransformType->XPath.array[dinTransformType->XPath.arrayLen].charactersLen = (uint16_t)(dinTransformType->XPath.array[dinTransformType->XPath.arrayLen].charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinTransformType->XPath.array[dinTransformType->XPath.arrayLen].charactersLen, dinTransformType->XPath.array[dinTransformType->XPath.arrayLen].characters);
errn = decodeCharacters(stream, dinTransformType->XPath.array[dinTransformType->XPath.arrayLen].charactersLen, dinTransformType->XPath.array[dinTransformType->XPath.arrayLen].characters, dinTransformType_XPath_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -6254,13 +6194,10 @@ static int decode_dinRetrievalMethodType(bitstream_t* stream, struct dinRetrieva
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinRetrievalMethodType->Type.charactersLen);
if (errn == 0) {
errn = (dinRetrievalMethodType->Type.charactersLen - 2) <= dinRetrievalMethodType_Type_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinRetrievalMethodType->Type.charactersLen >= 2) {
dinRetrievalMethodType->Type.charactersLen = (uint16_t)(dinRetrievalMethodType->Type.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinRetrievalMethodType->Type.charactersLen, dinRetrievalMethodType->Type.characters);
errn = decodeCharacters(stream, dinRetrievalMethodType->Type.charactersLen, dinRetrievalMethodType->Type.characters, dinRetrievalMethodType_Type_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -6271,13 +6208,10 @@ static int decode_dinRetrievalMethodType(bitstream_t* stream, struct dinRetrieva
break;
case 1:
errn = decodeUnsignedInteger16(stream, &dinRetrievalMethodType->URI.charactersLen);
if (errn == 0) {
errn = (dinRetrievalMethodType->URI.charactersLen - 2) <= dinRetrievalMethodType_URI_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinRetrievalMethodType->URI.charactersLen >= 2) {
dinRetrievalMethodType->URI.charactersLen = (uint16_t)(dinRetrievalMethodType->URI.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinRetrievalMethodType->URI.charactersLen, dinRetrievalMethodType->URI.characters);
errn = decodeCharacters(stream, dinRetrievalMethodType->URI.charactersLen, dinRetrievalMethodType->URI.characters, dinRetrievalMethodType_URI_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -6308,13 +6242,10 @@ static int decode_dinRetrievalMethodType(bitstream_t* stream, struct dinRetrieva
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinRetrievalMethodType->URI.charactersLen);
if (errn == 0) {
errn = (dinRetrievalMethodType->URI.charactersLen - 2) <= dinRetrievalMethodType_URI_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinRetrievalMethodType->URI.charactersLen >= 2) {
dinRetrievalMethodType->URI.charactersLen = (uint16_t)(dinRetrievalMethodType->URI.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinRetrievalMethodType->URI.charactersLen, dinRetrievalMethodType->URI.characters);
errn = decodeCharacters(stream, dinRetrievalMethodType->URI.charactersLen, dinRetrievalMethodType->URI.characters, dinRetrievalMethodType_URI_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -6644,13 +6575,10 @@ static int decode_dinReferenceType(bitstream_t* stream, struct dinReferenceType*
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinReferenceType->Id.charactersLen);
if (errn == 0) {
errn = (dinReferenceType->Id.charactersLen - 2) <= dinReferenceType_Id_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinReferenceType->Id.charactersLen >= 2) {
dinReferenceType->Id.charactersLen = (uint16_t)(dinReferenceType->Id.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinReferenceType->Id.charactersLen, dinReferenceType->Id.characters);
errn = decodeCharacters(stream, dinReferenceType->Id.charactersLen, dinReferenceType->Id.characters, dinReferenceType_Id_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -6661,13 +6589,10 @@ static int decode_dinReferenceType(bitstream_t* stream, struct dinReferenceType*
break;
case 1:
errn = decodeUnsignedInteger16(stream, &dinReferenceType->Type.charactersLen);
if (errn == 0) {
errn = (dinReferenceType->Type.charactersLen - 2) <= dinReferenceType_Type_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinReferenceType->Type.charactersLen >= 2) {
dinReferenceType->Type.charactersLen = (uint16_t)(dinReferenceType->Type.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinReferenceType->Type.charactersLen, dinReferenceType->Type.characters);
errn = decodeCharacters(stream, dinReferenceType->Type.charactersLen, dinReferenceType->Type.characters, dinReferenceType_Type_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -6678,13 +6603,10 @@ static int decode_dinReferenceType(bitstream_t* stream, struct dinReferenceType*
break;
case 2:
errn = decodeUnsignedInteger16(stream, &dinReferenceType->URI.charactersLen);
if (errn == 0) {
errn = (dinReferenceType->URI.charactersLen - 2) <= dinReferenceType_URI_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinReferenceType->URI.charactersLen >= 2) {
dinReferenceType->URI.charactersLen = (uint16_t)(dinReferenceType->URI.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinReferenceType->URI.charactersLen, dinReferenceType->URI.characters);
errn = decodeCharacters(stream, dinReferenceType->URI.charactersLen, dinReferenceType->URI.characters, dinReferenceType_URI_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -6715,13 +6637,10 @@ static int decode_dinReferenceType(bitstream_t* stream, struct dinReferenceType*
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinReferenceType->Type.charactersLen);
if (errn == 0) {
errn = (dinReferenceType->Type.charactersLen - 2) <= dinReferenceType_Type_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinReferenceType->Type.charactersLen >= 2) {
dinReferenceType->Type.charactersLen = (uint16_t)(dinReferenceType->Type.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinReferenceType->Type.charactersLen, dinReferenceType->Type.characters);
errn = decodeCharacters(stream, dinReferenceType->Type.charactersLen, dinReferenceType->Type.characters, dinReferenceType_Type_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -6732,13 +6651,10 @@ static int decode_dinReferenceType(bitstream_t* stream, struct dinReferenceType*
break;
case 1:
errn = decodeUnsignedInteger16(stream, &dinReferenceType->URI.charactersLen);
if (errn == 0) {
errn = (dinReferenceType->URI.charactersLen - 2) <= dinReferenceType_URI_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinReferenceType->URI.charactersLen >= 2) {
dinReferenceType->URI.charactersLen = (uint16_t)(dinReferenceType->URI.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinReferenceType->URI.charactersLen, dinReferenceType->URI.characters);
errn = decodeCharacters(stream, dinReferenceType->URI.charactersLen, dinReferenceType->URI.characters, dinReferenceType_URI_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -6769,13 +6685,10 @@ static int decode_dinReferenceType(bitstream_t* stream, struct dinReferenceType*
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinReferenceType->URI.charactersLen);
if (errn == 0) {
errn = (dinReferenceType->URI.charactersLen - 2) <= dinReferenceType_URI_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinReferenceType->URI.charactersLen >= 2) {
dinReferenceType->URI.charactersLen = (uint16_t)(dinReferenceType->URI.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinReferenceType->URI.charactersLen, dinReferenceType->URI.characters);
errn = decodeCharacters(stream, dinReferenceType->URI.charactersLen, dinReferenceType->URI.characters, dinReferenceType_URI_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -6982,13 +6895,10 @@ static int decode_dinObjectType(bitstream_t* stream, struct dinObjectType* dinOb
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinObjectType->Encoding.charactersLen);
if (errn == 0) {
errn = (dinObjectType->Encoding.charactersLen - 2) <= dinObjectType_Encoding_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinObjectType->Encoding.charactersLen >= 2) {
dinObjectType->Encoding.charactersLen = (uint16_t)(dinObjectType->Encoding.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinObjectType->Encoding.charactersLen, dinObjectType->Encoding.characters);
errn = decodeCharacters(stream, dinObjectType->Encoding.charactersLen, dinObjectType->Encoding.characters, dinObjectType_Encoding_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -6999,13 +6909,10 @@ static int decode_dinObjectType(bitstream_t* stream, struct dinObjectType* dinOb
break;
case 1:
errn = decodeUnsignedInteger16(stream, &dinObjectType->Id.charactersLen);
if (errn == 0) {
errn = (dinObjectType->Id.charactersLen - 2) <= dinObjectType_Id_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinObjectType->Id.charactersLen >= 2) {
dinObjectType->Id.charactersLen = (uint16_t)(dinObjectType->Id.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinObjectType->Id.charactersLen, dinObjectType->Id.characters);
errn = decodeCharacters(stream, dinObjectType->Id.charactersLen, dinObjectType->Id.characters, dinObjectType_Id_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -7016,13 +6923,10 @@ static int decode_dinObjectType(bitstream_t* stream, struct dinObjectType* dinOb
break;
case 2:
errn = decodeUnsignedInteger16(stream, &dinObjectType->MimeType.charactersLen);
if (errn == 0) {
errn = (dinObjectType->MimeType.charactersLen - 2) <= dinObjectType_MimeType_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinObjectType->MimeType.charactersLen >= 2) {
dinObjectType->MimeType.charactersLen = (uint16_t)(dinObjectType->MimeType.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinObjectType->MimeType.charactersLen, dinObjectType->MimeType.characters);
errn = decodeCharacters(stream, dinObjectType->MimeType.charactersLen, dinObjectType->MimeType.characters, dinObjectType_MimeType_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -7056,13 +6960,10 @@ static int decode_dinObjectType(bitstream_t* stream, struct dinObjectType* dinOb
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinObjectType->Id.charactersLen);
if (errn == 0) {
errn = (dinObjectType->Id.charactersLen - 2) <= dinObjectType_Id_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinObjectType->Id.charactersLen >= 2) {
dinObjectType->Id.charactersLen = (uint16_t)(dinObjectType->Id.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinObjectType->Id.charactersLen, dinObjectType->Id.characters);
errn = decodeCharacters(stream, dinObjectType->Id.charactersLen, dinObjectType->Id.characters, dinObjectType_Id_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -7073,13 +6974,10 @@ static int decode_dinObjectType(bitstream_t* stream, struct dinObjectType* dinOb
break;
case 1:
errn = decodeUnsignedInteger16(stream, &dinObjectType->MimeType.charactersLen);
if (errn == 0) {
errn = (dinObjectType->MimeType.charactersLen - 2) <= dinObjectType_MimeType_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinObjectType->MimeType.charactersLen >= 2) {
dinObjectType->MimeType.charactersLen = (uint16_t)(dinObjectType->MimeType.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinObjectType->MimeType.charactersLen, dinObjectType->MimeType.characters);
errn = decodeCharacters(stream, dinObjectType->MimeType.charactersLen, dinObjectType->MimeType.characters, dinObjectType_MimeType_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -7113,13 +7011,10 @@ static int decode_dinObjectType(bitstream_t* stream, struct dinObjectType* dinOb
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinObjectType->MimeType.charactersLen);
if (errn == 0) {
errn = (dinObjectType->MimeType.charactersLen - 2) <= dinObjectType_MimeType_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinObjectType->MimeType.charactersLen >= 2) {
dinObjectType->MimeType.charactersLen = (uint16_t)(dinObjectType->MimeType.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinObjectType->MimeType.charactersLen, dinObjectType->MimeType.characters);
errn = decodeCharacters(stream, dinObjectType->MimeType.charactersLen, dinObjectType->MimeType.characters, dinObjectType_MimeType_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -7219,13 +7114,10 @@ static int decode_dinSignatureValueType(bitstream_t* stream, struct dinSignature
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinSignatureValueType->Id.charactersLen);
if (errn == 0) {
errn = (dinSignatureValueType->Id.charactersLen - 2) <= dinSignatureValueType_Id_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinSignatureValueType->Id.charactersLen >= 2) {
dinSignatureValueType->Id.charactersLen = (uint16_t)(dinSignatureValueType->Id.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinSignatureValueType->Id.charactersLen, dinSignatureValueType->Id.characters);
errn = decodeCharacters(stream, dinSignatureValueType->Id.charactersLen, dinSignatureValueType->Id.characters, dinSignatureValueType_Id_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -7658,13 +7550,10 @@ static int decode_dinMeteringReceiptReqType(bitstream_t* stream, struct dinMeter
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinMeteringReceiptReqType->Id.charactersLen);
if (errn == 0) {
errn = (dinMeteringReceiptReqType->Id.charactersLen - 2) <= dinMeteringReceiptReqType_Id_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinMeteringReceiptReqType->Id.charactersLen >= 2) {
dinMeteringReceiptReqType->Id.charactersLen = (uint16_t)(dinMeteringReceiptReqType->Id.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinMeteringReceiptReqType->Id.charactersLen, dinMeteringReceiptReqType->Id.characters);
errn = decodeCharacters(stream, dinMeteringReceiptReqType->Id.charactersLen, dinMeteringReceiptReqType->Id.characters, dinMeteringReceiptReqType_Id_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -8541,13 +8430,10 @@ static int decode_dinKeyInfoType(bitstream_t* stream, struct dinKeyInfoType* din
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinKeyInfoType->Id.charactersLen);
if (errn == 0) {
errn = (dinKeyInfoType->Id.charactersLen - 2) <= dinKeyInfoType_Id_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinKeyInfoType->Id.charactersLen >= 2) {
dinKeyInfoType->Id.charactersLen = (uint16_t)(dinKeyInfoType->Id.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinKeyInfoType->Id.charactersLen, dinKeyInfoType->Id.characters);
errn = decodeCharacters(stream, dinKeyInfoType->Id.charactersLen, dinKeyInfoType->Id.characters, dinKeyInfoType_Id_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -8563,13 +8449,10 @@ static int decode_dinKeyInfoType(bitstream_t* stream, struct dinKeyInfoType* din
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen);
if (errn == 0) {
errn = (dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen - 2) <= dinKeyInfoType_KeyName_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen >= 2) {
dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen = (uint16_t)(dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen, dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].characters);
errn = decodeCharacters(stream, dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen, dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].characters, dinKeyInfoType_KeyName_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -8641,13 +8524,10 @@ static int decode_dinKeyInfoType(bitstream_t* stream, struct dinKeyInfoType* din
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen);
if (errn == 0) {
errn = (dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen - 2) <= dinKeyInfoType_MgmtData_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen >= 2) {
dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen = (uint16_t)(dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen, dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].characters);
errn = decodeCharacters(stream, dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen, dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].characters, dinKeyInfoType_MgmtData_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -8698,13 +8578,10 @@ static int decode_dinKeyInfoType(bitstream_t* stream, struct dinKeyInfoType* din
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen);
if (errn == 0) {
errn = (dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen - 2) <= dinKeyInfoType_KeyName_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen >= 2) {
dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen = (uint16_t)(dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen, dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].characters);
errn = decodeCharacters(stream, dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen, dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].characters, dinKeyInfoType_KeyName_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -8776,13 +8653,10 @@ static int decode_dinKeyInfoType(bitstream_t* stream, struct dinKeyInfoType* din
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen);
if (errn == 0) {
errn = (dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen - 2) <= dinKeyInfoType_MgmtData_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen >= 2) {
dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen = (uint16_t)(dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen, dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].characters);
errn = decodeCharacters(stream, dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen, dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].characters, dinKeyInfoType_MgmtData_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -8833,13 +8707,10 @@ static int decode_dinKeyInfoType(bitstream_t* stream, struct dinKeyInfoType* din
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen);
if (errn == 0) {
errn = (dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen - 2) <= dinKeyInfoType_KeyName_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen >= 2) {
dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen = (uint16_t)(dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen, dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].characters);
errn = decodeCharacters(stream, dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen, dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].characters, dinKeyInfoType_KeyName_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -8911,13 +8782,10 @@ static int decode_dinKeyInfoType(bitstream_t* stream, struct dinKeyInfoType* din
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen);
if (errn == 0) {
errn = (dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen - 2) <= dinKeyInfoType_MgmtData_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen >= 2) {
dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen = (uint16_t)(dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen, dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].characters);
errn = decodeCharacters(stream, dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen, dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].characters, dinKeyInfoType_MgmtData_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -8972,13 +8840,10 @@ static int decode_dinKeyInfoType(bitstream_t* stream, struct dinKeyInfoType* din
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen);
if (errn == 0) {
errn = (dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen - 2) <= dinKeyInfoType_KeyName_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen >= 2) {
dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen = (uint16_t)(dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen, dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].characters);
errn = decodeCharacters(stream, dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].charactersLen, dinKeyInfoType->KeyName.array[dinKeyInfoType->KeyName.arrayLen].characters, dinKeyInfoType_KeyName_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -9050,13 +8915,10 @@ static int decode_dinKeyInfoType(bitstream_t* stream, struct dinKeyInfoType* din
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen);
if (errn == 0) {
errn = (dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen - 2) <= dinKeyInfoType_MgmtData_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen >= 2) {
dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen = (uint16_t)(dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen, dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].characters);
errn = decodeCharacters(stream, dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].charactersLen, dinKeyInfoType->MgmtData.array[dinKeyInfoType->MgmtData.arrayLen].characters, dinKeyInfoType_MgmtData_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -9378,13 +9240,10 @@ static int decode_dinPaymentDetailsResType(bitstream_t* stream, struct dinPaymen
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinPaymentDetailsResType->GenChallenge.charactersLen);
if (errn == 0) {
errn = (dinPaymentDetailsResType->GenChallenge.charactersLen - 2) <= dinPaymentDetailsResType_GenChallenge_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinPaymentDetailsResType->GenChallenge.charactersLen >= 2) {
dinPaymentDetailsResType->GenChallenge.charactersLen = (uint16_t)(dinPaymentDetailsResType->GenChallenge.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinPaymentDetailsResType->GenChallenge.charactersLen, dinPaymentDetailsResType->GenChallenge.characters);
errn = decodeCharacters(stream, dinPaymentDetailsResType->GenChallenge.charactersLen, dinPaymentDetailsResType->GenChallenge.characters, dinPaymentDetailsResType_GenChallenge_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -9524,13 +9383,10 @@ static int decode_dinPaymentDetailsReqType(bitstream_t* stream, struct dinPaymen
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinPaymentDetailsReqType->ContractID.charactersLen);
if (errn == 0) {
errn = (dinPaymentDetailsReqType->ContractID.charactersLen - 2) <= dinPaymentDetailsReqType_ContractID_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinPaymentDetailsReqType->ContractID.charactersLen >= 2) {
dinPaymentDetailsReqType->ContractID.charactersLen = (uint16_t)(dinPaymentDetailsReqType->ContractID.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinPaymentDetailsReqType->ContractID.charactersLen, dinPaymentDetailsReqType->ContractID.characters);
errn = decodeCharacters(stream, dinPaymentDetailsReqType->ContractID.charactersLen, dinPaymentDetailsReqType->ContractID.characters, dinPaymentDetailsReqType_ContractID_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -9650,13 +9506,10 @@ static int decode_dinServiceTagType(bitstream_t* stream, struct dinServiceTagTyp
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinServiceTagType->ServiceName.charactersLen);
if (errn == 0) {
errn = (dinServiceTagType->ServiceName.charactersLen - 2) <= dinServiceTagType_ServiceName_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinServiceTagType->ServiceName.charactersLen >= 2) {
dinServiceTagType->ServiceName.charactersLen = (uint16_t)(dinServiceTagType->ServiceName.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinServiceTagType->ServiceName.charactersLen, dinServiceTagType->ServiceName.characters);
errn = decodeCharacters(stream, dinServiceTagType->ServiceName.charactersLen, dinServiceTagType->ServiceName.characters, dinServiceTagType_ServiceName_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -9750,13 +9603,10 @@ static int decode_dinServiceTagType(bitstream_t* stream, struct dinServiceTagTyp
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinServiceTagType->ServiceScope.charactersLen);
if (errn == 0) {
errn = (dinServiceTagType->ServiceScope.charactersLen - 2) <= dinServiceTagType_ServiceScope_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinServiceTagType->ServiceScope.charactersLen >= 2) {
dinServiceTagType->ServiceScope.charactersLen = (uint16_t)(dinServiceTagType->ServiceScope.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinServiceTagType->ServiceScope.charactersLen, dinServiceTagType->ServiceScope.characters);
errn = decodeCharacters(stream, dinServiceTagType->ServiceScope.charactersLen, dinServiceTagType->ServiceScope.characters, dinServiceTagType_ServiceScope_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -10025,13 +9875,10 @@ static int decode_dinServiceDiscoveryReqType(bitstream_t* stream, struct dinServ
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinServiceDiscoveryReqType->ServiceScope.charactersLen);
if (errn == 0) {
errn = (dinServiceDiscoveryReqType->ServiceScope.charactersLen - 2) <= dinServiceDiscoveryReqType_ServiceScope_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinServiceDiscoveryReqType->ServiceScope.charactersLen >= 2) {
dinServiceDiscoveryReqType->ServiceScope.charactersLen = (uint16_t)(dinServiceDiscoveryReqType->ServiceScope.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinServiceDiscoveryReqType->ServiceScope.charactersLen, dinServiceDiscoveryReqType->ServiceScope.characters);
errn = decodeCharacters(stream, dinServiceDiscoveryReqType->ServiceScope.charactersLen, dinServiceDiscoveryReqType->ServiceScope.characters, dinServiceDiscoveryReqType_ServiceScope_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -10264,13 +10111,10 @@ static int decode_dinCertificateUpdateReqType(bitstream_t* stream, struct dinCer
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinCertificateUpdateReqType->Id.charactersLen);
if (errn == 0) {
errn = (dinCertificateUpdateReqType->Id.charactersLen - 2) <= dinCertificateUpdateReqType_Id_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinCertificateUpdateReqType->Id.charactersLen >= 2) {
dinCertificateUpdateReqType->Id.charactersLen = (uint16_t)(dinCertificateUpdateReqType->Id.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinCertificateUpdateReqType->Id.charactersLen, dinCertificateUpdateReqType->Id.characters);
errn = decodeCharacters(stream, dinCertificateUpdateReqType->Id.charactersLen, dinCertificateUpdateReqType->Id.characters, dinCertificateUpdateReqType_Id_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -10315,13 +10159,10 @@ static int decode_dinCertificateUpdateReqType(bitstream_t* stream, struct dinCer
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinCertificateUpdateReqType->ContractID.charactersLen);
if (errn == 0) {
errn = (dinCertificateUpdateReqType->ContractID.charactersLen - 2) <= dinCertificateUpdateReqType_ContractID_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinCertificateUpdateReqType->ContractID.charactersLen >= 2) {
dinCertificateUpdateReqType->ContractID.charactersLen = (uint16_t)(dinCertificateUpdateReqType->ContractID.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinCertificateUpdateReqType->ContractID.charactersLen, dinCertificateUpdateReqType->ContractID.characters);
errn = decodeCharacters(stream, dinCertificateUpdateReqType->ContractID.charactersLen, dinCertificateUpdateReqType->ContractID.characters, dinCertificateUpdateReqType_ContractID_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -10505,13 +10346,10 @@ static int decode_dinSignedInfoType(bitstream_t* stream, struct dinSignedInfoTyp
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinSignedInfoType->Id.charactersLen);
if (errn == 0) {
errn = (dinSignedInfoType->Id.charactersLen - 2) <= dinSignedInfoType_Id_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinSignedInfoType->Id.charactersLen >= 2) {
dinSignedInfoType->Id.charactersLen = (uint16_t)(dinSignedInfoType->Id.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinSignedInfoType->Id.charactersLen, dinSignedInfoType->Id.characters);
errn = decodeCharacters(stream, dinSignedInfoType->Id.charactersLen, dinSignedInfoType->Id.characters, dinSignedInfoType_Id_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -11477,13 +11315,10 @@ static int decode_dinMeterInfoType(bitstream_t* stream, struct dinMeterInfoType*
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinMeterInfoType->MeterID.charactersLen);
if (errn == 0) {
errn = (dinMeterInfoType->MeterID.charactersLen - 2) <= dinMeterInfoType_MeterID_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinMeterInfoType->MeterID.charactersLen >= 2) {
dinMeterInfoType->MeterID.charactersLen = (uint16_t)(dinMeterInfoType->MeterID.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinMeterInfoType->MeterID.charactersLen, dinMeterInfoType->MeterID.characters);
errn = decodeCharacters(stream, dinMeterInfoType->MeterID.charactersLen, dinMeterInfoType->MeterID.characters, dinMeterInfoType_MeterID_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -11827,13 +11662,10 @@ static int decode_dinCertificateInstallationResType(bitstream_t* stream, struct
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinCertificateInstallationResType->Id.charactersLen);
if (errn == 0) {
errn = (dinCertificateInstallationResType->Id.charactersLen - 2) <= dinCertificateInstallationResType_Id_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinCertificateInstallationResType->Id.charactersLen >= 2) {
dinCertificateInstallationResType->Id.charactersLen = (uint16_t)(dinCertificateInstallationResType->Id.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinCertificateInstallationResType->Id.charactersLen, dinCertificateInstallationResType->Id.characters);
errn = decodeCharacters(stream, dinCertificateInstallationResType->Id.charactersLen, dinCertificateInstallationResType->Id.characters, dinCertificateInstallationResType_Id_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -11982,13 +11814,10 @@ static int decode_dinCertificateInstallationResType(bitstream_t* stream, struct
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinCertificateInstallationResType->ContractID.charactersLen);
if (errn == 0) {
errn = (dinCertificateInstallationResType->ContractID.charactersLen - 2) <= dinCertificateInstallationResType_ContractID_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinCertificateInstallationResType->ContractID.charactersLen >= 2) {
dinCertificateInstallationResType->ContractID.charactersLen = (uint16_t)(dinCertificateInstallationResType->ContractID.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinCertificateInstallationResType->ContractID.charactersLen, dinCertificateInstallationResType->ContractID.characters);
errn = decodeCharacters(stream, dinCertificateInstallationResType->ContractID.charactersLen, dinCertificateInstallationResType->ContractID.characters, dinCertificateInstallationResType_ContractID_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -12181,13 +12010,10 @@ static int decode_dinX509IssuerSerialType(bitstream_t* stream, struct dinX509Iss
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinX509IssuerSerialType->X509IssuerName.charactersLen);
if (errn == 0) {
errn = (dinX509IssuerSerialType->X509IssuerName.charactersLen - 2) <= dinX509IssuerSerialType_X509IssuerName_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinX509IssuerSerialType->X509IssuerName.charactersLen >= 2) {
dinX509IssuerSerialType->X509IssuerName.charactersLen = (uint16_t)(dinX509IssuerSerialType->X509IssuerName.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinX509IssuerSerialType->X509IssuerName.charactersLen, dinX509IssuerSerialType->X509IssuerName.characters);
errn = decodeCharacters(stream, dinX509IssuerSerialType->X509IssuerName.charactersLen, dinX509IssuerSerialType->X509IssuerName.characters, dinX509IssuerSerialType_X509IssuerName_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -12553,13 +12379,10 @@ static int decode_dinX509DataType(bitstream_t* stream, struct dinX509DataType* d
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinX509DataType->X509SubjectName.array[dinX509DataType->X509SubjectName.arrayLen].charactersLen);
if (errn == 0) {
errn = (dinX509DataType->X509SubjectName.array[dinX509DataType->X509SubjectName.arrayLen].charactersLen - 2) <= dinX509DataType_X509SubjectName_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinX509DataType->X509SubjectName.array[dinX509DataType->X509SubjectName.arrayLen].charactersLen >= 2) {
dinX509DataType->X509SubjectName.array[dinX509DataType->X509SubjectName.arrayLen].charactersLen = (uint16_t)(dinX509DataType->X509SubjectName.array[dinX509DataType->X509SubjectName.arrayLen].charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinX509DataType->X509SubjectName.array[dinX509DataType->X509SubjectName.arrayLen].charactersLen, dinX509DataType->X509SubjectName.array[dinX509DataType->X509SubjectName.arrayLen].characters);
errn = decodeCharacters(stream, dinX509DataType->X509SubjectName.array[dinX509DataType->X509SubjectName.arrayLen].charactersLen, dinX509DataType->X509SubjectName.array[dinX509DataType->X509SubjectName.arrayLen].characters, dinX509DataType_X509SubjectName_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -12711,13 +12534,10 @@ static int decode_dinX509DataType(bitstream_t* stream, struct dinX509DataType* d
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinX509DataType->X509SubjectName.array[dinX509DataType->X509SubjectName.arrayLen].charactersLen);
if (errn == 0) {
errn = (dinX509DataType->X509SubjectName.array[dinX509DataType->X509SubjectName.arrayLen].charactersLen - 2) <= dinX509DataType_X509SubjectName_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinX509DataType->X509SubjectName.array[dinX509DataType->X509SubjectName.arrayLen].charactersLen >= 2) {
dinX509DataType->X509SubjectName.array[dinX509DataType->X509SubjectName.arrayLen].charactersLen = (uint16_t)(dinX509DataType->X509SubjectName.array[dinX509DataType->X509SubjectName.arrayLen].charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinX509DataType->X509SubjectName.array[dinX509DataType->X509SubjectName.arrayLen].charactersLen, dinX509DataType->X509SubjectName.array[dinX509DataType->X509SubjectName.arrayLen].characters);
errn = decodeCharacters(stream, dinX509DataType->X509SubjectName.array[dinX509DataType->X509SubjectName.arrayLen].charactersLen, dinX509DataType->X509SubjectName.array[dinX509DataType->X509SubjectName.arrayLen].characters, dinX509DataType_X509SubjectName_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -13367,13 +13187,10 @@ static int decode_dinCertificateUpdateResType(bitstream_t* stream, struct dinCer
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinCertificateUpdateResType->Id.charactersLen);
if (errn == 0) {
errn = (dinCertificateUpdateResType->Id.charactersLen - 2) <= dinCertificateUpdateResType_Id_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinCertificateUpdateResType->Id.charactersLen >= 2) {
dinCertificateUpdateResType->Id.charactersLen = (uint16_t)(dinCertificateUpdateResType->Id.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinCertificateUpdateResType->Id.charactersLen, dinCertificateUpdateResType->Id.characters);
errn = decodeCharacters(stream, dinCertificateUpdateResType->Id.charactersLen, dinCertificateUpdateResType->Id.characters, dinCertificateUpdateResType_Id_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -13522,13 +13339,10 @@ static int decode_dinCertificateUpdateResType(bitstream_t* stream, struct dinCer
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinCertificateUpdateResType->ContractID.charactersLen);
if (errn == 0) {
errn = (dinCertificateUpdateResType->ContractID.charactersLen - 2) <= dinCertificateUpdateResType_ContractID_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinCertificateUpdateResType->ContractID.charactersLen >= 2) {
dinCertificateUpdateResType->ContractID.charactersLen = (uint16_t)(dinCertificateUpdateResType->ContractID.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinCertificateUpdateResType->ContractID.charactersLen, dinCertificateUpdateResType->ContractID.characters);
errn = decodeCharacters(stream, dinCertificateUpdateResType->ContractID.charactersLen, dinCertificateUpdateResType->ContractID.characters, dinCertificateUpdateResType_ContractID_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -13760,13 +13574,10 @@ static int decode_dinListOfRootCertificateIDsType(bitstream_t* stream, struct di
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinListOfRootCertificateIDsType->RootCertificateID.array[dinListOfRootCertificateIDsType->RootCertificateID.arrayLen].charactersLen);
if (errn == 0) {
errn = (dinListOfRootCertificateIDsType->RootCertificateID.array[dinListOfRootCertificateIDsType->RootCertificateID.arrayLen].charactersLen - 2) <= dinListOfRootCertificateIDsType_RootCertificateID_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinListOfRootCertificateIDsType->RootCertificateID.array[dinListOfRootCertificateIDsType->RootCertificateID.arrayLen].charactersLen >= 2) {
dinListOfRootCertificateIDsType->RootCertificateID.array[dinListOfRootCertificateIDsType->RootCertificateID.arrayLen].charactersLen = (uint16_t)(dinListOfRootCertificateIDsType->RootCertificateID.array[dinListOfRootCertificateIDsType->RootCertificateID.arrayLen].charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinListOfRootCertificateIDsType->RootCertificateID.array[dinListOfRootCertificateIDsType->RootCertificateID.arrayLen].charactersLen, dinListOfRootCertificateIDsType->RootCertificateID.array[dinListOfRootCertificateIDsType->RootCertificateID.arrayLen].characters);
errn = decodeCharacters(stream, dinListOfRootCertificateIDsType->RootCertificateID.array[dinListOfRootCertificateIDsType->RootCertificateID.arrayLen].charactersLen, dinListOfRootCertificateIDsType->RootCertificateID.array[dinListOfRootCertificateIDsType->RootCertificateID.arrayLen].characters, dinListOfRootCertificateIDsType_RootCertificateID_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -13809,13 +13620,10 @@ static int decode_dinListOfRootCertificateIDsType(bitstream_t* stream, struct di
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &dinListOfRootCertificateIDsType->RootCertificateID.array[dinListOfRootCertificateIDsType->RootCertificateID.arrayLen].charactersLen);
if (errn == 0) {
errn = (dinListOfRootCertificateIDsType->RootCertificateID.array[dinListOfRootCertificateIDsType->RootCertificateID.arrayLen].charactersLen - 2) <= dinListOfRootCertificateIDsType_RootCertificateID_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinListOfRootCertificateIDsType->RootCertificateID.array[dinListOfRootCertificateIDsType->RootCertificateID.arrayLen].charactersLen >= 2) {
dinListOfRootCertificateIDsType->RootCertificateID.array[dinListOfRootCertificateIDsType->RootCertificateID.arrayLen].charactersLen = (uint16_t)(dinListOfRootCertificateIDsType->RootCertificateID.array[dinListOfRootCertificateIDsType->RootCertificateID.arrayLen].charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinListOfRootCertificateIDsType->RootCertificateID.array[dinListOfRootCertificateIDsType->RootCertificateID.arrayLen].charactersLen, dinListOfRootCertificateIDsType->RootCertificateID.array[dinListOfRootCertificateIDsType->RootCertificateID.arrayLen].characters);
errn = decodeCharacters(stream, dinListOfRootCertificateIDsType->RootCertificateID.array[dinListOfRootCertificateIDsType->RootCertificateID.arrayLen].charactersLen, dinListOfRootCertificateIDsType->RootCertificateID.array[dinListOfRootCertificateIDsType->RootCertificateID.arrayLen].characters, dinListOfRootCertificateIDsType_RootCertificateID_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -13877,13 +13685,10 @@ static int decode_dinSignatureMethodType(bitstream_t* stream, struct dinSignatur
switch(eventCode) {
case 0:
errn = decodeUnsignedInteger16(stream, &dinSignatureMethodType->Algorithm.charactersLen);
if (errn == 0) {
errn = (dinSignatureMethodType->Algorithm.charactersLen - 2) <= dinSignatureMethodType_Algorithm_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (dinSignatureMethodType->Algorithm.charactersLen >= 2) {
dinSignatureMethodType->Algorithm.charactersLen = (uint16_t)(dinSignatureMethodType->Algorithm.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, dinSignatureMethodType->Algorithm.charactersLen, dinSignatureMethodType->Algorithm.characters);
errn = decodeCharacters(stream, dinSignatureMethodType->Algorithm.charactersLen, dinSignatureMethodType->Algorithm.characters, dinSignatureMethodType_Algorithm_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -14225,13 +14030,10 @@ int decode_dinExiDocument(bitstream_t* stream, struct dinEXIDocument* exiDoc) {
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &exiDoc->KeyName.charactersLen);
if (errn == 0) {
errn = (exiDoc->KeyName.charactersLen - 2) <= EXIDocument_KeyName_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (exiDoc->KeyName.charactersLen >= 2) {
exiDoc->KeyName.charactersLen = (uint16_t)(exiDoc->KeyName.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, exiDoc->KeyName.charactersLen, exiDoc->KeyName.characters);
errn = decodeCharacters(stream, exiDoc->KeyName.charactersLen, exiDoc->KeyName.characters, EXIDocument_KeyName_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;
@ -14271,13 +14073,10 @@ int decode_dinExiDocument(bitstream_t* stream, struct dinEXIDocument* exiDoc) {
if(errn == 0) {
if(eventCode == 0) {
errn = decodeUnsignedInteger16(stream, &exiDoc->MgmtData.charactersLen);
if (errn == 0) {
errn = (exiDoc->MgmtData.charactersLen - 2) <= EXIDocument_MgmtData_CHARACTERS_SIZE ? 0 : EXI_ERROR_STRINGVALUES_OUT_OF_BOUND;
}
if (errn == 0) {
if (exiDoc->MgmtData.charactersLen >= 2) {
exiDoc->MgmtData.charactersLen = (uint16_t)(exiDoc->MgmtData.charactersLen - 2); /* string table miss */
errn = decodeCharacters(stream, exiDoc->MgmtData.charactersLen, exiDoc->MgmtData.characters);
errn = decodeCharacters(stream, exiDoc->MgmtData.charactersLen, exiDoc->MgmtData.characters, EXIDocument_MgmtData_CHARACTERS_SIZE);
} else {
/* string table hit */
errn = EXI_ERROR_STRINGVALUES_NOT_SUPPORTED;

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -19,7 +19,7 @@
*
* @author Daniel.Peintner.EXT@siemens.com
* @author Sebastian.Kaebisch@siemens.com
* @version 0.9.3
* @version 1.0.0alpha
* @contact Joerg.Heuer@siemens.com
*
* <p>Switch for sample programs: EXI codec only or for entire V2G example</p>
@ -32,6 +32,9 @@
#include "main.h"
int main(int argc, char *argv[]) {
/* disable buffering of output, especially when piped or redirected */
setvbuf(stdout, NULL, _IONBF, 0);
#if CODE_VERSION == CODE_VERSION_EXI
/* EXI codec only */
return main_databinder(argc, argv);

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -19,7 +19,7 @@
*
* @author Daniel.Peintner.EXT@siemens.com
* @author Sebastian.Kaebisch@siemens.com
* @version 0.9.3
* @version 1.0.0alpha
* @contact Joerg.Heuer@siemens.com
*
*

View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -18,7 +18,7 @@
/*******************************************************************
*
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 1.0.0alpha
* @contact Joerg.Heuer@siemens.com
*
* <p>Code generated by EXIdizer</p>
@ -72,8 +72,8 @@ int main_databinder(int argc, char *argv[]) {
bitstream_t iStream, oStream;
#if EXI_STREAM == BYTE_ARRAY
uint16_t posDecode;
uint16_t posEncode;
size_t posDecode;
size_t posEncode;
#endif /* EXI_STREAM == BYTE_ARRAY */

File diff suppressed because it is too large Load diff

View file

@ -1,6 +1,6 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -20,7 +20,7 @@
*
* @author Sebastian.Kaebisch@siemens.com
* @author Daniel.Peintner.EXT@siemens.com
* @version 0.9.3
* @version 1.0.0alpha
* @contact Joerg.Heuer@siemens.com
*
********************************************************************/

View file

@ -1,6 +1,6 @@
/*
* Copyright (C) 2007-2015 Siemens AG
* Copyright (C) 2007-2017 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
@ -19,7 +19,7 @@
/*******************************************************************
*
* @author Sebastian.Kaebisch@siemens.com
* @version 0.9.3
* @version 1.0.0alpha
* @contact Joerg.Heuer@siemens.com
*
********************************************************************/