Don't re-create ASN.1 files everytime

CMakeLists.txt

@@ -383,6 +383,9 @@ include_directories ("${RRC_FULL_DIR}")
 
 #NR RRC
 #######
+set (NR_RRC_ASN1_VERSION "NR_Rel16" )
+make_version(NR_RRC_VERSION 16 1 0)
+add_definitions(-DNR_RRC_VERSION=${NR_RRC_VERSION})
 add_library(NR_RRC_LIB ${OPENAIR2_DIR}/RRC/NR/MESSAGES/asn1_msg.c)
 target_link_libraries(NR_RRC_LIB PUBLIC ASN1_NR_RRC_LIB)
 # RRC is used everywhere, and recursively included literally everywhere.
@@ -390,7 +393,7 @@ target_link_libraries(NR_RRC_LIB PUBLIC ASN1_NR_RRC_LIB)
 # To clean this up, every module would need to be separated into subdirectories
 # (via add_subdirectory()) and use
 # target_link_libraries(xyz PRIVATE ASN1_NR_RRC_LIB)
-include_directories("${CMAKE_CURRENT_BINARY_DIR}/openair2/RRC/NR/MESSAGES/asn1c/CMakeFiles/RRC_NR_Rel16/")
+include_directories("openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/")
 
 # S1AP
 # Same limitation as described in RRC: unknown generated file list

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/README

+Create the ASN.1 C files:
+
+ASN1C_PREFIX=NR_ asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen nr-rrc-16.1.0.asn1

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/BIT_STRING.h

+/*-
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_BIT_STRING_H_
+#define	_BIT_STRING_H_
+
+#include <OCTET_STRING.h>	/* Some help from OCTET STRING */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct BIT_STRING_s {
+	uint8_t *buf;	/* BIT STRING body */
+	size_t size;	/* Size of the above buffer */
+
+	int bits_unused;/* Unused trailing bits in the last octet (0..7) */
+
+	asn_struct_ctx_t _asn_ctx;	/* Parsing across buffer boundaries */
+} BIT_STRING_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_BIT_STRING;
+extern asn_TYPE_operation_t asn_OP_BIT_STRING;
+extern asn_OCTET_STRING_specifics_t asn_SPC_BIT_STRING_specs;
+
+asn_struct_print_f BIT_STRING_print;	/* Human-readable output */
+asn_struct_compare_f BIT_STRING_compare;
+asn_constr_check_f BIT_STRING_constraint;
+xer_type_encoder_f BIT_STRING_encode_xer;
+oer_type_decoder_f BIT_STRING_decode_oer;
+oer_type_encoder_f BIT_STRING_encode_oer;
+per_type_decoder_f BIT_STRING_decode_uper;
+per_type_encoder_f BIT_STRING_encode_uper;
+asn_random_fill_f  BIT_STRING_random_fill;
+
+#define BIT_STRING_free              OCTET_STRING_free
+#define BIT_STRING_decode_ber        OCTET_STRING_decode_ber
+#define BIT_STRING_encode_der        OCTET_STRING_encode_der
+#define BIT_STRING_decode_xer        OCTET_STRING_decode_xer_binary
+#define BIT_STRING_decode_aper       OCTET_STRING_decode_aper
+#define BIT_STRING_encode_aper       OCTET_STRING_encode_aper
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BIT_STRING_H_ */

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/BOOLEAN.h

+/*-
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_BOOLEAN_H_
+#define	_BOOLEAN_H_
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * The underlying integer may contain various values, but everything
+ * non-zero is capped to 0xff by the DER encoder. The BER decoder may
+ * yield non-zero values different from 1, beware.
+ */
+typedef int BOOLEAN_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_BOOLEAN;
+extern asn_TYPE_operation_t asn_OP_BOOLEAN;
+
+asn_struct_free_f BOOLEAN_free;
+asn_struct_print_f BOOLEAN_print;
+asn_struct_compare_f BOOLEAN_compare;
+ber_type_decoder_f BOOLEAN_decode_ber;
+der_type_encoder_f BOOLEAN_encode_der;
+oer_type_decoder_f BOOLEAN_decode_oer;
+oer_type_encoder_f BOOLEAN_encode_oer;
+per_type_decoder_f BOOLEAN_decode_uper;
+per_type_encoder_f BOOLEAN_encode_uper;
+per_type_decoder_f BOOLEAN_decode_aper;
+per_type_encoder_f BOOLEAN_encode_aper;
+xer_type_decoder_f BOOLEAN_decode_xer;
+xer_type_encoder_f BOOLEAN_encode_xer;
+asn_random_fill_f  BOOLEAN_random_fill;
+
+#define BOOLEAN_constraint     asn_generic_no_constraint
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BOOLEAN_H_ */

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/INTEGER.h

+/*-
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_INTEGER_H_
+#define	_INTEGER_H_
+
+#include <asn_application.h>
+#include <asn_codecs_prim.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef ASN__PRIMITIVE_TYPE_t INTEGER_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_INTEGER;
+extern asn_TYPE_operation_t asn_OP_INTEGER;
+
+/* Map with <tag> to integer value association */
+typedef struct asn_INTEGER_enum_map_s {
+	long		 nat_value;	/* associated native integer value */
+	size_t		 enum_len;	/* strlen("tag") */
+	const char	*enum_name;	/* "tag" */
+} asn_INTEGER_enum_map_t;
+
+/* This type describes an enumeration for INTEGER and ENUMERATED types */
+typedef struct asn_INTEGER_specifics_s {
+	const asn_INTEGER_enum_map_t *value2enum;	/* N -> "tag"; sorted by N */
+	const unsigned int *enum2value;		/* "tag" => N; sorted by tag */
+	int map_count;				/* Elements in either map */
+	int extension;				/* This map is extensible */
+	int strict_enumeration;			/* Enumeration set is fixed */
+	int field_width;			/* Size of native integer */
+	int field_unsigned;			/* Signed=0, unsigned=1 */
+} asn_INTEGER_specifics_t;
+
+#define INTEGER_free    ASN__PRIMITIVE_TYPE_free
+#define INTEGER_decode_ber	ber_decode_primitive
+#define INTEGER_constraint	asn_generic_no_constraint
+asn_struct_print_f INTEGER_print;
+asn_struct_compare_f INTEGER_compare;
+der_type_encoder_f INTEGER_encode_der;
+xer_type_decoder_f INTEGER_decode_xer;
+xer_type_encoder_f INTEGER_encode_xer;
+oer_type_decoder_f INTEGER_decode_oer;
+oer_type_encoder_f INTEGER_encode_oer;
+per_type_decoder_f INTEGER_decode_uper;
+per_type_encoder_f INTEGER_encode_uper;
+per_type_decoder_f INTEGER_decode_aper;
+per_type_encoder_f INTEGER_encode_aper;
+asn_random_fill_f  INTEGER_random_fill;
+
+/***********************************
+ * Some handy conversion routines. *
+ ***********************************/
+
+/*
+ * Natiwe size-independent conversion of native integers to/from INTEGER.
+ * (l_size) is in bytes.
+ * Returns 0 if it was possible to convert, -1 otherwise.
+ * -1/EINVAL: Mandatory argument missing
+ * -1/ERANGE: Value encoded is out of range for long representation
+ * -1/ENOMEM: Memory allocation failed (in asn_*2INTEGER()).
+ */
+int asn_INTEGER2imax(const INTEGER_t *i, intmax_t *l);
+int asn_INTEGER2umax(const INTEGER_t *i, uintmax_t *l);
+int asn_imax2INTEGER(INTEGER_t *i, intmax_t l);
+int asn_umax2INTEGER(INTEGER_t *i, uintmax_t l);
+
+/*
+ * Size-specific conversion helpers.
+ */
+int asn_INTEGER2long(const INTEGER_t *i, long *l);
+int asn_INTEGER2ulong(const INTEGER_t *i, unsigned long *l);
+int asn_long2INTEGER(INTEGER_t *i, long l);
+int asn_ulong2INTEGER(INTEGER_t *i, unsigned long l);
+int asn_int642INTEGER(INTEGER_t *i, int64_t l);
+int asn_uint642INTEGER(INTEGER_t *i, uint64_t l);
+
+/* A version of strtol/strtoimax(3) with nicer error reporting. */
+enum asn_strtox_result_e {
+    ASN_STRTOX_ERROR_RANGE = -3,  /* Input outside of supported numeric range */
+    ASN_STRTOX_ERROR_INVAL = -2,  /* Invalid data encountered (e.g., "+-") */
+    ASN_STRTOX_EXPECT_MORE = -1,  /* More data expected (e.g. "+") */
+    ASN_STRTOX_OK          =  0,  /* Conversion succeded, number ends at (*end) */
+    ASN_STRTOX_EXTRA_DATA  =  1   /* Conversion succeded, but the string has extra stuff */
+};
+enum asn_strtox_result_e asn_strtol_lim(const char *str, const char **end,
+                                        long *l);
+enum asn_strtox_result_e asn_strtoul_lim(const char *str, const char **end,
+                                         unsigned long *l);
+enum asn_strtox_result_e asn_strtoimax_lim(const char *str, const char **end,
+                                           intmax_t *l);
+enum asn_strtox_result_e asn_strtoumax_lim(const char *str, const char **end,
+                                           uintmax_t *l);
+
+/*
+ * Convert the integer value into the corresponding enumeration map entry.
+ */
+const asn_INTEGER_enum_map_t *INTEGER_map_value2enum(
+    const asn_INTEGER_specifics_t *specs, long value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _INTEGER_H_ */

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_AI-RNTI-r16.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-RRC-Definitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#include "NR_AI-RNTI-r16.h"
+
+int
+NR_AI_RNTI_r16_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 0 && value <= 65535)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NR_RNTI_Value,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_NR_AI_RNTI_r16_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 16,  16,  0,  65535 }	/* (0..65535) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_NR_AI_RNTI_r16_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NR_AI_RNTI_r16 = {
+	"AI-RNTI-r16",
+	"AI-RNTI-r16",
+	&asn_OP_NativeInteger,
+	asn_DEF_NR_AI_RNTI_r16_tags_1,
+	sizeof(asn_DEF_NR_AI_RNTI_r16_tags_1)
+		/sizeof(asn_DEF_NR_AI_RNTI_r16_tags_1[0]), /* 1 */
+	asn_DEF_NR_AI_RNTI_r16_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NR_AI_RNTI_r16_tags_1)
+		/sizeof(asn_DEF_NR_AI_RNTI_r16_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_NR_AI_RNTI_r16_constr_1, NR_AI_RNTI_r16_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_AI-RNTI-r16.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-RRC-Definitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#ifndef	_NR_AI_RNTI_r16_H_
+#define	_NR_AI_RNTI_r16_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "NR_RNTI-Value.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* NR_AI-RNTI-r16 */
+typedef NR_RNTI_Value_t	 NR_AI_RNTI_r16_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_NR_AI_RNTI_r16_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_NR_AI_RNTI_r16;
+asn_struct_free_f NR_AI_RNTI_r16_free;
+asn_struct_print_f NR_AI_RNTI_r16_print;
+asn_constr_check_f NR_AI_RNTI_r16_constraint;
+ber_type_decoder_f NR_AI_RNTI_r16_decode_ber;
+der_type_encoder_f NR_AI_RNTI_r16_encode_der;
+xer_type_decoder_f NR_AI_RNTI_r16_decode_xer;
+xer_type_encoder_f NR_AI_RNTI_r16_encode_xer;
+per_type_decoder_f NR_AI_RNTI_r16_decode_uper;
+per_type_encoder_f NR_AI_RNTI_r16_encode_uper;
+per_type_decoder_f NR_AI_RNTI_r16_decode_aper;
+per_type_encoder_f NR_AI_RNTI_r16_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NR_AI_RNTI_r16_H_ */
+#include <asn_internal.h>

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_AMF-Identifier.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-RRC-Definitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#include "NR_AMF-Identifier.h"
+
+int
+NR_AMF_Identifier_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(st->size > 0) {
+		/* Size in bits */
+		size = 8 * st->size - (st->bits_unused & 0x07);
+	} else {
+		size = 0;
+	}
+	
+	if((size == 24)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using BIT_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_NR_AMF_Identifier_constr_1 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  24,  24 }	/* (SIZE(24..24)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_NR_AMF_Identifier_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NR_AMF_Identifier = {
+	"AMF-Identifier",
+	"AMF-Identifier",
+	&asn_OP_BIT_STRING,
+	asn_DEF_NR_AMF_Identifier_tags_1,
+	sizeof(asn_DEF_NR_AMF_Identifier_tags_1)
+		/sizeof(asn_DEF_NR_AMF_Identifier_tags_1[0]), /* 1 */
+	asn_DEF_NR_AMF_Identifier_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NR_AMF_Identifier_tags_1)
+		/sizeof(asn_DEF_NR_AMF_Identifier_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_NR_AMF_Identifier_constr_1, NR_AMF_Identifier_constraint },
+	0, 0,	/* No members */
+	&asn_SPC_BIT_STRING_specs	/* Additional specs */
+};
+

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_AMF-Identifier.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-RRC-Definitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#ifndef	_NR_AMF_Identifier_H_
+#define	_NR_AMF_Identifier_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <BIT_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* NR_AMF-Identifier */
+typedef BIT_STRING_t	 NR_AMF_Identifier_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_NR_AMF_Identifier_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_NR_AMF_Identifier;
+asn_struct_free_f NR_AMF_Identifier_free;
+asn_struct_print_f NR_AMF_Identifier_print;
+asn_constr_check_f NR_AMF_Identifier_constraint;
+ber_type_decoder_f NR_AMF_Identifier_decode_ber;
+der_type_encoder_f NR_AMF_Identifier_encode_der;
+xer_type_decoder_f NR_AMF_Identifier_decode_xer;
+xer_type_encoder_f NR_AMF_Identifier_encode_xer;
+per_type_decoder_f NR_AMF_Identifier_decode_uper;
+per_type_encoder_f NR_AMF_Identifier_encode_uper;
+per_type_decoder_f NR_AMF_Identifier_decode_aper;
+per_type_encoder_f NR_AMF_Identifier_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NR_AMF_Identifier_H_ */
+#include <asn_internal.h>

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_ARFCN-ValueEUTRA.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-RRC-Definitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#include "NR_ARFCN-ValueEUTRA.h"
+
+int
+NR_ARFCN_ValueEUTRA_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 0 && value <= 262143)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_NR_ARFCN_ValueEUTRA_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 18, -1,  0,  262143 }	/* (0..262143) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_NR_ARFCN_ValueEUTRA_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NR_ARFCN_ValueEUTRA = {
+	"ARFCN-ValueEUTRA",
+	"ARFCN-ValueEUTRA",
+	&asn_OP_NativeInteger,
+	asn_DEF_NR_ARFCN_ValueEUTRA_tags_1,
+	sizeof(asn_DEF_NR_ARFCN_ValueEUTRA_tags_1)
+		/sizeof(asn_DEF_NR_ARFCN_ValueEUTRA_tags_1[0]), /* 1 */
+	asn_DEF_NR_ARFCN_ValueEUTRA_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NR_ARFCN_ValueEUTRA_tags_1)
+		/sizeof(asn_DEF_NR_ARFCN_ValueEUTRA_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_NR_ARFCN_ValueEUTRA_constr_1, NR_ARFCN_ValueEUTRA_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_ARFCN-ValueEUTRA.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-RRC-Definitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#ifndef	_NR_ARFCN_ValueEUTRA_H_
+#define	_NR_ARFCN_ValueEUTRA_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* NR_ARFCN-ValueEUTRA */
+typedef long	 NR_ARFCN_ValueEUTRA_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_NR_ARFCN_ValueEUTRA_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_NR_ARFCN_ValueEUTRA;
+asn_struct_free_f NR_ARFCN_ValueEUTRA_free;
+asn_struct_print_f NR_ARFCN_ValueEUTRA_print;
+asn_constr_check_f NR_ARFCN_ValueEUTRA_constraint;
+ber_type_decoder_f NR_ARFCN_ValueEUTRA_decode_ber;
+der_type_encoder_f NR_ARFCN_ValueEUTRA_encode_der;
+xer_type_decoder_f NR_ARFCN_ValueEUTRA_decode_xer;
+xer_type_encoder_f NR_ARFCN_ValueEUTRA_encode_xer;
+per_type_decoder_f NR_ARFCN_ValueEUTRA_decode_uper;
+per_type_encoder_f NR_ARFCN_ValueEUTRA_encode_uper;
+per_type_decoder_f NR_ARFCN_ValueEUTRA_decode_aper;
+per_type_encoder_f NR_ARFCN_ValueEUTRA_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NR_ARFCN_ValueEUTRA_H_ */
+#include <asn_internal.h>

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_ARFCN-ValueNR.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-RRC-Definitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#include "NR_ARFCN-ValueNR.h"
+
+int
+NR_ARFCN_ValueNR_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 0 && value <= 3279165)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_NR_ARFCN_ValueNR_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 22, -1,  0,  3279165 }	/* (0..3279165) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_NR_ARFCN_ValueNR_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NR_ARFCN_ValueNR = {
+	"ARFCN-ValueNR",
+	"ARFCN-ValueNR",
+	&asn_OP_NativeInteger,
+	asn_DEF_NR_ARFCN_ValueNR_tags_1,
+	sizeof(asn_DEF_NR_ARFCN_ValueNR_tags_1)
+		/sizeof(asn_DEF_NR_ARFCN_ValueNR_tags_1[0]), /* 1 */
+	asn_DEF_NR_ARFCN_ValueNR_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NR_ARFCN_ValueNR_tags_1)
+		/sizeof(asn_DEF_NR_ARFCN_ValueNR_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_NR_ARFCN_ValueNR_constr_1, NR_ARFCN_ValueNR_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_ARFCN-ValueNR.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-RRC-Definitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#ifndef	_NR_ARFCN_ValueNR_H_
+#define	_NR_ARFCN_ValueNR_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* NR_ARFCN-ValueNR */
+typedef long	 NR_ARFCN_ValueNR_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_NR_ARFCN_ValueNR_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_NR_ARFCN_ValueNR;
+asn_struct_free_f NR_ARFCN_ValueNR_free;
+asn_struct_print_f NR_ARFCN_ValueNR_print;
+asn_constr_check_f NR_ARFCN_ValueNR_constraint;
+ber_type_decoder_f NR_ARFCN_ValueNR_decode_ber;
+der_type_encoder_f NR_ARFCN_ValueNR_encode_der;
+xer_type_decoder_f NR_ARFCN_ValueNR_decode_xer;
+xer_type_encoder_f NR_ARFCN_ValueNR_encode_xer;
+per_type_decoder_f NR_ARFCN_ValueNR_decode_uper;
+per_type_encoder_f NR_ARFCN_ValueNR_encode_uper;
+per_type_decoder_f NR_ARFCN_ValueNR_decode_aper;
+per_type_encoder_f NR_ARFCN_ValueNR_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NR_ARFCN_ValueNR_H_ */
+#include <asn_internal.h>

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_ARFCN-ValueUTRA-FDD-r16.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-RRC-Definitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#include "NR_ARFCN-ValueUTRA-FDD-r16.h"
+
+int
+NR_ARFCN_ValueUTRA_FDD_r16_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 0 && value <= 16383)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_NR_ARFCN_ValueUTRA_FDD_r16_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 14,  14,  0,  16383 }	/* (0..16383) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_NR_ARFCN_ValueUTRA_FDD_r16_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NR_ARFCN_ValueUTRA_FDD_r16 = {
+	"ARFCN-ValueUTRA-FDD-r16",
+	"ARFCN-ValueUTRA-FDD-r16",
+	&asn_OP_NativeInteger,
+	asn_DEF_NR_ARFCN_ValueUTRA_FDD_r16_tags_1,
+	sizeof(asn_DEF_NR_ARFCN_ValueUTRA_FDD_r16_tags_1)
+		/sizeof(asn_DEF_NR_ARFCN_ValueUTRA_FDD_r16_tags_1[0]), /* 1 */
+	asn_DEF_NR_ARFCN_ValueUTRA_FDD_r16_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NR_ARFCN_ValueUTRA_FDD_r16_tags_1)
+		/sizeof(asn_DEF_NR_ARFCN_ValueUTRA_FDD_r16_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_NR_ARFCN_ValueUTRA_FDD_r16_constr_1, NR_ARFCN_ValueUTRA_FDD_r16_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_ARFCN-ValueUTRA-FDD-r16.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-RRC-Definitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#ifndef	_NR_ARFCN_ValueUTRA_FDD_r16_H_
+#define	_NR_ARFCN_ValueUTRA_FDD_r16_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* NR_ARFCN-ValueUTRA-FDD-r16 */
+typedef long	 NR_ARFCN_ValueUTRA_FDD_r16_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_NR_ARFCN_ValueUTRA_FDD_r16_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_NR_ARFCN_ValueUTRA_FDD_r16;
+asn_struct_free_f NR_ARFCN_ValueUTRA_FDD_r16_free;
+asn_struct_print_f NR_ARFCN_ValueUTRA_FDD_r16_print;
+asn_constr_check_f NR_ARFCN_ValueUTRA_FDD_r16_constraint;
+ber_type_decoder_f NR_ARFCN_ValueUTRA_FDD_r16_decode_ber;
+der_type_encoder_f NR_ARFCN_ValueUTRA_FDD_r16_encode_der;
+xer_type_decoder_f NR_ARFCN_ValueUTRA_FDD_r16_decode_xer;
+xer_type_encoder_f NR_ARFCN_ValueUTRA_FDD_r16_encode_xer;
+per_type_decoder_f NR_ARFCN_ValueUTRA_FDD_r16_decode_uper;
+per_type_encoder_f NR_ARFCN_ValueUTRA_FDD_r16_encode_uper;
+per_type_decoder_f NR_ARFCN_ValueUTRA_FDD_r16_decode_aper;
+per_type_encoder_f NR_ARFCN_ValueUTRA_FDD_r16_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NR_ARFCN_ValueUTRA_FDD_r16_H_ */
+#include <asn_internal.h>

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_AS-Config.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-InterNodeDefinitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#ifndef	_NR_AS_Config_H_
+#define	_NR_AS_Config_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+#include <constr_SEQUENCE.h>
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum NR_AS_Config__ext2__sourceSCG_Configured {
+	NR_AS_Config__ext2__sourceSCG_Configured_true	= 0
+} e_NR_AS_Config__ext2__sourceSCG_Configured;
+
+/* NR_AS-Config */
+typedef struct NR_AS_Config {
+	OCTET_STRING_t	 rrcReconfiguration;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	struct NR_AS_Config__ext1 {
+		OCTET_STRING_t	*sourceRB_SN_Config;	/* OPTIONAL */
+		OCTET_STRING_t	*sourceSCG_NR_Config;	/* OPTIONAL */
+		OCTET_STRING_t	*sourceSCG_EUTRA_Config;	/* OPTIONAL */
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} *ext1;
+	struct NR_AS_Config__ext2 {
+		long	*sourceSCG_Configured;	/* OPTIONAL */
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} *ext2;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} NR_AS_Config_t;
+
+/* Implementation */
+/* extern asn_TYPE_descriptor_t asn_DEF_NR_sourceSCG_Configured_9;	// (Use -fall-defs-global to expose) */
+extern asn_TYPE_descriptor_t asn_DEF_NR_AS_Config;
+extern asn_SEQUENCE_specifics_t asn_SPC_NR_AS_Config_specs_1;
+extern asn_TYPE_member_t asn_MBR_NR_AS_Config_1[3];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NR_AS_Config_H_ */
+#include <asn_internal.h>

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_AS-Context.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-InterNodeDefinitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#ifndef	_NR_AS_Context_H_
+#define	_NR_AS_Context_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <constr_SEQUENCE.h>
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct NR_ReestablishmentInfo;
+struct NR_ConfigRestrictInfoSCG;
+struct NR_RAN_NotificationAreaInfo;
+struct NR_BandCombinationInfoSN;
+struct NR_ConfigRestrictInfoDAPS_r16;
+struct NR_NeedForGapsInfoNR_r16;
+
+/* NR_AS-Context */
+typedef struct NR_AS_Context {
+	struct NR_ReestablishmentInfo	*reestablishmentInfo;	/* OPTIONAL */
+	struct NR_ConfigRestrictInfoSCG	*configRestrictInfo;	/* OPTIONAL */
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	struct NR_AS_Context__ext1 {
+		struct NR_RAN_NotificationAreaInfo	*ran_NotificationAreaInfo;	/* OPTIONAL */
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} *ext1;
+	struct NR_AS_Context__ext2 {
+		OCTET_STRING_t	*ueAssistanceInformation;	/* OPTIONAL */
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} *ext2;
+	struct NR_AS_Context__ext3 {
+		struct NR_BandCombinationInfoSN	*selectedBandCombinationSN;	/* OPTIONAL */
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} *ext3;
+	struct NR_AS_Context__ext4 {
+		struct NR_ConfigRestrictInfoDAPS_r16	*configRestrictInfoDAPS_r16;	/* OPTIONAL */
+		OCTET_STRING_t	*sidelinkUEInformationNR_r16;	/* OPTIONAL */
+		OCTET_STRING_t	*sidelinkUEInformationEUTRA_r16;	/* OPTIONAL */
+		OCTET_STRING_t	*ueAssistanceInformationEUTRA_r16;	/* OPTIONAL */
+		OCTET_STRING_t	*ueAssistanceInformationSCG_r16;	/* OPTIONAL */
+		struct NR_NeedForGapsInfoNR_r16	*needForGapsInfoNR_r16;	/* OPTIONAL */
+		
+		/* Context for parsing across buffer boundaries */
+		asn_struct_ctx_t _asn_ctx;
+	} *ext4;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} NR_AS_Context_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_NR_AS_Context;
+extern asn_SEQUENCE_specifics_t asn_SPC_NR_AS_Context_specs_1;
+extern asn_TYPE_member_t asn_MBR_NR_AS_Context_1[6];
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "NR_ReestablishmentInfo.h"
+#include "NR_ConfigRestrictInfoSCG.h"
+#include "NR_RAN-NotificationAreaInfo.h"
+#include "NR_BandCombinationInfoSN.h"
+#include "NR_ConfigRestrictInfoDAPS-r16.h"
+#include "NR_NeedForGapsInfoNR-r16.h"
+
+#endif	/* _NR_AS_Context_H_ */
+#include <asn_internal.h>

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_AbsoluteTimeInfo-r16.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-RRC-Definitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#include "NR_AbsoluteTimeInfo-r16.h"
+
+int
+NR_AbsoluteTimeInfo_r16_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(st->size > 0) {
+		/* Size in bits */
+		size = 8 * st->size - (st->bits_unused & 0x07);
+	} else {
+		size = 0;
+	}
+	
+	if((size == 48)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using BIT_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_NR_AbsoluteTimeInfo_r16_constr_1 CC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  48,  48 }	/* (SIZE(48..48)) */,
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_NR_AbsoluteTimeInfo_r16_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NR_AbsoluteTimeInfo_r16 = {
+	"AbsoluteTimeInfo-r16",
+	"AbsoluteTimeInfo-r16",
+	&asn_OP_BIT_STRING,
+	asn_DEF_NR_AbsoluteTimeInfo_r16_tags_1,
+	sizeof(asn_DEF_NR_AbsoluteTimeInfo_r16_tags_1)
+		/sizeof(asn_DEF_NR_AbsoluteTimeInfo_r16_tags_1[0]), /* 1 */
+	asn_DEF_NR_AbsoluteTimeInfo_r16_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NR_AbsoluteTimeInfo_r16_tags_1)
+		/sizeof(asn_DEF_NR_AbsoluteTimeInfo_r16_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_NR_AbsoluteTimeInfo_r16_constr_1, NR_AbsoluteTimeInfo_r16_constraint },
+	0, 0,	/* No members */
+	&asn_SPC_BIT_STRING_specs	/* Additional specs */
+};
+

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_AbsoluteTimeInfo-r16.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-RRC-Definitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#ifndef	_NR_AbsoluteTimeInfo_r16_H_
+#define	_NR_AbsoluteTimeInfo_r16_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <BIT_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* NR_AbsoluteTimeInfo-r16 */
+typedef BIT_STRING_t	 NR_AbsoluteTimeInfo_r16_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_NR_AbsoluteTimeInfo_r16_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_NR_AbsoluteTimeInfo_r16;
+asn_struct_free_f NR_AbsoluteTimeInfo_r16_free;
+asn_struct_print_f NR_AbsoluteTimeInfo_r16_print;
+asn_constr_check_f NR_AbsoluteTimeInfo_r16_constraint;
+ber_type_decoder_f NR_AbsoluteTimeInfo_r16_decode_ber;
+der_type_encoder_f NR_AbsoluteTimeInfo_r16_encode_der;
+xer_type_decoder_f NR_AbsoluteTimeInfo_r16_decode_xer;
+xer_type_encoder_f NR_AbsoluteTimeInfo_r16_encode_xer;
+per_type_decoder_f NR_AbsoluteTimeInfo_r16_decode_uper;
+per_type_encoder_f NR_AbsoluteTimeInfo_r16_encode_uper;
+per_type_decoder_f NR_AbsoluteTimeInfo_r16_decode_aper;
+per_type_encoder_f NR_AbsoluteTimeInfo_r16_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NR_AbsoluteTimeInfo_r16_H_ */
+#include <asn_internal.h>

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_AccessStratumRelease.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-RRC-Definitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#include "NR_AccessStratumRelease.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_NR_AccessStratumRelease_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  3,  3,  0,  7 }	/* (0..7,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_NR_AccessStratumRelease_value2enum_1[] = {
+	{ 0,	5,	"rel15" },
+	{ 1,	5,	"rel16" },
+	{ 2,	6,	"spare6" },
+	{ 3,	6,	"spare5" },
+	{ 4,	6,	"spare4" },
+	{ 5,	6,	"spare3" },
+	{ 6,	6,	"spare2" },
+	{ 7,	6,	"spare1" }
+	/* This list is extensible */
+};
+static const unsigned int asn_MAP_NR_AccessStratumRelease_enum2value_1[] = {
+	0,	/* rel15(0) */
+	1,	/* rel16(1) */
+	7,	/* spare1(7) */
+	6,	/* spare2(6) */
+	5,	/* spare3(5) */
+	4,	/* spare4(4) */
+	3,	/* spare5(3) */
+	2	/* spare6(2) */
+	/* This list is extensible */
+};
+const asn_INTEGER_specifics_t asn_SPC_NR_AccessStratumRelease_specs_1 = {
+	asn_MAP_NR_AccessStratumRelease_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_NR_AccessStratumRelease_enum2value_1,	/* N => "tag"; sorted by N */
+	8,	/* Number of elements in the maps */
+	9,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_NR_AccessStratumRelease_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NR_AccessStratumRelease = {
+	"AccessStratumRelease",
+	"AccessStratumRelease",
+	&asn_OP_NativeEnumerated,
+	asn_DEF_NR_AccessStratumRelease_tags_1,
+	sizeof(asn_DEF_NR_AccessStratumRelease_tags_1)
+		/sizeof(asn_DEF_NR_AccessStratumRelease_tags_1[0]), /* 1 */
+	asn_DEF_NR_AccessStratumRelease_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NR_AccessStratumRelease_tags_1)
+		/sizeof(asn_DEF_NR_AccessStratumRelease_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_NR_AccessStratumRelease_constr_1, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_NR_AccessStratumRelease_specs_1	/* Additional specs */
+};
+

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_AccessStratumRelease.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-RRC-Definitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#ifndef	_NR_AccessStratumRelease_H_
+#define	_NR_AccessStratumRelease_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeEnumerated.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum NR_AccessStratumRelease {
+	NR_AccessStratumRelease_rel15	= 0,
+	NR_AccessStratumRelease_rel16	= 1,
+	NR_AccessStratumRelease_spare6	= 2,
+	NR_AccessStratumRelease_spare5	= 3,
+	NR_AccessStratumRelease_spare4	= 4,
+	NR_AccessStratumRelease_spare3	= 5,
+	NR_AccessStratumRelease_spare2	= 6,
+	NR_AccessStratumRelease_spare1	= 7
+	/*
+	 * Enumeration is extensible
+	 */
+} e_NR_AccessStratumRelease;
+
+/* NR_AccessStratumRelease */
+typedef long	 NR_AccessStratumRelease_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_NR_AccessStratumRelease_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_NR_AccessStratumRelease;
+extern const asn_INTEGER_specifics_t asn_SPC_NR_AccessStratumRelease_specs_1;
+asn_struct_free_f NR_AccessStratumRelease_free;
+asn_struct_print_f NR_AccessStratumRelease_print;
+asn_constr_check_f NR_AccessStratumRelease_constraint;
+ber_type_decoder_f NR_AccessStratumRelease_decode_ber;
+der_type_encoder_f NR_AccessStratumRelease_encode_der;
+xer_type_decoder_f NR_AccessStratumRelease_decode_xer;
+xer_type_encoder_f NR_AccessStratumRelease_encode_xer;
+per_type_decoder_f NR_AccessStratumRelease_decode_uper;
+per_type_encoder_f NR_AccessStratumRelease_encode_uper;
+per_type_decoder_f NR_AccessStratumRelease_decode_aper;
+per_type_encoder_f NR_AccessStratumRelease_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NR_AccessStratumRelease_H_ */
+#include <asn_internal.h>

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_AdditionalSpectrumEmission.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-RRC-Definitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#include "NR_AdditionalSpectrumEmission.h"
+
+int
+NR_AdditionalSpectrumEmission_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 0 && value <= 7)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+asn_per_constraints_t asn_PER_type_NR_AdditionalSpectrumEmission_constr_1 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 3,  3,  0,  7 }	/* (0..7) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_NR_AdditionalSpectrumEmission_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NR_AdditionalSpectrumEmission = {
+	"AdditionalSpectrumEmission",
+	"AdditionalSpectrumEmission",
+	&asn_OP_NativeInteger,
+	asn_DEF_NR_AdditionalSpectrumEmission_tags_1,
+	sizeof(asn_DEF_NR_AdditionalSpectrumEmission_tags_1)
+		/sizeof(asn_DEF_NR_AdditionalSpectrumEmission_tags_1[0]), /* 1 */
+	asn_DEF_NR_AdditionalSpectrumEmission_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NR_AdditionalSpectrumEmission_tags_1)
+		/sizeof(asn_DEF_NR_AdditionalSpectrumEmission_tags_1[0]), /* 1 */
+	{ 0, &asn_PER_type_NR_AdditionalSpectrumEmission_constr_1, NR_AdditionalSpectrumEmission_constraint },
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_AdditionalSpectrumEmission.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-RRC-Definitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#ifndef	_NR_AdditionalSpectrumEmission_H_
+#define	_NR_AdditionalSpectrumEmission_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* NR_AdditionalSpectrumEmission */
+typedef long	 NR_AdditionalSpectrumEmission_t;
+
+/* Implementation */
+extern asn_per_constraints_t asn_PER_type_NR_AdditionalSpectrumEmission_constr_1;
+extern asn_TYPE_descriptor_t asn_DEF_NR_AdditionalSpectrumEmission;
+asn_struct_free_f NR_AdditionalSpectrumEmission_free;
+asn_struct_print_f NR_AdditionalSpectrumEmission_print;
+asn_constr_check_f NR_AdditionalSpectrumEmission_constraint;
+ber_type_decoder_f NR_AdditionalSpectrumEmission_decode_ber;
+der_type_encoder_f NR_AdditionalSpectrumEmission_encode_der;
+xer_type_decoder_f NR_AdditionalSpectrumEmission_decode_xer;
+xer_type_encoder_f NR_AdditionalSpectrumEmission_encode_xer;
+per_type_decoder_f NR_AdditionalSpectrumEmission_decode_uper;
+per_type_encoder_f NR_AdditionalSpectrumEmission_encode_uper;
+per_type_decoder_f NR_AdditionalSpectrumEmission_decode_aper;
+per_type_encoder_f NR_AdditionalSpectrumEmission_encode_aper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NR_AdditionalSpectrumEmission_H_ */
+#include <asn_internal.h>

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_AffectedCarrierFreq-r16.c

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-RRC-Definitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#include "NR_AffectedCarrierFreq-r16.h"
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static asn_per_constraints_t asn_PER_type_NR_interferenceDirection_r16_constr_3 CC_NOTUSED = {
+	{ APC_CONSTRAINED,	 2,  2,  0,  3 }	/* (0..3) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_NR_interferenceDirection_r16_value2enum_3[] = {
+	{ 0,	2,	"nr" },
+	{ 1,	5,	"other" },
+	{ 2,	4,	"both" },
+	{ 3,	5,	"spare" }
+};
+static const unsigned int asn_MAP_NR_interferenceDirection_r16_enum2value_3[] = {
+	2,	/* both(2) */
+	0,	/* nr(0) */
+	1,	/* other(1) */
+	3	/* spare(3) */
+};
+static const asn_INTEGER_specifics_t asn_SPC_NR_interferenceDirection_r16_specs_3 = {
+	asn_MAP_NR_interferenceDirection_r16_value2enum_3,	/* "tag" => N; sorted by tag */
+	asn_MAP_NR_interferenceDirection_r16_enum2value_3,	/* N => "tag"; sorted by N */
+	4,	/* Number of elements in the maps */
+	0,	/* Enumeration is not extensible */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static const ber_tlv_tag_t asn_DEF_NR_interferenceDirection_r16_tags_3[] = {
+	(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_NR_interferenceDirection_r16_3 = {
+	"interferenceDirection-r16",
+	"interferenceDirection-r16",
+	&asn_OP_NativeEnumerated,
+	asn_DEF_NR_interferenceDirection_r16_tags_3,
+	sizeof(asn_DEF_NR_interferenceDirection_r16_tags_3)
+		/sizeof(asn_DEF_NR_interferenceDirection_r16_tags_3[0]) - 1, /* 1 */
+	asn_DEF_NR_interferenceDirection_r16_tags_3,	/* Same as above */
+	sizeof(asn_DEF_NR_interferenceDirection_r16_tags_3)
+		/sizeof(asn_DEF_NR_interferenceDirection_r16_tags_3[0]), /* 2 */
+	{ 0, &asn_PER_type_NR_interferenceDirection_r16_constr_3, NativeEnumerated_constraint },
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_NR_interferenceDirection_r16_specs_3	/* Additional specs */
+};
+
+asn_TYPE_member_t asn_MBR_NR_AffectedCarrierFreq_r16_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct NR_AffectedCarrierFreq_r16, carrierFreq_r16),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NR_ARFCN_ValueNR,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"carrierFreq-r16"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct NR_AffectedCarrierFreq_r16, interferenceDirection_r16),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NR_interferenceDirection_r16_3,
+		0,
+		{ 0, 0, 0 },
+		0, 0, /* No default value */
+		"interferenceDirection-r16"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_NR_AffectedCarrierFreq_r16_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_NR_AffectedCarrierFreq_r16_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* carrierFreq-r16 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* interferenceDirection-r16 */
+};
+asn_SEQUENCE_specifics_t asn_SPC_NR_AffectedCarrierFreq_r16_specs_1 = {
+	sizeof(struct NR_AffectedCarrierFreq_r16),
+	offsetof(struct NR_AffectedCarrierFreq_r16, _asn_ctx),
+	asn_MAP_NR_AffectedCarrierFreq_r16_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* First extension addition */
+};
+asn_TYPE_descriptor_t asn_DEF_NR_AffectedCarrierFreq_r16 = {
+	"AffectedCarrierFreq-r16",
+	"AffectedCarrierFreq-r16",
+	&asn_OP_SEQUENCE,
+	asn_DEF_NR_AffectedCarrierFreq_r16_tags_1,
+	sizeof(asn_DEF_NR_AffectedCarrierFreq_r16_tags_1)
+		/sizeof(asn_DEF_NR_AffectedCarrierFreq_r16_tags_1[0]), /* 1 */
+	asn_DEF_NR_AffectedCarrierFreq_r16_tags_1,	/* Same as above */
+	sizeof(asn_DEF_NR_AffectedCarrierFreq_r16_tags_1)
+		/sizeof(asn_DEF_NR_AffectedCarrierFreq_r16_tags_1[0]), /* 1 */
+	{ 0, 0, SEQUENCE_constraint },
+	asn_MBR_NR_AffectedCarrierFreq_r16_1,
+	2,	/* Elements count */
+	&asn_SPC_NR_AffectedCarrierFreq_r16_specs_1	/* Additional specs */
+};
+

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.gen/NR_AffectedCarrierFreq-r16.h

+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ * From ASN.1 module "NR-RRC-Definitions"
+ * 	found in "nr-rrc-16.1.0.asn1"
+ * 	`asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -findirect-choice -D nr-rrc-16.1.0.gen`
+ */
+
+#ifndef	_NR_AffectedCarrierFreq_r16_H_
+#define	_NR_AffectedCarrierFreq_r16_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "NR_ARFCN-ValueNR.h"
+#include <NativeEnumerated.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum NR_AffectedCarrierFreq_r16__interferenceDirection_r16 {
+	NR_AffectedCarrierFreq_r16__interferenceDirection_r16_nr	= 0,
+	NR_AffectedCarrierFreq_r16__interferenceDirection_r16_other	= 1,
+	NR_AffectedCarrierFreq_r16__interferenceDirection_r16_both	= 2,
+	NR_AffectedCarrierFreq_r16__interferenceDirection_r16_spare	= 3
+} e_NR_AffectedCarrierFreq_r16__interferenceDirection_r16;
+
+/* NR_AffectedCarrierFreq-r16 */
+typedef struct NR_AffectedCarrierFreq_r16 {
+	NR_ARFCN_ValueNR_t	 carrierFreq_r16;
+	long	 interferenceDirection_r16;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} NR_AffectedCarrierFreq_r16_t;
+
+/* Implementation */
+/* extern asn_TYPE_descriptor_t asn_DEF_NR_interferenceDirection_r16_3;	// (Use -fall-defs-global to expose) */
+extern asn_TYPE_descriptor_t asn_DEF_NR_AffectedCarrierFreq_r16;
+extern asn_SEQUENCE_specifics_t asn_SPC_NR_AffectedCarrierFreq_r16_specs_1;
+extern asn_TYPE_member_t asn_MBR_NR_AffectedCarrierFreq_r16_1[2];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NR_AffectedCarrierFreq_r16_H_ */
+#include <asn_internal.h>