int Data_used_by_applications_outside_the_ERTMSETCS_system_Decoder(Bitstream* stream, Data_used_by_applications_outside_the_ERTMSETCS_system_Core* p)
{
if (NormalBitstream(stream, DATA_USED_BY_APPLICATIONS_OUTSIDE_THE_ERTMSETCS_SYSTEM_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires Q_DIR: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->Q_DIR;
ensures Q_DIR: stream->bitpos == pos + 2;
ensures Q_DIR: EqualBits(stream, pos + 0, pos + 2, p->Q_DIR);
ensures Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
*/
{ p->Q_DIR = Bitstream_Read(stream, 2); }
/*@
requires L_PACKET: stream->bitpos == pos + 2;
assigns stream->bitpos;
assigns p->L_PACKET;
ensures L_PACKET: stream->bitpos == pos + 15;
ensures L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
ensures L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
*/
{ p->L_PACKET = Bitstream_Read(stream, 13); }
/*@
requires NID_XUSER: stream->bitpos == pos + 15;
assigns stream->bitpos;
assigns p->NID_XUSER;
ensures NID_XUSER: stream->bitpos == pos + 24;
ensures NID_XUSER: EqualBits(stream, pos + 15, pos + 24, p->NID_XUSER);
ensures NID_XUSER: UpperBitsNotSet(p->NID_XUSER, 9);
*/
{ p->NID_XUSER = Bitstream_Read(stream, 9); }
if (p->NID_XUSER == 102)
{
{ p->NID_NTC = Bitstream_Read(stream, 8); }
}
{ p->Other_data_depending_on__NID_XUSER = Bitstream_Read(stream, 8); }
//@ assert Q_DIR: EqualBits(stream, pos, pos + 2, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
//@ assert NID_XUSER: EqualBits(stream, pos + 15, pos + 24, p->NID_XUSER);
//@ assert Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
//@ assert L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
//@ assert NID_XUSER: UpperBitsNotSet(p->NID_XUSER, 9);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int DangerForShuntingInformation_DecodeBit(DangerForShuntingInformation* p, Bitstream* stream)
{
if (Bitstream_Normal(stream, DANGERFORSHUNTINGINFORMATION_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires Q_DIR: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->Q_DIR;
ensures Q_DIR: stream->bitpos == pos + 2;
ensures Q_DIR: EqualBits(stream, pos + 0, pos + 2, p->Q_DIR);
ensures Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
*/
{
p->Q_DIR = Bitstream_Read(stream, 2);
}
/*@
requires L_PACKET: stream->bitpos == pos + 2;
assigns stream->bitpos;
assigns p->L_PACKET;
ensures L_PACKET: stream->bitpos == pos + 15;
ensures L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
ensures L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
*/
{
p->L_PACKET = Bitstream_Read(stream, 13);
}
/*@
requires Q_ASPECT: stream->bitpos == pos + 15;
assigns stream->bitpos;
assigns p->Q_ASPECT;
ensures Q_ASPECT: stream->bitpos == pos + 16;
ensures Q_ASPECT: EqualBits(stream, pos + 15, pos + 16, p->Q_ASPECT);
ensures Q_ASPECT: UpperBitsNotSet(p->Q_ASPECT, 1);
*/
{
p->Q_ASPECT = Bitstream_Read(stream, 1);
}
//@ assert Q_DIR: EqualBits(stream, pos, pos + 2, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
//@ assert Q_ASPECT: EqualBits(stream, pos + 15, pos + 16, p->Q_ASPECT);
//@ assert Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
//@ assert L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
//@ assert Q_ASPECT: UpperBitsNotSet(p->Q_ASPECT, 1);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int RadioNetworkRegistration_DecodeBit(RadioNetworkRegistration* p, Bitstream* stream)
{
if (Bitstream_Normal(stream, RADIONETWORKREGISTRATION_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires Q_DIR: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->Q_DIR;
ensures Q_DIR: stream->bitpos == pos + 2;
ensures Q_DIR: EqualBits(stream, pos + 0, pos + 2, p->Q_DIR);
ensures Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
*/
{
p->Q_DIR = Bitstream_Read(stream, 2);
}
/*@
requires L_PACKET: stream->bitpos == pos + 2;
assigns stream->bitpos;
assigns p->L_PACKET;
ensures L_PACKET: stream->bitpos == pos + 15;
ensures L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
ensures L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
*/
{
p->L_PACKET = Bitstream_Read(stream, 13);
}
/*@
requires NID_MN: stream->bitpos == pos + 15;
assigns stream->bitpos;
assigns p->NID_MN;
ensures NID_MN: stream->bitpos == pos + 39;
ensures NID_MN: EqualBits(stream, pos + 15, pos + 39, p->NID_MN);
ensures NID_MN: UpperBitsNotSet(p->NID_MN, 24);
*/
{
p->NID_MN = Bitstream_Read(stream, 24);
}
//@ assert Q_DIR: EqualBits(stream, pos, pos + 2, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
//@ assert NID_MN: EqualBits(stream, pos + 15, pos + 39, p->NID_MN);
//@ assert Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
//@ assert L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
//@ assert NID_MN: UpperBitsNotSet(p->NID_MN, 24);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int Axle_Load_Speed_Profile_Core_2_Decoder(Bitstream* stream, Axle_Load_Speed_Profile_Core_2* p)
{
if (NormalBitstream(stream, AXLE_LOAD_SPEED_PROFILE_CORE_2_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires D_AXLELOAD_k: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->D_AXLELOAD_k;
ensures D_AXLELOAD_k: stream->bitpos == pos + 15;
ensures D_AXLELOAD_k: EqualBits(stream, pos + 0, pos + 15, p->D_AXLELOAD_k);
ensures D_AXLELOAD_k: UpperBitsNotSet(p->D_AXLELOAD_k, 15);
*/
{ p->D_AXLELOAD_k = Bitstream_Read(stream, 15); }
/*@
requires L_AXLELOAD_k: stream->bitpos == pos + 15;
assigns stream->bitpos;
assigns p->L_AXLELOAD_k;
ensures L_AXLELOAD_k: stream->bitpos == pos + 30;
ensures L_AXLELOAD_k: EqualBits(stream, pos + 15, pos + 30, p->L_AXLELOAD_k);
ensures L_AXLELOAD_k: UpperBitsNotSet(p->L_AXLELOAD_k, 15);
*/
{ p->L_AXLELOAD_k = Bitstream_Read(stream, 15); }
/*@
requires Q_FRONT_k: stream->bitpos == pos + 30;
assigns stream->bitpos;
assigns p->Q_FRONT_k;
ensures Q_FRONT_k: stream->bitpos == pos + 31;
ensures Q_FRONT_k: EqualBits(stream, pos + 30, pos + 31, p->Q_FRONT_k);
ensures Q_FRONT_k: UpperBitsNotSet(p->Q_FRONT_k, 1);
*/
{ p->Q_FRONT_k = Bitstream_Read(stream, 1); }
{ p->N_ITER_2_1 = Bitstream_Read(stream, 5); }
for (uint32_t i = 0; i < p->N_ITER_2_1; ++i)
{
Axle_Load_Speed_Profile_Core_2_1_Decoder(stream, &(p->sub_2_1[i]));
}
//@ assert D_AXLELOAD_k: EqualBits(stream, pos, pos + 15, p->D_AXLELOAD_k);
//@ assert L_AXLELOAD_k: EqualBits(stream, pos + 15, pos + 30, p->L_AXLELOAD_k);
//@ assert Q_FRONT_k: EqualBits(stream, pos + 30, pos + 31, p->Q_FRONT_k);
//@ assert D_AXLELOAD_k: UpperBitsNotSet(p->D_AXLELOAD_k, 15);
//@ assert L_AXLELOAD_k: UpperBitsNotSet(p->L_AXLELOAD_k, 15);
//@ assert Q_FRONT_k: UpperBitsNotSet(p->Q_FRONT_k, 1);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int Stop_if_in_Staff_Responsible_Decoder(Bitstream* stream, Stop_if_in_Staff_Responsible* p)
{
if (NormalBitstream(stream, STOP_IF_IN_STAFF_RESPONSIBLE_BITSIZE))
{
uint8_t* addr = stream->addr;
const uint32_t size = stream->size;
const uint32_t pos = stream->bitpos;
/*@
requires Q_DIR: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->Q_DIR;
ensures Q_DIR: stream->bitpos == pos + 2;
ensures Q_DIR: EqualBits(stream, pos + 0, pos + 2, p->Q_DIR);
ensures Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
*/
{ p->Q_DIR = Bitstream_Read(stream, 2); }
/*@
requires L_PACKET: stream->bitpos == pos + 2;
assigns stream->bitpos;
assigns p->L_PACKET;
ensures L_PACKET: stream->bitpos == pos + 15;
ensures L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
ensures L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
*/
{ p->L_PACKET = Bitstream_Read(stream, 13); }
/*@
requires Q_SRSTOP: stream->bitpos == pos + 15;
assigns stream->bitpos;
assigns p->Q_SRSTOP;
ensures Q_SRSTOP: stream->bitpos == pos + 16;
ensures Q_SRSTOP: EqualBits(stream, pos + 15, pos + 16, p->Q_SRSTOP);
ensures Q_SRSTOP: UpperBitsNotSet(p->Q_SRSTOP, 1);
*/
{ p->Q_SRSTOP = Bitstream_Read(stream, 1); }
//@ assert Q_DIR: EqualBits(stream, pos, pos + 2, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
//@ assert Q_SRSTOP: EqualBits(stream, pos + 15, pos + 16, p->Q_SRSTOP);
//@ assert Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
//@ assert L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
//@ assert Q_SRSTOP: UpperBitsNotSet(p->Q_SRSTOP, 1);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int Radio_Network_registration_Decoder(Bitstream* stream, Radio_Network_registration* p)
{
if (NormalBitstream(stream, RADIO_NETWORK_REGISTRATION_BITSIZE))
{
uint8_t* addr = stream->addr;
const uint32_t size = stream->size;
const uint32_t pos = stream->bitpos;
/*@
requires Q_DIR: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->Q_DIR;
ensures Q_DIR: stream->bitpos == pos + 2;
ensures Q_DIR: EqualBits(stream, pos + 0, pos + 2, p->Q_DIR);
ensures Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
*/
{ p->Q_DIR = Bitstream_Read(stream, 2); }
/*@
requires L_PACKET: stream->bitpos == pos + 2;
assigns stream->bitpos;
assigns p->L_PACKET;
ensures L_PACKET: stream->bitpos == pos + 15;
ensures L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
ensures L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
*/
{ p->L_PACKET = Bitstream_Read(stream, 13); }
/*@
requires NID_MN: stream->bitpos == pos + 15;
assigns stream->bitpos;
assigns p->NID_MN;
ensures NID_MN: stream->bitpos == pos + 39;
ensures NID_MN: EqualBits(stream, pos + 15, pos + 39, p->NID_MN);
ensures NID_MN: UpperBitsNotSet(p->NID_MN, 24);
*/
{ p->NID_MN = Bitstream_Read(stream, 24); }
//@ assert Q_DIR: EqualBits(stream, pos, pos + 2, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
//@ assert NID_MN: EqualBits(stream, pos + 15, pos + 39, p->NID_MN);
//@ assert Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
//@ assert L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
//@ assert NID_MN: UpperBitsNotSet(p->NID_MN, 24);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int Danger_for_Shunting_information_Decoder(Bitstream* stream, Danger_for_Shunting_information* p)
{
if (NormalBitstream(stream, DANGER_FOR_SHUNTING_INFORMATION_BITSIZE))
{
uint8_t* addr = stream->addr;
const uint32_t size = stream->size;
const uint32_t pos = stream->bitpos;
/*@
requires Q_DIR: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->Q_DIR;
ensures Q_DIR: stream->bitpos == pos + 2;
ensures Q_DIR: EqualBits(stream, pos + 0, pos + 2, p->Q_DIR);
ensures Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
*/
{ p->Q_DIR = Bitstream_Read(stream, 2); }
/*@
requires L_PACKET: stream->bitpos == pos + 2;
assigns stream->bitpos;
assigns p->L_PACKET;
ensures L_PACKET: stream->bitpos == pos + 15;
ensures L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
ensures L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
*/
{ p->L_PACKET = Bitstream_Read(stream, 13); }
/*@
requires Q_ASPECT: stream->bitpos == pos + 15;
assigns stream->bitpos;
assigns p->Q_ASPECT;
ensures Q_ASPECT: stream->bitpos == pos + 16;
ensures Q_ASPECT: EqualBits(stream, pos + 15, pos + 16, p->Q_ASPECT);
ensures Q_ASPECT: UpperBitsNotSet(p->Q_ASPECT, 1);
*/
{ p->Q_ASPECT = Bitstream_Read(stream, 1); }
//@ assert Q_DIR: EqualBits(stream, pos, pos + 2, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
//@ assert Q_ASPECT: EqualBits(stream, pos + 15, pos + 16, p->Q_ASPECT);
//@ assert Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
//@ assert L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
//@ assert Q_ASPECT: UpperBitsNotSet(p->Q_ASPECT, 1);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int Train_running_number_from_RBC_Decoder(Bitstream* stream, Train_running_number_from_RBC_Core* p)
{
if (NormalBitstream(stream, TRAIN_RUNNING_NUMBER_FROM_RBC_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires Q_DIR: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->Q_DIR;
ensures Q_DIR: stream->bitpos == pos + 2;
ensures Q_DIR: EqualBits(stream, pos + 0, pos + 2, p->Q_DIR);
ensures Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
*/
{ p->Q_DIR = Bitstream_Read(stream, 2); }
/*@
requires L_PACKET: stream->bitpos == pos + 2;
assigns stream->bitpos;
assigns p->L_PACKET;
ensures L_PACKET: stream->bitpos == pos + 15;
ensures L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
ensures L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
*/
{ p->L_PACKET = Bitstream_Read(stream, 13); }
/*@
requires NID_OPERATIONAL: stream->bitpos == pos + 15;
assigns stream->bitpos;
assigns p->NID_OPERATIONAL;
ensures NID_OPERATIONAL: stream->bitpos == pos + 47;
ensures NID_OPERATIONAL: EqualBits(stream, pos + 15, pos + 47, p->NID_OPERATIONAL);
ensures NID_OPERATIONAL: UpperBitsNotSet(p->NID_OPERATIONAL, 32);
*/
{ p->NID_OPERATIONAL = Bitstream_Read(stream, 32); }
//@ assert Q_DIR: EqualBits(stream, pos, pos + 2, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
//@ assert NID_OPERATIONAL: EqualBits(stream, pos + 15, pos + 47, p->NID_OPERATIONAL);
//@ assert Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
//@ assert L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
//@ assert NID_OPERATIONAL: UpperBitsNotSet(p->NID_OPERATIONAL, 32);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int Temporary_Speed_Restriction_Revocation_Decoder(Bitstream* stream, Temporary_Speed_Restriction_Revocation_Core* p)
{
if (NormalBitstream(stream, TEMPORARY_SPEED_RESTRICTION_REVOCATION_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires Q_DIR: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->Q_DIR;
ensures Q_DIR: stream->bitpos == pos + 2;
ensures Q_DIR: EqualBits(stream, pos + 0, pos + 2, p->Q_DIR);
ensures Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
*/
{ p->Q_DIR = Bitstream_Read(stream, 2); }
/*@
requires L_PACKET: stream->bitpos == pos + 2;
assigns stream->bitpos;
assigns p->L_PACKET;
ensures L_PACKET: stream->bitpos == pos + 15;
ensures L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
ensures L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
*/
{ p->L_PACKET = Bitstream_Read(stream, 13); }
/*@
requires NID_TSR: stream->bitpos == pos + 15;
assigns stream->bitpos;
assigns p->NID_TSR;
ensures NID_TSR: stream->bitpos == pos + 23;
ensures NID_TSR: EqualBits(stream, pos + 15, pos + 23, p->NID_TSR);
ensures NID_TSR: UpperBitsNotSet(p->NID_TSR, 8);
*/
{ p->NID_TSR = Bitstream_Read(stream, 8); }
//@ assert Q_DIR: EqualBits(stream, pos, pos + 2, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
//@ assert NID_TSR: EqualBits(stream, pos + 15, pos + 23, p->NID_TSR);
//@ assert Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
//@ assert L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
//@ assert NID_TSR: UpperBitsNotSet(p->NID_TSR, 8);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int OnboardTelephoneNumbers_1_DecodeBit(OnboardTelephoneNumbers_1* p, Bitstream* stream)
{
if (Bitstream_Normal(stream, ONBOARDTELEPHONENUMBERS_1_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires NID_RADIO: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->NID_RADIO;
ensures NID_RADIO: stream->bitpos == pos + 64;
ensures NID_RADIO: EqualBits(stream, pos + 0, pos + 64, p->NID_RADIO);
ensures NID_RADIO: UpperBitsNotSet(p->NID_RADIO, 64);
*/
{
p->NID_RADIO = Bitstream_Read(stream, 64);
}
//@ assert NID_RADIO: EqualBits(stream, pos, pos + 64, p->NID_RADIO);
//@ assert NID_RADIO: UpperBitsNotSet(p->NID_RADIO, 64);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int Validated_train_data_Core_2_Decoder(Bitstream* stream, Validated_train_data_Core_2* p)
{
if (NormalBitstream(stream, VALIDATED_TRAIN_DATA_CORE_2_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires NID_NTC_n: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->NID_NTC_n;
ensures NID_NTC_n: stream->bitpos == pos + 8;
ensures NID_NTC_n: EqualBits(stream, pos + 0, pos + 8, p->NID_NTC_n);
ensures NID_NTC_n: UpperBitsNotSet(p->NID_NTC_n, 8);
*/
{ p->NID_NTC_n = Bitstream_Read(stream, 8); }
//@ assert NID_NTC_n: EqualBits(stream, pos, pos + 8, p->NID_NTC_n);
//@ assert NID_NTC_n: UpperBitsNotSet(p->NID_NTC_n, 8);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int List_of_Balises_in_SR_Authority_Decoder(Bitstream* stream, List_of_Balises_in_SR_Authority_Core* p)
{
if (NormalBitstream(stream, LIST_OF_BALISES_IN_SR_AUTHORITY_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires Q_DIR: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->Q_DIR;
ensures Q_DIR: stream->bitpos == pos + 2;
ensures Q_DIR: EqualBits(stream, pos + 0, pos + 2, p->Q_DIR);
ensures Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
*/
{ p->Q_DIR = Bitstream_Read(stream, 2); }
/*@
requires L_PACKET: stream->bitpos == pos + 2;
assigns stream->bitpos;
assigns p->L_PACKET;
ensures L_PACKET: stream->bitpos == pos + 15;
ensures L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
ensures L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
*/
{ p->L_PACKET = Bitstream_Read(stream, 13); }
{ p->N_ITER_1 = Bitstream_Read(stream, 5); }
for (uint32_t i = 0; i < p->N_ITER_1; ++i)
{
List_of_Balises_in_SR_Authority_Core_1_Decoder(stream, &(p->sub_1[i]));
}
//@ assert Q_DIR: EqualBits(stream, pos, pos + 2, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
//@ assert Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
//@ assert L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int Staff_Responsible_distance_Information_from_loop_Core_1_Decode_Bit(Bitstream* stream, Staff_Responsible_distance_Information_from_loop_Core_1* p)
{
if (Bitstream_Normal(stream, STAFF_RESPONSIBLE_DISTANCE_INFORMATION_FROM_LOOP_CORE_1_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires Q_NEWCOUNTRY: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->Q_NEWCOUNTRY;
ensures Q_NEWCOUNTRY: stream->bitpos == pos + 1;
ensures Q_NEWCOUNTRY: EqualBits(stream, pos + 0, pos + 1, p->Q_NEWCOUNTRY);
ensures Q_NEWCOUNTRY: UpperBitsNotSet(p->Q_NEWCOUNTRY, 1);
*/
{
p->Q_NEWCOUNTRY = Bitstream_Read(stream, 1);
}
if (p->Q_NEWCOUNTRY == 1)
{
{
p->NID_C = Bitstream_Read(stream, 10);
}
}
{
p->NID_BG = Bitstream_Read(stream, 14);
}
{
p->D_SR = Bitstream_Read(stream, 15);
}
//@ assert Q_NEWCOUNTRY: EqualBits(stream, pos, pos + 1, p->Q_NEWCOUNTRY);
//@ assert Q_NEWCOUNTRY: UpperBitsNotSet(p->Q_NEWCOUNTRY, 1);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
bool Termination_of_a_communication_session_Message::decode(Bitstream& stream)
{
uint32_t old_pos = stream.bitpos;
L_MESSAGE = Bitstream_Read(&stream, 10);
T_TRAIN = Bitstream_Read(&stream, 32);
NID_ENGINE = Bitstream_Read(&stream, 24);
if (stream.bitpos > old_pos + (8 * L_MESSAGE))
{
return false;
}
stream.bitpos = old_pos + (8 * L_MESSAGE);
return true;
}
int Axle_Load_Speed_Profile_Core_1_Decode_Bit(Bitstream* stream, Axle_Load_Speed_Profile_Core_1* p)
{
if (Bitstream_Normal(stream, AXLE_LOAD_SPEED_PROFILE_CORE_1_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires M_AXLELOAD: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->M_AXLELOAD;
ensures M_AXLELOAD: stream->bitpos == pos + 7;
ensures M_AXLELOAD: EqualBits(stream, pos + 0, pos + 7, p->M_AXLELOAD);
ensures M_AXLELOAD: UpperBitsNotSet(p->M_AXLELOAD, 7);
*/
{
p->M_AXLELOAD = Bitstream_Read(stream, 7);
}
/*@
requires V_AXLELOAD: stream->bitpos == pos + 7;
assigns stream->bitpos;
assigns p->V_AXLELOAD;
ensures V_AXLELOAD: stream->bitpos == pos + 14;
ensures V_AXLELOAD: EqualBits(stream, pos + 7, pos + 14, p->V_AXLELOAD);
ensures V_AXLELOAD: UpperBitsNotSet(p->V_AXLELOAD, 7);
*/
{
p->V_AXLELOAD = Bitstream_Read(stream, 7);
}
//@ assert M_AXLELOAD: EqualBits(stream, pos, pos + 7, p->M_AXLELOAD);
//@ assert V_AXLELOAD: EqualBits(stream, pos + 7, pos + 14, p->V_AXLELOAD);
//@ assert M_AXLELOAD: UpperBitsNotSet(p->M_AXLELOAD, 7);
//@ assert V_AXLELOAD: UpperBitsNotSet(p->V_AXLELOAD, 7);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int Position_Report_Parameters_Core_1_Decode_Bit(Bitstream* stream, Position_Report_Parameters_Core_1* p)
{
if (Bitstream_Normal(stream, POSITION_REPORT_PARAMETERS_CORE_1_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires D_LOC: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->D_LOC;
ensures D_LOC: stream->bitpos == pos + 15;
ensures D_LOC: EqualBits(stream, pos + 0, pos + 15, p->D_LOC);
ensures D_LOC: UpperBitsNotSet(p->D_LOC, 15);
*/
{
p->D_LOC = Bitstream_Read(stream, 15);
}
/*@
requires Q_LGTLOC: stream->bitpos == pos + 15;
assigns stream->bitpos;
assigns p->Q_LGTLOC;
ensures Q_LGTLOC: stream->bitpos == pos + 16;
ensures Q_LGTLOC: EqualBits(stream, pos + 15, pos + 16, p->Q_LGTLOC);
ensures Q_LGTLOC: UpperBitsNotSet(p->Q_LGTLOC, 1);
*/
{
p->Q_LGTLOC = Bitstream_Read(stream, 1);
}
//@ assert D_LOC: EqualBits(stream, pos, pos + 15, p->D_LOC);
//@ assert Q_LGTLOC: EqualBits(stream, pos + 15, pos + 16, p->Q_LGTLOC);
//@ assert D_LOC: UpperBitsNotSet(p->D_LOC, 15);
//@ assert Q_LGTLOC: UpperBitsNotSet(p->Q_LGTLOC, 1);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int Default_balise_or_Loop_or_RIU_information_Decoder(Bitstream* stream, Default_balise_or_Loop_or_RIU_information* p)
{
if (NormalBitstream(stream, DEFAULT_BALISE_OR_LOOP_OR_RIU_INFORMATION_BITSIZE))
{
uint8_t* addr = stream->addr;
const uint32_t size = stream->size;
const uint32_t pos = stream->bitpos;
/*@
requires Q_DIR: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->Q_DIR;
ensures Q_DIR: stream->bitpos == pos + 2;
ensures Q_DIR: EqualBits(stream, pos + 0, pos + 2, p->Q_DIR);
ensures Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
*/
{ p->Q_DIR = Bitstream_Read(stream, 2); }
/*@
requires L_PACKET: stream->bitpos == pos + 2;
assigns stream->bitpos;
assigns p->L_PACKET;
ensures L_PACKET: stream->bitpos == pos + 15;
ensures L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
ensures L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
*/
{ p->L_PACKET = Bitstream_Read(stream, 13); }
//@ assert Q_DIR: EqualBits(stream, pos, pos + 2, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
//@ assert Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
//@ assert L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int National_Values_Core_3_1_Decode_Bit(Bitstream* stream, National_Values_Core_3_1* p)
{
if (Bitstream_Normal(stream, NATIONAL_VALUES_CORE_3_1_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires V_NVKVINT: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->V_NVKVINT;
ensures V_NVKVINT: stream->bitpos == pos + 7;
ensures V_NVKVINT: EqualBits(stream, pos + 0, pos + 7, p->V_NVKVINT);
ensures V_NVKVINT: UpperBitsNotSet(p->V_NVKVINT, 7);
*/
{
p->V_NVKVINT = Bitstream_Read(stream, 7);
}
/*@
requires M_NVKVINT: stream->bitpos == pos + 7;
assigns stream->bitpos;
assigns p->M_NVKVINT;
ensures M_NVKVINT: stream->bitpos == pos + 14;
ensures M_NVKVINT: EqualBits(stream, pos + 7, pos + 14, p->M_NVKVINT);
ensures M_NVKVINT: UpperBitsNotSet(p->M_NVKVINT, 7);
*/
{
p->M_NVKVINT = Bitstream_Read(stream, 7);
}
//@ assert V_NVKVINT: EqualBits(stream, pos, pos + 7, p->V_NVKVINT);
//@ assert M_NVKVINT: EqualBits(stream, pos + 7, pos + 14, p->M_NVKVINT);
//@ assert V_NVKVINT: UpperBitsNotSet(p->V_NVKVINT, 7);
//@ assert M_NVKVINT: UpperBitsNotSet(p->M_NVKVINT, 7);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int Track_Condition_Big_Metal_Masses_Core_1_Decode_Bit(Bitstream* stream, Track_Condition_Big_Metal_Masses_Core_1* p)
{
if (Bitstream_Normal(stream, TRACK_CONDITION_BIG_METAL_MASSES_CORE_1_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires D_TRACKCOND: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->D_TRACKCOND;
ensures D_TRACKCOND: stream->bitpos == pos + 15;
ensures D_TRACKCOND: EqualBits(stream, pos + 0, pos + 15, p->D_TRACKCOND);
ensures D_TRACKCOND: UpperBitsNotSet(p->D_TRACKCOND, 15);
*/
{
p->D_TRACKCOND = Bitstream_Read(stream, 15);
}
/*@
requires L_TRACKCOND: stream->bitpos == pos + 15;
assigns stream->bitpos;
assigns p->L_TRACKCOND;
ensures L_TRACKCOND: stream->bitpos == pos + 30;
ensures L_TRACKCOND: EqualBits(stream, pos + 15, pos + 30, p->L_TRACKCOND);
ensures L_TRACKCOND: UpperBitsNotSet(p->L_TRACKCOND, 15);
*/
{
p->L_TRACKCOND = Bitstream_Read(stream, 15);
}
//@ assert D_TRACKCOND: EqualBits(stream, pos, pos + 15, p->D_TRACKCOND);
//@ assert L_TRACKCOND: EqualBits(stream, pos + 15, pos + 30, p->L_TRACKCOND);
//@ assert D_TRACKCOND: UpperBitsNotSet(p->D_TRACKCOND, 15);
//@ assert L_TRACKCOND: UpperBitsNotSet(p->L_TRACKCOND, 15);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int InternationalStaticSpeedProfile_2_1_DecodeBit(InternationalStaticSpeedProfile_2_1* p, Bitstream* stream)
{
if (Bitstream_Normal(stream, INTERNATIONALSTATICSPEEDPROFILE_2_1_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires NC_DIFF: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->NC_DIFF;
ensures NC_DIFF: stream->bitpos == pos + 4;
ensures NC_DIFF: EqualBits(stream, pos + 0, pos + 4, p->NC_DIFF);
ensures NC_DIFF: UpperBitsNotSet(p->NC_DIFF, 4);
*/
{
p->NC_DIFF = Bitstream_Read(stream, 4);
}
/*@
requires V_DIFF: stream->bitpos == pos + 4;
assigns stream->bitpos;
assigns p->V_DIFF;
ensures V_DIFF: stream->bitpos == pos + 11;
ensures V_DIFF: EqualBits(stream, pos + 4, pos + 11, p->V_DIFF);
ensures V_DIFF: UpperBitsNotSet(p->V_DIFF, 7);
*/
{
p->V_DIFF = Bitstream_Read(stream, 7);
}
//@ assert NC_DIFF: EqualBits(stream, pos, pos + 4, p->NC_DIFF);
//@ assert V_DIFF: EqualBits(stream, pos + 4, pos + 11, p->V_DIFF);
//@ assert NC_DIFF: UpperBitsNotSet(p->NC_DIFF, 4);
//@ assert V_DIFF: UpperBitsNotSet(p->V_DIFF, 7);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int Inhibition_of_balise_group_message_consistency_reaction_Decode_Bit(Bitstream* stream, Inhibition_of_balise_group_message_consistency_reaction_Core* p)
{
if (Bitstream_Normal(stream, INHIBITION_OF_BALISE_GROUP_MESSAGE_CONSISTENCY_REACTION_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires Q_DIR: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->Q_DIR;
ensures Q_DIR: stream->bitpos == pos + 2;
ensures Q_DIR: EqualBits(stream, pos + 0, pos + 2, p->Q_DIR);
ensures Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
*/
{
p->Q_DIR = Bitstream_Read(stream, 2);
}
/*@
requires L_PACKET: stream->bitpos == pos + 2;
assigns stream->bitpos;
assigns p->L_PACKET;
ensures L_PACKET: stream->bitpos == pos + 15;
ensures L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
ensures L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
*/
{
p->L_PACKET = Bitstream_Read(stream, 13);
}
//@ assert Q_DIR: EqualBits(stream, pos, pos + 2, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
//@ assert Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
//@ assert L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int Level23TransitionInformation_DecodeBit(Level23TransitionInformation* p, Bitstream* stream)
{
if (Bitstream_Normal(stream, LEVEL23TRANSITIONINFORMATION_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires L_PACKET: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->L_PACKET;
ensures L_PACKET: stream->bitpos == pos + 13;
ensures L_PACKET: EqualBits(stream, pos + 0, pos + 13, p->L_PACKET);
ensures L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
*/
{
p->L_PACKET = Bitstream_Read(stream, 13);
}
/*@
requires NID_LTRBG: stream->bitpos == pos + 13;
assigns stream->bitpos;
assigns p->NID_LTRBG;
ensures NID_LTRBG: stream->bitpos == pos + 37;
ensures NID_LTRBG: EqualBits(stream, pos + 13, pos + 37, p->NID_LTRBG);
ensures NID_LTRBG: UpperBitsNotSet(p->NID_LTRBG, 24);
*/
{
p->NID_LTRBG = Bitstream_Read(stream, 24);
}
//@ assert L_PACKET: EqualBits(stream, pos, pos + 13, p->L_PACKET);
//@ assert NID_LTRBG: EqualBits(stream, pos + 13, pos + 37, p->NID_LTRBG);
//@ assert L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
//@ assert NID_LTRBG: UpperBitsNotSet(p->NID_LTRBG, 24);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int List_of_Balises_in_SR_Authority_Core_1_Decode_Bit(Bitstream* stream, List_of_Balises_in_SR_Authority_Core_1* p)
{
if (Bitstream_Normal(stream, LIST_OF_BALISES_IN_SR_AUTHORITY_CORE_1_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires Q_NEWCOUNTRY: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->Q_NEWCOUNTRY;
ensures Q_NEWCOUNTRY: stream->bitpos == pos + 1;
ensures Q_NEWCOUNTRY: EqualBits(stream, pos + 0, pos + 1, p->Q_NEWCOUNTRY);
ensures Q_NEWCOUNTRY: UpperBitsNotSet(p->Q_NEWCOUNTRY, 1);
*/
{
p->Q_NEWCOUNTRY = Bitstream_Read(stream, 1);
}
if (p->Q_NEWCOUNTRY == 1)
{
{
p->NID_C = Bitstream_Read(stream, 10);
}
}
{
p->NID_BG = Bitstream_Read(stream, 14);
}
//@ assert Q_NEWCOUNTRY: EqualBits(stream, pos, pos + 1, p->Q_NEWCOUNTRY);
//@ assert Q_NEWCOUNTRY: UpperBitsNotSet(p->Q_NEWCOUNTRY, 1);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
bool Unconditional_Emergency_Stop_Message::decode(Bitstream& stream)
{
uint32_t old_pos = stream.bitpos;
L_MESSAGE = Bitstream_Read(&stream, 10);
T_TRAIN = Bitstream_Read(&stream, 32);
M_ACK = Bitstream_Read(&stream, 1);
NID_LRBG = Bitstream_Read(&stream, 24);
NID_EM = Bitstream_Read(&stream, 4);
if (stream.bitpos > old_pos + (8 * L_MESSAGE))
{
return false;
}
stream.bitpos = old_pos + (8 * L_MESSAGE);
return true;
}
int Inhibition_of_revocable_TSRs_from_balises_in_L23_Decoder(Bitstream* stream, Inhibition_of_revocable_TSRs_from_balises_in_L23_Core* p)
{
if (NormalBitstream(stream, INHIBITION_OF_REVOCABLE_TSRS_FROM_BALISES_IN_L23_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires Q_DIR: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->Q_DIR;
ensures Q_DIR: stream->bitpos == pos + 2;
ensures Q_DIR: EqualBits(stream, pos + 0, pos + 2, p->Q_DIR);
ensures Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
*/
{ p->Q_DIR = Bitstream_Read(stream, 2); }
/*@
requires L_PACKET: stream->bitpos == pos + 2;
assigns stream->bitpos;
assigns p->L_PACKET;
ensures L_PACKET: stream->bitpos == pos + 15;
ensures L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
ensures L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
*/
{ p->L_PACKET = Bitstream_Read(stream, 13); }
//@ assert Q_DIR: EqualBits(stream, pos, pos + 2, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
//@ assert Q_DIR: UpperBitsNotSet(p->Q_DIR, 2);
//@ assert L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int Error_Reporting_Decoder(Bitstream* stream, Error_Reporting_Core* p)
{
if (NormalBitstream(stream, ERROR_REPORTING_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires L_PACKET: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->L_PACKET;
ensures L_PACKET: stream->bitpos == pos + 13;
ensures L_PACKET: EqualBits(stream, pos + 0, pos + 13, p->L_PACKET);
ensures L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
*/
{ p->L_PACKET = Bitstream_Read(stream, 13); }
/*@
requires M_ERROR: stream->bitpos == pos + 13;
assigns stream->bitpos;
assigns p->M_ERROR;
ensures M_ERROR: stream->bitpos == pos + 21;
ensures M_ERROR: EqualBits(stream, pos + 13, pos + 21, p->M_ERROR);
ensures M_ERROR: UpperBitsNotSet(p->M_ERROR, 8);
*/
{ p->M_ERROR = Bitstream_Read(stream, 8); }
//@ assert L_PACKET: EqualBits(stream, pos, pos + 13, p->L_PACKET);
//@ assert M_ERROR: EqualBits(stream, pos + 13, pos + 21, p->M_ERROR);
//@ assert L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
//@ assert M_ERROR: UpperBitsNotSet(p->M_ERROR, 8);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int International_Static_Speed_Profile_Core_1_Decoder(Bitstream* stream, International_Static_Speed_Profile_Core_1* p)
{
if (NormalBitstream(stream, INTERNATIONAL_STATIC_SPEED_PROFILE_CORE_1_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires Q_DIFF_n: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->Q_DIFF_n;
ensures Q_DIFF_n: stream->bitpos == pos + 2;
ensures Q_DIFF_n: EqualBits(stream, pos + 0, pos + 2, p->Q_DIFF_n);
ensures Q_DIFF_n: UpperBitsNotSet(p->Q_DIFF_n, 2);
*/
{ p->Q_DIFF_n = Bitstream_Read(stream, 2); }
if (p->Q_DIFF_n == 0)
{
{ p->NC_CDDIFF_n = Bitstream_Read(stream, 4); }
}
if ((p->Q_DIFF_n == 1) || (p->Q_DIFF_n == 2))
{
{ p->NC_DIFF_n = Bitstream_Read(stream, 4); }
}
{ p->V_DIFF_n = Bitstream_Read(stream, 7); }
//@ assert Q_DIFF_n: EqualBits(stream, pos, pos + 2, p->Q_DIFF_n);
//@ assert Q_DIFF_n: UpperBitsNotSet(p->Q_DIFF_n, 2);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int Onboard_telephone_numbers_Decode_Bit(Bitstream* stream, Onboard_telephone_numbers_Core* p)
{
if (Bitstream_Normal(stream, ONBOARD_TELEPHONE_NUMBERS_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires L_PACKET: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->L_PACKET;
ensures L_PACKET: stream->bitpos == pos + 13;
ensures L_PACKET: EqualBits(stream, pos + 0, pos + 13, p->L_PACKET);
ensures L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
*/
{
p->L_PACKET = Bitstream_Read(stream, 13);
}
{
p->N_ITER_1 = Bitstream_Read(stream, 5);
}
for (uint32_t i = 0; i < p->N_ITER_1; ++i)
{
Onboard_telephone_numbers_Core_1_Decode_Bit(stream, &(p->sub_1[i]));
}
//@ assert L_PACKET: EqualBits(stream, pos, pos + 13, p->L_PACKET);
//@ assert L_PACKET: UpperBitsNotSet(p->L_PACKET, 13);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int Validated_train_data_Core_1_Decoder(Bitstream* stream, Validated_train_data_Core_1* p)
{
if (NormalBitstream(stream, VALIDATED_TRAIN_DATA_CORE_1_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires M_VOLTAGE_k: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->M_VOLTAGE_k;
ensures M_VOLTAGE_k: stream->bitpos == pos + 4;
ensures M_VOLTAGE_k: EqualBits(stream, pos + 0, pos + 4, p->M_VOLTAGE_k);
ensures M_VOLTAGE_k: UpperBitsNotSet(p->M_VOLTAGE_k, 4);
*/
{
p->M_VOLTAGE_k = Bitstream_Read(stream, 4);
}
if ((p->M_VOLTAGE_k != 0) && (p->NID_CTRACTION_k != 0))
{
{
p->NID_CTRACTION_k = Bitstream_Read(stream, 10);
}
}
//@ assert M_VOLTAGE_k: EqualBits(stream, pos, pos + 4, p->M_VOLTAGE_k);
//@ assert M_VOLTAGE_k: UpperBitsNotSet(p->M_VOLTAGE_k, 4);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
int Geographical_Position_Information_Core_1_Decode_Bit(Bitstream* stream, Geographical_Position_Information_Core_1* p)
{
if (Bitstream_Normal(stream, GEOGRAPHICAL_POSITION_INFORMATION_CORE_1_CORE_BITSIZE))
{
//@ ghost const uint32_t pos = stream->bitpos;
/*@
requires Q_NEWCOUNTRY: stream->bitpos == pos + 0;
assigns stream->bitpos;
assigns p->Q_NEWCOUNTRY;
ensures Q_NEWCOUNTRY: stream->bitpos == pos + 1;
ensures Q_NEWCOUNTRY: EqualBits(stream, pos + 0, pos + 1, p->Q_NEWCOUNTRY);
ensures Q_NEWCOUNTRY: UpperBitsNotSet(p->Q_NEWCOUNTRY, 1);
*/
{
p->Q_NEWCOUNTRY = Bitstream_Read(stream, 1);
}
if (p->Q_NEWCOUNTRY == 1)
{
{
p->NID_C = Bitstream_Read(stream, 10);
}
}
{
p->NID_BG = Bitstream_Read(stream, 14);
}
{
p->D_POSOFF = Bitstream_Read(stream, 15);
}
{
p->Q_MPOSITION = Bitstream_Read(stream, 1);
}
{
p->M_POSITION = Bitstream_Read(stream, 20);
}
//@ assert Q_NEWCOUNTRY: EqualBits(stream, pos, pos + 1, p->Q_NEWCOUNTRY);
//@ assert Q_NEWCOUNTRY: UpperBitsNotSet(p->Q_NEWCOUNTRY, 1);
//@ assert final: EqualBits(stream, pos, p);
return 1;
}
else
{
return 0;
}
}
