int Permitted_Braking_Distance_Information_Core_1_Encoder(Bitstream* stream, const Permitted_Braking_Distance_Information_Core_1* p)
{
if (NormalBitstream(stream, PERMITTED_BRAKING_DISTANCE_INFORMATION_CORE_1_CORE_BITSIZE))
{
if (Permitted_Braking_Distance_Information_Core_1_UpperBitsNotSet(p))
{
//@ ghost const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 15, p->D_PBD_k);
Bitstream_Write(stream, 1, p->Q_GDIR_k);
Bitstream_Write(stream, 8, p->G_PBDSR_k);
Bitstream_Write(stream, 1, p->Q_PBDSR_k);
Bitstream_Write(stream, 15, p->D_PBDSR_k);
Bitstream_Write(stream, 15, p->L_PBDSR_k);
//@ assert D_PBD_k: EqualBits(stream, pos, pos + 15, p->D_PBD_k);
//@ assert Q_GDIR_k: EqualBits(stream, pos + 15, pos + 16, p->Q_GDIR_k);
//@ assert G_PBDSR_k: EqualBits(stream, pos + 16, pos + 24, p->G_PBDSR_k);
//@ assert Q_PBDSR_k: EqualBits(stream, pos + 24, pos + 25, p->Q_PBDSR_k);
//@ assert D_PBDSR_k: EqualBits(stream, pos + 25, pos + 40, p->D_PBDSR_k);
//@ assert L_PBDSR_k: EqualBits(stream, pos + 40, pos + 55, p->L_PBDSR_k);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Temporary_Speed_Restriction_Revocation_Encoder(Bitstream* stream, const Temporary_Speed_Restriction_Revocation_Core* p)
{
if (NormalBitstream(stream, TEMPORARY_SPEED_RESTRICTION_REVOCATION_CORE_BITSIZE))
{
if (Temporary_Speed_Restriction_Revocation_UpperBitsNotSet(p))
{
//@ ghost const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 2, p->Q_DIR);
Bitstream_Write(stream, 13, p->L_PACKET);
Bitstream_Write(stream, 8, p->NID_TSR);
//@ 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);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Danger_for_Shunting_information_Encoder(Bitstream* stream, const Danger_for_Shunting_information* p)
{
if (NormalBitstream(stream, DANGER_FOR_SHUNTING_INFORMATION_BITSIZE))
{
if (Danger_for_Shunting_information_UpperBitsNotSet(p))
{
uint8_t* addr = stream->addr;
const uint32_t size = stream->size;
const uint32_t pos = stream->bitpos;
Bitwalker_Poke_Normal(addr, size, pos, 2, p->Q_DIR);
Bitwalker_Poke_Normal(addr, size, pos + 2, 13, p->L_PACKET);
Bitwalker_Poke_Normal(addr, size, pos + 15, 1, p->Q_ASPECT);
stream->bitpos += DANGER_FOR_SHUNTING_INFORMATION_BITSIZE;
//@ 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);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Geographical_Position_Information_Core_1_Encoder(Bitstream* stream, const Geographical_Position_Information_Core_1* p)
{
if (NormalBitstream(stream, GEOGRAPHICAL_POSITION_INFORMATION_CORE_1_CORE_BITSIZE))
{
if (Geographical_Position_Information_Core_1_UpperBitsNotSet(p))
{
//@ ghost const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 1, p->Q_NEWCOUNTRY_k);
if (p->Q_NEWCOUNTRY_k == 1)
{
Bitstream_Write(stream, 10, p->NID_C_k);
}
Bitstream_Write(stream, 14, p->NID_BG_k);
Bitstream_Write(stream, 15, p->D_POSOFF_k);
Bitstream_Write(stream, 1, p->Q_MPOSITION_k);
Bitstream_Write(stream, 24, p->M_POSITION_k);
//@ assert Q_NEWCOUNTRY_k: EqualBits(stream, pos, pos + 1, p->Q_NEWCOUNTRY_k);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Train_running_number_from_RBC_Encoder(Bitstream* stream, const Train_running_number_from_RBC* p)
{
if (NormalBitstream(stream, TRAIN_RUNNING_NUMBER_FROM_RBC_BITSIZE))
{
if (Train_running_number_from_RBC_UpperBitsNotSet(p))
{
uint8_t* addr = stream->addr;
const uint32_t size = stream->size;
const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 2, p->Q_DIR);
Bitstream_Write(stream, 13, p->L_PACKET);
Bitstream_Write(stream, 32, p->NID_OPERATIONAL);
//@ 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);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
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 List_of_Balises_in_SR_Authority_Encoder(Bitstream* stream, const List_of_Balises_in_SR_Authority_Core* p)
{
if (NormalBitstream(stream, LIST_OF_BALISES_IN_SR_AUTHORITY_CORE_BITSIZE))
{
if (List_of_Balises_in_SR_Authority_UpperBitsNotSet(p))
{
//@ ghost const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 2, p->Q_DIR);
Bitstream_Write(stream, 13, p->L_PACKET);
Bitstream_Write(stream, 5, p->N_ITER_1);
for (uint32_t i = 0; i < p->N_ITER_1; ++i)
{
List_of_Balises_in_SR_Authority_Core_1_Encoder(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);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Default_balise_or_Loop_or_RIU_information_Encoder(Bitstream* stream, const Default_balise_or_Loop_or_RIU_information* p)
{
if (NormalBitstream(stream, DEFAULT_BALISE_OR_LOOP_OR_RIU_INFORMATION_BITSIZE))
{
if (Default_balise_or_Loop_or_RIU_information_UpperBitsNotSet(p))
{
uint8_t* addr = stream->addr;
const uint32_t size = stream->size;
const uint32_t pos = stream->bitpos;
Bitwalker_Poke_Normal(addr, size, pos, 8, p->NID_PACKET);
Bitwalker_Poke_Normal(addr, size, pos + 8, 2, p->Q_DIR);
Bitwalker_Poke_Normal(addr, size, pos + 10, 13, p->L_PACKET);
stream->bitpos += DEFAULT_BALISE_OR_LOOP_OR_RIU_INFORMATION_BITSIZE;
//@ assert NID_PACKET: EqualBits(stream, pos, pos + 8, p->NID_PACKET);
//@ assert Q_DIR: EqualBits(stream, pos + 8, pos + 10, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 10, pos + 23, p->L_PACKET);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Error_Reporting_Encoder(Bitstream* stream, const Error_Reporting* p)
{
if (NormalBitstream(stream, ERROR_REPORTING_BITSIZE))
{
if (Error_Reporting_UpperBitsNotSet(p))
{
uint8_t* addr = stream->addr;
const uint32_t size = stream->size;
const uint32_t pos = stream->bitpos;
Bitwalker_Poke_Normal(addr, size, pos, 13, p->L_PACKET);
Bitwalker_Poke_Normal(addr, size, pos + 13, 8, p->M_ERROR);
stream->bitpos += ERROR_REPORTING_BITSIZE;
//@ assert L_PACKET: EqualBits(stream, pos, pos + 13, p->L_PACKET);
//@ assert M_ERROR: EqualBits(stream, pos + 13, pos + 21, p->M_ERROR);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Radio_Network_registration_Encoder(Bitstream* stream, const Radio_Network_registration_Core* p)
{
if (NormalBitstream(stream, RADIO_NETWORK_REGISTRATION_CORE_BITSIZE))
{
if (Radio_Network_registration_UpperBitsNotSet(p))
{
//@ ghost const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 2, p->Q_DIR);
Bitstream_Write(stream, 13, p->L_PACKET);
Bitstream_Write(stream, 24, p->NID_MN);
//@ 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);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Error_Reporting_Encoder(Bitstream* stream, const Error_Reporting_Core* p)
{
if (NormalBitstream(stream, ERROR_REPORTING_CORE_BITSIZE))
{
if (Error_Reporting_UpperBitsNotSet(p))
{
//@ ghost const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 13, p->L_PACKET);
Bitstream_Write(stream, 8, p->M_ERROR);
//@ assert L_PACKET: EqualBits(stream, pos, pos + 13, p->L_PACKET);
//@ assert M_ERROR: EqualBits(stream, pos + 13, pos + 21, p->M_ERROR);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Track_Condition_Change_of_allowed_current_consumption_Encoder(Bitstream* stream, const Track_Condition_Change_of_allowed_current_consumption* p)
{
if (NormalBitstream(stream, TRACK_CONDITION_CHANGE_OF_ALLOWED_CURRENT_CONSUMPTION_BITSIZE))
{
if (Track_Condition_Change_of_allowed_current_consumption_UpperBitsNotSet(p))
{
uint8_t* addr = stream->addr;
const uint32_t size = stream->size;
const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 2, p->Q_DIR);
Bitstream_Write(stream, 13, p->L_PACKET);
Bitstream_Write(stream, 2, p->Q_SCALE);
Bitstream_Write(stream, 15, p->D_CURRENT);
Bitstream_Write(stream, 10, p->M_CURRENT);
//@ 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_SCALE: EqualBits(stream, pos + 15, pos + 17, p->Q_SCALE);
//@ assert D_CURRENT: EqualBits(stream, pos + 17, pos + 32, p->D_CURRENT);
//@ assert M_CURRENT: EqualBits(stream, pos + 32, pos + 42, p->M_CURRENT);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Repositioning_Information_Encoder(Bitstream* stream, const Repositioning_Information* p)
{
if (NormalBitstream(stream, REPOSITIONING_INFORMATION_BITSIZE))
{
if (Repositioning_Information_UpperBitsNotSet(p))
{
uint8_t* addr = stream->addr;
const uint32_t size = stream->size;
const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 2, p->Q_DIR);
Bitstream_Write(stream, 13, p->L_PACKET);
Bitstream_Write(stream, 2, p->Q_SCALE);
Bitstream_Write(stream, 15, p->L_SECTION);
//@ 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_SCALE: EqualBits(stream, pos + 15, pos + 17, p->Q_SCALE);
//@ assert L_SECTION: EqualBits(stream, pos + 17, pos + 32, p->L_SECTION);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Inhibition_of_revocable_TSRs_from_balises_in_L23_Decoder(Bitstream* stream, Inhibition_of_revocable_TSRs_from_balises_in_L23* p)
{
if (NormalBitstream(stream, INHIBITION_OF_REVOCABLE_TSRS_FROM_BALISES_IN_L23_BITSIZE))
{
uint8_t* addr = stream->addr;
const uint32_t size = stream->size;
const uint32_t pos = stream->bitpos;
p->NID_PACKET = Bitwalker_Peek_Normal(addr, size, pos, 8);
p->Q_DIR = Bitwalker_Peek_Normal(addr, size, pos + 8, 2);
p->L_PACKET = Bitwalker_Peek_Normal(addr, size, pos + 10, 13);
stream->bitpos += INHIBITION_OF_REVOCABLE_TSRS_FROM_BALISES_IN_L23_BITSIZE;
//@ assert NID_PACKET: EqualBits(stream, pos, pos + 8, p->NID_PACKET);
//@ assert Q_DIR: EqualBits(stream, pos + 8, pos + 10, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 10, pos + 23, p->L_PACKET);
return 1;
}
else
{
return 0;
}
}
int Mode_profile_Core_1_Encoder(Bitstream* stream, const Mode_profile_Core_1* p)
{
if (NormalBitstream(stream, MODE_PROFILE_CORE_1_CORE_BITSIZE))
{
if (Mode_profile_Core_1_UpperBitsNotSet(p))
{
//@ ghost const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 15, p->D_MAMODE_k);
Bitstream_Write(stream, 2, p->M_MAMODE_k);
Bitstream_Write(stream, 7, p->V_MAMODE_k);
Bitstream_Write(stream, 15, p->L_MAMODE_k);
Bitstream_Write(stream, 15, p->L_ACKMAMODE_k);
Bitstream_Write(stream, 1, p->Q_MAMODE_k);
//@ assert D_MAMODE_k: EqualBits(stream, pos, pos + 15, p->D_MAMODE_k);
//@ assert M_MAMODE_k: EqualBits(stream, pos + 15, pos + 17, p->M_MAMODE_k);
//@ assert V_MAMODE_k: EqualBits(stream, pos + 17, pos + 24, p->V_MAMODE_k);
//@ assert L_MAMODE_k: EqualBits(stream, pos + 24, pos + 39, p->L_MAMODE_k);
//@ assert L_ACKMAMODE_k: EqualBits(stream, pos + 39, pos + 54, p->L_ACKMAMODE_k);
//@ assert Q_MAMODE_k: EqualBits(stream, pos + 54, pos + 55, p->Q_MAMODE_k);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Track_Condition_Station_Platforms_Core_1_Encoder(Bitstream* stream, const Track_Condition_Station_Platforms_Core_1* p)
{
if (NormalBitstream(stream, TRACK_CONDITION_STATION_PLATFORMS_CORE_1_CORE_BITSIZE))
{
if (Track_Condition_Station_Platforms_Core_1_UpperBitsNotSet(p))
{
//@ ghost const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 15, p->D_TRACKCOND_k);
Bitstream_Write(stream, 15, p->L_TRACKCOND_k);
Bitstream_Write(stream, 4, p->M_PLATFORM_k);
Bitstream_Write(stream, 2, p->Q_PLATFORM_k);
//@ assert D_TRACKCOND_k: EqualBits(stream, pos, pos + 15, p->D_TRACKCOND_k);
//@ assert L_TRACKCOND_k: EqualBits(stream, pos + 15, pos + 30, p->L_TRACKCOND_k);
//@ assert M_PLATFORM_k: EqualBits(stream, pos + 30, pos + 34, p->M_PLATFORM_k);
//@ assert Q_PLATFORM_k: EqualBits(stream, pos + 34, pos + 36, p->Q_PLATFORM_k);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Data_used_by_applications_outside_the_ERTMSETCS_system_Encoder(Bitstream* stream, const Data_used_by_applications_outside_the_ERTMSETCS_system_Core* p)
{
if (NormalBitstream(stream, DATA_USED_BY_APPLICATIONS_OUTSIDE_THE_ERTMSETCS_SYSTEM_CORE_BITSIZE))
{
if (Data_used_by_applications_outside_the_ERTMSETCS_system_UpperBitsNotSet(p))
{
//@ ghost const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 2, p->Q_DIR);
Bitstream_Write(stream, 13, p->L_PACKET);
Bitstream_Write(stream, 9, p->NID_XUSER);
if (p->NID_XUSER == 102)
{
Bitstream_Write(stream, 8, p->NID_NTC);
}
Bitstream_Write(stream, 8, p->Other_data_depending_on__NID_XUSER);
//@ 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);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Reversing_supervision_information_Decoder(Bitstream* stream, Reversing_supervision_information* p)
{
if (NormalBitstream(stream, REVERSING_SUPERVISION_INFORMATION_BITSIZE))
{
uint8_t* addr = stream->addr;
const uint32_t size = stream->size;
const uint32_t pos = stream->bitpos;
p->NID_PACKET = Bitwalker_Peek_Normal(addr, size, pos, 8);
p->Q_DIR = Bitwalker_Peek_Normal(addr, size, pos + 8, 2);
p->L_PACKET = Bitwalker_Peek_Normal(addr, size, pos + 10, 13);
p->Q_SCALE = Bitwalker_Peek_Normal(addr, size, pos + 23, 2);
p->D_REVERSE = Bitwalker_Peek_Normal(addr, size, pos + 25, 15);
p->V_REVERSE = Bitwalker_Peek_Normal(addr, size, pos + 40, 7);
stream->bitpos += REVERSING_SUPERVISION_INFORMATION_BITSIZE;
//@ assert NID_PACKET: EqualBits(stream, pos, pos + 8, p->NID_PACKET);
//@ assert Q_DIR: EqualBits(stream, pos + 8, pos + 10, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 10, pos + 23, p->L_PACKET);
//@ assert Q_SCALE: EqualBits(stream, pos + 23, pos + 25, p->Q_SCALE);
//@ assert D_REVERSE: EqualBits(stream, pos + 25, pos + 40, p->D_REVERSE);
//@ assert V_REVERSE: EqualBits(stream, pos + 40, pos + 47, p->V_REVERSE);
return 1;
}
else
{
return 0;
}
}
int Validated_train_data_Core_1_Encoder(Bitstream* stream, const Validated_train_data_Core_1* p)
{
if (NormalBitstream(stream, VALIDATED_TRAIN_DATA_CORE_1_CORE_BITSIZE))
{
if (Validated_train_data_Core_1_UpperBitsNotSet(p))
{
//@ ghost const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 4, p->M_VOLTAGE_k);
if ((p->M_VOLTAGE_k != 0) && (p->NID_CTRACTION_k != 0))
{
Bitstream_Write(stream, 10, p->NID_CTRACTION_k);
}
//@ assert M_VOLTAGE_k: EqualBits(stream, pos, pos + 4, p->M_VOLTAGE_k);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Axle_Load_Speed_Profile_Core_1_Encoder(Bitstream* stream, const Axle_Load_Speed_Profile_Core_1* p)
{
if (NormalBitstream(stream, AXLE_LOAD_SPEED_PROFILE_CORE_1_CORE_BITSIZE))
{
if (Axle_Load_Speed_Profile_Core_1_UpperBitsNotSet(p))
{
//@ ghost const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 7, p->M_AXLELOADCAT_n);
Bitstream_Write(stream, 7, p->V_AXLELOAD_n);
//@ assert M_AXLELOADCAT_n: EqualBits(stream, pos, pos + 7, p->M_AXLELOADCAT_n);
//@ assert V_AXLELOAD_n: EqualBits(stream, pos + 7, pos + 14, p->V_AXLELOAD_n);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Stop_if_in_Staff_Responsible_Encoder(Bitstream* stream, const Stop_if_in_Staff_Responsible* p)
{
if (NormalBitstream(stream, STOP_IF_IN_STAFF_RESPONSIBLE_BITSIZE))
{
if (Stop_if_in_Staff_Responsible_UpperBitsNotSet(p))
{
uint8_t* addr = stream->addr;
const uint32_t size = stream->size;
const uint32_t pos = stream->bitpos;
Bitwalker_Poke_Normal(addr, size, pos, 2, p->Q_DIR);
Bitwalker_Poke_Normal(addr, size, pos + 2, 13, p->L_PACKET);
Bitwalker_Poke_Normal(addr, size, pos + 15, 1, p->Q_SRSTOP);
stream->bitpos += STOP_IF_IN_STAFF_RESPONSIBLE_BITSIZE;
//@ 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);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Movement_Authority_Request_Parameters_Encoder(Bitstream* stream, const Movement_Authority_Request_Parameters* p)
{
if (NormalBitstream(stream, MOVEMENT_AUTHORITY_REQUEST_PARAMETERS_BITSIZE))
{
if (Movement_Authority_Request_Parameters_UpperBitsNotSet(p))
{
uint8_t* addr = stream->addr;
const uint32_t size = stream->size;
const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 2, p->Q_DIR);
Bitstream_Write(stream, 13, p->L_PACKET);
Bitstream_Write(stream, 8, p->T_MAR);
Bitstream_Write(stream, 10, p->T_TIMEOUTRQST);
Bitstream_Write(stream, 8, p->T_CYCRQST);
//@ assert Q_DIR: EqualBits(stream, pos, pos + 2, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
//@ assert T_MAR: EqualBits(stream, pos + 15, pos + 23, p->T_MAR);
//@ assert T_TIMEOUTRQST: EqualBits(stream, pos + 23, pos + 33, p->T_TIMEOUTRQST);
//@ assert T_CYCRQST: EqualBits(stream, pos + 33, pos + 41, p->T_CYCRQST);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Level_23_Movement_Authority_Core_1_Encoder(Bitstream* stream, const Level_23_Movement_Authority_Core_1* p)
{
if (NormalBitstream(stream, LEVEL_23_MOVEMENT_AUTHORITY_CORE_1_CORE_BITSIZE))
{
if (Level_23_Movement_Authority_Core_1_UpperBitsNotSet(p))
{
//@ ghost const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 15, p->L_SECTION_k);
Bitstream_Write(stream, 1, p->Q_SECTIONTIMER_k);
Bitstream_Write(stream, 10, p->T_SECTIONTIMER_k);
Bitstream_Write(stream, 15, p->D_SECTIONTIMERSTOPLOC_k);
//@ assert L_SECTION_k: EqualBits(stream, pos, pos + 15, p->L_SECTION_k);
//@ assert Q_SECTIONTIMER_k: EqualBits(stream, pos + 15, pos + 16, p->Q_SECTIONTIMER_k);
//@ assert T_SECTIONTIMER_k: EqualBits(stream, pos + 16, pos + 26, p->T_SECTIONTIMER_k);
//@ assert D_SECTIONTIMERSTOPLOC_k: EqualBits(stream, pos + 26, pos + 41, p->D_SECTIONTIMERSTOPLOC_k);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Validated_train_data_Core_2_Encoder(Bitstream* stream, const Validated_train_data_Core_2* p)
{
if (NormalBitstream(stream, VALIDATED_TRAIN_DATA_CORE_2_CORE_BITSIZE))
{
if (Validated_train_data_Core_2_UpperBitsNotSet(p))
{
//@ ghost const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 8, p->NID_NTC_n);
//@ assert NID_NTC_n: EqualBits(stream, pos, pos + 8, p->NID_NTC_n);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Stop_if_in_Staff_Responsible_Encoder(Bitstream* stream, const Stop_if_in_Staff_Responsible_Core* p)
{
if (NormalBitstream(stream, STOP_IF_IN_STAFF_RESPONSIBLE_CORE_BITSIZE))
{
if (Stop_if_in_Staff_Responsible_UpperBitsNotSet(p))
{
//@ ghost const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 2, p->Q_DIR);
Bitstream_Write(stream, 13, p->L_PACKET);
Bitstream_Write(stream, 1, p->Q_SRSTOP);
//@ 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);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
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 Inhibition_of_revocable_TSRs_from_balises_in_L23_Encoder(Bitstream* stream, const Inhibition_of_revocable_TSRs_from_balises_in_L23_Core* p)
{
if (NormalBitstream(stream, INHIBITION_OF_REVOCABLE_TSRS_FROM_BALISES_IN_L23_CORE_BITSIZE))
{
if (Inhibition_of_revocable_TSRs_from_balises_in_L23_UpperBitsNotSet(p))
{
//@ ghost const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 2, p->Q_DIR);
Bitstream_Write(stream, 13, p->L_PACKET);
//@ assert Q_DIR: EqualBits(stream, pos, pos + 2, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 2, pos + 15, p->L_PACKET);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}
int Inhibition_of_balise_group_message_consistency_reaction_Decoder(Bitstream* stream, Inhibition_of_balise_group_message_consistency_reaction* p)
{
if (NormalBitstream(stream, INHIBITION_OF_BALISE_GROUP_MESSAGE_CONSISTENCY_REACTION_BITSIZE))
{
uint8_t* addr = stream->addr;
const uint32_t size = stream->size;
const uint32_t pos = stream->bitpos;
p->NID_PACKET = Bitwalker_Peek_Normal(addr, size, pos, 8);
p->Q_DIR = Bitwalker_Peek_Normal(addr, size, pos + 8, 2);
p->L_PACKET = Bitwalker_Peek_Normal(addr, size, pos + 10, 13);
stream->bitpos += INHIBITION_OF_BALISE_GROUP_MESSAGE_CONSISTENCY_REACTION_BITSIZE;
//@ assert NID_PACKET: EqualBits(stream, pos, pos + 8, p->NID_PACKET);
//@ assert Q_DIR: EqualBits(stream, pos + 8, pos + 10, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 10, pos + 23, p->L_PACKET);
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;
p->NID_PACKET = Bitwalker_Peek_Normal(addr, size, pos, 8);
p->Q_DIR = Bitwalker_Peek_Normal(addr, size, pos + 8, 2);
p->L_PACKET = Bitwalker_Peek_Normal(addr, size, pos + 10, 13);
stream->bitpos += DEFAULT_BALISE_OR_LOOP_OR_RIU_INFORMATION_BITSIZE;
//@ assert NID_PACKET: EqualBits(stream, pos, pos + 8, p->NID_PACKET);
//@ assert Q_DIR: EqualBits(stream, pos + 8, pos + 10, p->Q_DIR);
//@ assert L_PACKET: EqualBits(stream, pos + 10, pos + 23, p->L_PACKET);
return 1;
}
else
{
return 0;
}
}
int Axle_Load_Speed_Profile_Core_2_Encoder(Bitstream* stream, const Axle_Load_Speed_Profile_Core_2* p)
{
if (NormalBitstream(stream, AXLE_LOAD_SPEED_PROFILE_CORE_2_CORE_BITSIZE))
{
if (Axle_Load_Speed_Profile_Core_2_UpperBitsNotSet(p))
{
//@ ghost const uint32_t pos = stream->bitpos;
Bitstream_Write(stream, 15, p->D_AXLELOAD_k);
Bitstream_Write(stream, 15, p->L_AXLELOAD_k);
Bitstream_Write(stream, 1, p->Q_FRONT_k);
Bitstream_Write(stream, 5, p->N_ITER_2_1);
for (uint32_t i = 0; i < p->N_ITER_2_1; ++i)
{
Axle_Load_Speed_Profile_Core_2_1_Encoder(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);
return 1;
}
else
{
return -2;
}
}
else
{
return -1;
}
}