Added Secure User Plane Location (SUPL) client library and the associated A-GNSS data structures. The GNSS assistance function is not active yet!

git-svn-id: https://svn.code.sf.net/p/gnss-sdr/code/trunk@344 64b25241-fba3-4117-9849-534c7e92360d

CMakeLists.txt

@@ -25,7 +25,7 @@ endif(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
 # Project setup
 ########################################################################
 cmake_minimum_required(VERSION 2.8)
-project(gnss-sdr CXX)
+project(gnss-sdr CXX C)
 
 #select the release build type by default to get optimization flags
 if(NOT CMAKE_BUILD_TYPE)

src/algorithms/libs/CMakeLists.txt

@@ -16,6 +16,8 @@
 # along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
 #
 
+add_subdirectory(supl)
+
 set(GNSS_SPLIBS_SOURCES 
      galileo_e1_signal_processing.cc 
      gnss_sdr_valve.cc 
@@ -23,6 +25,7 @@ set(GNSS_SPLIBS_SOURCES
      gps_sdr_signal_processing.cc
      nco_lib.cc
      pass_through.cc
+     gnss_sdr_supl_client.cc
 )
 
 include_directories(
@@ -30,6 +33,10 @@ include_directories(
      ${CMAKE_SOURCE_DIR}/src/core/system_parameters
      ${CMAKE_SOURCE_DIR}/src/core/receiver
      ${CMAKE_SOURCE_DIR}/src/core/interfaces
+     ${CMAKE_SOURCE_DIR}/src/algorithms/libs/supl
+	 ${CMAKE_SOURCE_DIR}/src/algorithms/libs/supl/asn-rrlp
+	 ${CMAKE_SOURCE_DIR}/src/algorithms/libs/supl/asn-supl
 )
 
-add_library(gnss_sp_libs ${GNSS_SPLIBS_SOURCES})
+add_library(gnss_sp_libs ${GNSS_SPLIBS_SOURCES})
+target_link_libraries (gnss_sp_libs supl_library) 

src/algorithms/libs/gnss_sdr_supl_client.cc

@@ -0,0 +1,307 @@
+/*!
+ * \file gnss_sdr_supl_client.c
+ * \brief class that implements a C++ interface to external Secure User Location Protocol (SUPL) client library.
+ * \author Javier Arribas, 2013. jarribas(at)cttc.es
+ *
+ * TODO: put here supl.c author info
+ * class that implements a C++ interface to external Secure User Location Protocol (SUPL) client library.
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2013  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+#include "gnss_sdr_supl_client.h"
+
+
+gnss_sdr_supl_client::gnss_sdr_supl_client()
+{
+
+}
+gnss_sdr_supl_client::~gnss_sdr_supl_client()
+{
+
+}
+
+void gnss_sdr_supl_client::print_assistance()
+{
+	  if (assist.set & SUPL_RRLP_ASSIST_REFTIME) {
+	    fprintf(stdout, "T %ld %ld %ld %ld\n", assist.time.gps_week, assist.time.gps_tow,
+		    assist.time.stamp.tv_sec, assist.time.stamp.tv_usec);
+	  }
+
+	  if (assist.set & SUPL_RRLP_ASSIST_UTC) {
+	    fprintf(stdout, "U %d %d %d %d %d %d %d %d\n",
+		    assist.utc.a0, assist.utc.a1, assist.utc.delta_tls,
+		    assist.utc.tot, assist.utc.wnt, assist.utc.wnlsf,
+		    assist.utc.dn, assist.utc.delta_tlsf);
+	  }
+
+	  if (assist.set & SUPL_RRLP_ASSIST_REFLOC) {
+	    fprintf(stdout, "L %f %f %d\n", assist.pos.lat, assist.pos.lon, assist.pos.uncertainty);
+	  }
+
+	  if (assist.set & SUPL_RRLP_ASSIST_IONO) {
+	    fprintf(stdout, "I %d %d %d %d %d %d %d %d\n",
+		    assist.iono.a0, assist.iono.a1, assist.iono.a2, assist.iono.a3,
+		    assist.iono.b0, assist.iono.b1, assist.iono.b2, assist.iono.b3);
+	  }
+
+	  if (assist.cnt_eph) {
+	    int i;
+
+	    fprintf(stdout, "E %d\n", assist.cnt_eph);
+
+	    for (i = 0; i < assist.cnt_eph; i++) {
+	      struct supl_ephemeris_s *e = &assist.eph[i];
+
+	      fprintf(stdout, "e %d %d %d %d %d %d %d %d %d %d",
+		      e->prn, e->delta_n, e->M0, e->A_sqrt, e->OMEGA_0, e->i0, e->w, e->OMEGA_dot, e->i_dot, e->e);
+	      fprintf(stdout, " %d %d %d %d %d %d",
+		      e->Cuc, e->Cus, e->Crc, e->Crs, e->Cic, e->Cis);
+	      fprintf(stdout, " %d %d %d %d %d %d",
+		      e->toe, e->IODC, e->toc, e->AF0, e->AF1, e->AF2);
+	      fprintf(stdout, " %d %d %d %d %d\n",
+		      e->bits, e->ura, e->health, e->tgd, e->AODA);
+	    }
+	  }
+
+	  if (assist.cnt_alm) {
+	    int i;
+
+	    fprintf(stdout, "A %d\n", assist.cnt_alm);
+	    for (i = 0; i < assist.cnt_alm; i++) {
+	      struct supl_almanac_s *a = &assist.alm[i];
+
+	      fprintf(stdout, "a %d %d %d %d %d ",
+		      a->prn, a->e, a->toa, a->Ksii, a->OMEGA_dot);
+	      fprintf(stdout, "%d %d %d %d %d %d\n",
+		      a->A_sqrt, a->OMEGA_0, a->w, a->M0, a->AF0, a->AF1);
+	    }
+	  }
+
+	  if (assist.cnt_acq) {
+	    int i;
+
+	    fprintf(stdout, "Q %d %d\n", assist.cnt_acq, assist.acq_time);
+	    for (i = 0; i < assist.cnt_acq; i++) {
+	      struct supl_acquis_s *q = &assist.acq[i];
+
+	      fprintf(stdout, "q %d %d %d ",
+		      q->prn, q->parts, q->doppler0);
+	      if (q->parts & SUPL_ACQUIS_DOPPLER) {
+		fprintf(stdout, "%d %d ", q->doppler1, q->d_win);
+	      } else {
+		fprintf(stdout, "0 0 ");
+	      }
+	      fprintf(stdout, "%d %d %d %d ",
+		      q->code_ph, q->code_ph_int, q->bit_num, q->code_ph_win);
+	      if (q->parts & SUPL_ACQUIS_ANGLE) {
+		fprintf(stdout, "%d %d\n", q->az, q->el);
+	      } else {
+		fprintf(stdout, "0 0\n");
+	      }
+	    }
+	  }
+
+}
+int gnss_sdr_supl_client::get_assistance(int i_mcc, int i_mns, int i_lac, int i_ci)
+{
+
+	// SET SUPL CLIENT INFORMATION
+	// GSM CELL PARAMETERS
+	mcc=i_mcc;
+	mns=i_mns;
+	lac=i_lac;
+	ci=i_ci;
+	supl_set_gsm_cell(&ctx,mcc,mns,lac,ci);
+
+	// PERFORM SUPL COMMUNICATION
+	char *cstr = new char[server_name.length() + 1];
+	strcpy(cstr, server_name.c_str());
+
+	int err;
+	ctx.p.request=request; // select assistance info request from a pre-defined set
+	err=supl_get_assist(&ctx, cstr, &assist);
+	if (err==0)
+	{
+		read_supl_data();
+	}
+	delete [] cstr;
+	return err;
+}
+
+void gnss_sdr_supl_client::read_supl_data()
+{
+	// READ REFERENCE LOCATION
+	  if (assist.set & SUPL_RRLP_ASSIST_REFLOC) {
+		  gps_ref_loc.lat=assist.pos.lat;
+		  gps_ref_loc.lon=assist.pos.lon;
+		  gps_ref_loc.uncertainty=assist.pos.uncertainty;
+		  gps_ref_loc.valid=true;
+	  }
+
+	// READ REFERENCE TIME
+	if (assist.set & SUPL_RRLP_ASSIST_REFTIME) {
+		gps_time.d_TOW=(double)assist.time.gps_tow;
+		gps_time.d_Week=(double)assist.time.gps_week;
+		gps_time.d_tv_sec=(double)assist.time.stamp.tv_sec;
+		gps_time.d_tv_usec=(double)assist.time.stamp.tv_usec;
+		gps_time.valid=true;
+
+	}
+
+	// READ UTC MODEL
+	if (assist.set & SUPL_RRLP_ASSIST_UTC) {
+	    gps_utc.d_A0=((double)assist.utc.a0)*pow(2.0, -30);
+	    gps_utc.d_A1=((double)assist.utc.a1)*pow(2.0, -50);
+	    gps_utc.d_DeltaT_LS=((double)assist.utc.delta_tls);
+	    gps_utc.d_DeltaT_LSF=((double)assist.utc.delta_tlsf);
+	    gps_utc.d_t_OT=((double)assist.utc.tot)*pow(2.0,12);
+	    gps_utc.i_DN=((double)assist.utc.dn);
+	    gps_utc.i_WN_T=((double)assist.utc.wnt);
+	    gps_utc.i_WN_LSF=((double)assist.utc.wnlsf);
+	    gps_utc.valid=true;
+	  }
+
+	// READ IONOSPHERIC MODEL
+	if (assist.set & SUPL_RRLP_ASSIST_IONO) {
+		gps_iono.d_alpha0 = (double)assist.iono.a0 * ALPHA_0_LSB;
+		gps_iono.d_alpha1 = (double)assist.iono.a1 * ALPHA_1_LSB;
+		gps_iono.d_alpha2 = (double)assist.iono.a2 * ALPHA_2_LSB;
+		gps_iono.d_alpha3 = (double)assist.iono.a3 * ALPHA_3_LSB;
+
+		gps_iono.d_beta0 = (double)assist.iono.b0 * BETA_0_LSB;
+		gps_iono.d_beta1 = (double)assist.iono.b1 * BETA_1_LSB;
+		gps_iono.d_beta2 = (double)assist.iono.b2 * BETA_2_LSB;
+		gps_iono.d_beta3 = (double)assist.iono.b3 * BETA_3_LSB;
+		gps_iono.valid=true;
+
+	}
+
+	// READ SV ALMANAC
+	  if (assist.cnt_alm) {
+		std::map<int,Gps_Almanac>::iterator gps_almanac_iterator;
+		for (int i = 0; i < assist.cnt_alm; i++) {
+			struct supl_almanac_s *a = &assist.alm[i];
+			// Check if the SV is present in the map
+			gps_almanac_iterator=this->gps_almanac_map.find(a->prn);
+			// the SV is not present in the almanac data -> insert new SV register
+			if (gps_almanac_iterator==gps_almanac_map.end())
+			{
+				Gps_Almanac gps_almanac_entry;
+				gps_almanac_map.insert(std::pair<int,Gps_Almanac>(a->prn, gps_almanac_entry));
+				gps_almanac_iterator=this->gps_almanac_map.find(a->prn);
+			}
+			gps_almanac_iterator->second.i_satellite_PRN=a->prn;
+			gps_almanac_iterator->second.d_A_f0=((double)a->AF0)*pow(2.0, -20);
+			gps_almanac_iterator->second.d_A_f1=((double)a->AF1)*pow(2.0, -38);
+			gps_almanac_iterator->second.d_Delta_i=((double)a->Ksii)*pow(2.0, -19);
+			gps_almanac_iterator->second.d_OMEGA=((double)a->w)*pow(2.0, -23);
+			gps_almanac_iterator->second.d_OMEGA0=((double)a->OMEGA_0)*pow(2.0, -23);
+			gps_almanac_iterator->second.d_sqrt_A=((double)a->A_sqrt)*pow(2.0, -11);
+			gps_almanac_iterator->second.d_OMEGA_DOT=((double)a->OMEGA_dot)*pow(2.0, -38);
+			gps_almanac_iterator->second.d_Toa=((double)a->toa)*pow(2.0, 12);
+			gps_almanac_iterator->second.d_e_eccentricity=((double)a->toa)*pow(2.0, -21);
+			gps_almanac_iterator->second.d_M_0=((double)a->M0)*pow(2.0, -23);
+
+		}
+	}
+
+
+	// READ SV EPHEMERIS
+	if (assist.cnt_eph) {
+		std::map<int,Gps_Ephemeris>::iterator gps_eph_iterator;
+		for (int i = 0; i < assist.cnt_eph; i++) {
+			struct supl_ephemeris_s *e = &assist.eph[i];
+			// Check if the SV is present in the map
+			gps_eph_iterator=this->gps_ephemeris_map.find(e->prn);
+			// the SV is not present in the assistance data -> insert new SV register
+			if (gps_eph_iterator==gps_ephemeris_map.end())
+			{
+				Gps_Ephemeris gps_eph;
+				gps_ephemeris_map.insert(std::pair<int,Gps_Ephemeris>(e->prn, gps_eph));
+				gps_eph_iterator=this->gps_ephemeris_map.find(e->prn);
+			}
+			gps_eph_iterator->second.i_satellite_PRN=e->prn;
+			// SV navigation model
+			gps_eph_iterator->second.i_code_on_L2=e->bits;
+			gps_eph_iterator->second.i_SV_accuracy=e->ura;//User Range Accuracy (URA)
+			gps_eph_iterator->second.i_SV_health = e->health;
+			gps_eph_iterator->second.d_IODC = (double)e->IODC;
+			//miss P flag (1 bit)
+			//miss SF1 Reserved (87 bits)
+			gps_eph_iterator->second.d_TGD = ((double)e->tgd)*T_GD_LSB;
+			gps_eph_iterator->second.d_Toc = ((double)e->toc)*T_OC_LSB;
+			gps_eph_iterator->second.d_A_f0=((double)e->AF0)*A_F0_LSB;
+			gps_eph_iterator->second.d_A_f1=((double)e->AF1)*A_F1_LSB;
+			gps_eph_iterator->second.d_A_f2=((double)e->AF2)*A_F2_LSB;
+			gps_eph_iterator->second.d_Crc = ((double)e->Crc)*C_RC_LSB;
+			gps_eph_iterator->second.d_Delta_n = ((double)e->delta_n)*DELTA_N_LSB;
+			gps_eph_iterator->second.d_M_0 = ((double)e->M0)*M_0_LSB;
+			gps_eph_iterator->second.d_Cuc = ((double)e->Cuc)*C_UC_LSB;
+			gps_eph_iterator->second.d_e_eccentricity = ((double)e->e)*E_LSB;
+			gps_eph_iterator->second.d_Cus = ((double)e->Cus)*C_US_LSB;
+			gps_eph_iterator->second.d_sqrt_A = ((double)e->A_sqrt)*SQRT_A_LSB;
+			gps_eph_iterator->second.d_Toe = ((double)e->toe)*T_OE_LSB;
+			//miss fit interval flag (1 bit)
+			gps_eph_iterator->second.i_AODO = e->AODA * AODO_LSB;
+			gps_eph_iterator->second.d_Cic = ((double)e->Cic)*C_IC_LSB;
+			gps_eph_iterator->second.d_OMEGA0 = ((double)e->OMEGA_0)*OMEGA_0_LSB;
+			gps_eph_iterator->second.d_Cis = ((double)e->Cis)*C_IS_LSB;
+			gps_eph_iterator->second.d_i_0 = ((double)e->i0)*I_0_LSB;
+			gps_eph_iterator->second.d_Crs = ((double)e->Crs)*C_RS_LSB;
+			gps_eph_iterator->second.d_OMEGA = ((double)e->w)*OMEGA_LSB;
+			gps_eph_iterator->second.d_OMEGA_DOT = (double)e->OMEGA_dot*OMEGA_DOT_LSB;
+			gps_eph_iterator->second.d_IDOT = ((double)e->i_dot)*I_DOT_LSB;
+		}
+	}
+
+	// READ SV ACQUISITION ASSISTANCE
+
+	  if (assist.cnt_acq) {
+		std::map<int,Gps_Acq_Assist>::iterator gps_acq_iterator;
+		for (int i = 0; i < assist.cnt_acq; i++) {
+			struct supl_acquis_s *e = &assist.acq[i];
+			// Check if the SV is present in the map
+			gps_acq_iterator=this->gps_acq_map.find(e->prn);
+			// the SV is not present in the assistance data -> insert new SV register
+			if (gps_acq_iterator==gps_acq_map.end())
+			{
+				Gps_Acq_Assist gps_acq_assist;
+				gps_acq_map.insert(std::pair<int,Gps_Acq_Assist>(e->prn, gps_acq_assist));
+				gps_acq_iterator=this->gps_acq_map.find(e->prn);
+			}
+			// fill the acquisition assistance structure
+			gps_acq_iterator->second.d_TOW=(double)assist.acq_time;
+			gps_acq_iterator->second.d_Doppler0=(double)e->doppler0;
+			gps_acq_iterator->second.d_Doppler1=(double)e->doppler1;
+			gps_acq_iterator->second.Code_Phase=(double)e->code_ph;
+			gps_acq_iterator->second.Code_Phase_int=(double)e->code_ph_int;
+			gps_acq_iterator->second.Code_Phase_window=(double)e->code_ph_win;
+			gps_acq_iterator->second.Azimuth=(double)e->az;
+			gps_acq_iterator->second.Elevation=(double)e->el;
+			gps_acq_iterator->second.GPS_Bit_Number=(double)e->bit_num;
+
+		}
+	}
+}

src/algorithms/libs/gnss_sdr_supl_client.h

@@ -0,0 +1,112 @@
+/*!
+ * \file supl_client.h
+ * \brief class that implements a C++ interface to external Secure User Location Protocol (SUPL) client library.
+ * \author Javier Arribas, 2013. jarribas(at)cttc.es
+ *
+ * TODO: put here supl.c author info
+ * class that implements a C++ interface to external Secure User Location Protocol (SUPL) client library.
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2013  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef GNSS_SDR_SUPL_CLIENT_H_
+#define GNSS_SDR_SUPL_CLIENT_H_
+
+#include <iostream>
+
+extern "C" {
+#include "supl.h"
+}
+
+#include "GPS_L1_CA.h"
+#include "gps_ephemeris.h"
+#include "gps_iono.h"
+#include "gps_almanac.h"
+#include "gps_utc_model.h"
+#include "gps_acq_assist.h"
+#include "gps_ref_time.h"
+#include "gps_ref_location.h"
+
+/*!
+ * \brief class that implements a C++ interface to external Secure User Location Protocol (SUPL) client library..
+ */
+class gnss_sdr_supl_client
+{
+private:
+
+	// GSM CELL INFO
+	int mcc;
+	int mns;
+	int lac;
+	int ci;
+	// assistance protocol structure
+	supl_ctx_t ctx;
+	// assistance data
+	supl_assist_t assist;
+
+public:
+	// SUPL SERVER INFO
+	std::string server_name;
+	int server_port;
+	int request;
+	// ephemeris map
+	std::map<int,Gps_Ephemeris> gps_ephemeris_map;
+	// almanac map
+	std::map<int,Gps_Almanac> gps_almanac_map;
+
+	// ionospheric model
+	Gps_Iono gps_iono;
+	// reference time
+	Gps_Ref_Time gps_time;
+	// UTC model
+	Gps_Utc_Model gps_utc;
+	// reference location
+	Gps_Ref_Location gps_ref_loc;
+	// Acquisition Assistance map
+	std::map<int,Gps_Acq_Assist> gps_acq_map;
+
+	/*
+	 * \brief Initiates the TCP SSL SUPL connection to the SUPL server and request assistance data using the provided GSM Base station parameters
+	 * \param i_mcc Current network MCC (Mobile country code), 3 digits.
+	 * \param i_mns Current network MNC (Mobile Network code), 2 or 3 digits.
+	 * \param i_lac Current network LAC (Location area code),16 bits, 1-65520 are valid values.
+	 * \param i_ci Cell Identity (16 bits, 0-65535 are valid values).
+	 * \return Error code -> 0 no errors.
+	 */
+	int get_assistance(int i_mcc, int i_mns, int i_lac, int i_ci);
+	/*
+	 * \brief Read the received SUPL data and stores it into the corresponding class members (gps_ephemeris_map, gps_almanac_map, gps_iono, gps_time, gps_utc, gps_acq_map, and gps_ref_loc)
+	 *
+	 */
+	void read_supl_data();
+	/*
+	 * Prints SUPL data to std::cout. Use it for debug purposes only.
+	 */
+	void print_assistance();
+	gnss_sdr_supl_client();
+    ~gnss_sdr_supl_client();
+};
+
+#endif

src/algorithms/libs/supl/CMakeLists.txt

@@ -0,0 +1,37 @@
+# Copyright (C) 2012-2013  (see AUTHORS file for a list of contributors)
+#
+# This file is part of GNSS-SDR.
+#
+# GNSS-SDR is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# at your option) any later version.
+#
+# GNSS-SDR is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+#
+
+file(GLOB  ASN_RRLP_SOURCES "${CMAKE_SOURCE_DIR}/src/algorithms/libs/supl/asn-rrlp/*.c")
+file(GLOB  ASN_SUPL_SOURCES "${CMAKE_SOURCE_DIR}/src/algorithms/libs/supl/asn-supl/*.c")
+
+set (SUPL_SOURCES
+	supl.c
+	)
+
+include_directories(
+	${CMAKE_CURRENT_SOURCE_DIR}
+    ${CMAKE_SOURCE_DIR}/src/algorithms/libs/supl
+	${CMAKE_SOURCE_DIR}/src/algorithms/libs/supl/asn-rrlp
+	${CMAKE_SOURCE_DIR}/src/algorithms/libs/supl/asn-supl
+	)
+	
+	
+
+add_library (supl_library STATIC ${ASN_RRLP_SOURCES} ${ASN_SUPL_SOURCES} ${SUPL_SOURCES})
+target_link_libraries (supl_library ssl) 
+SET_TARGET_PROPERTIES(supl_library PROPERTIES LINKER_LANGUAGE C)

src/algorithms/libs/supl/asn-rrlp/Accuracy.c

@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "Accuracy.h"
+
+int
+Accuracy_constraint(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 <= 127)) {
+		/* 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.
+ */
+static void
+Accuracy_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+Accuracy_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Accuracy_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Accuracy_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Accuracy_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Accuracy_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	Accuracy_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Accuracy_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Accuracy_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Accuracy_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	Accuracy_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Accuracy_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Accuracy_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Accuracy_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Accuracy_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+Accuracy_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Accuracy_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_Accuracy_constr_1 = {
+	{ APC_CONSTRAINED,	 7,  7,  0,  127 }	/* (0..127) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static ber_tlv_tag_t asn_DEF_Accuracy_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Accuracy = {
+	"Accuracy",
+	"Accuracy",
+	Accuracy_free,
+	Accuracy_print,
+	Accuracy_constraint,
+	Accuracy_decode_ber,
+	Accuracy_encode_der,
+	Accuracy_decode_xer,
+	Accuracy_encode_xer,
+	Accuracy_decode_uper,
+	Accuracy_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Accuracy_tags_1,
+	sizeof(asn_DEF_Accuracy_tags_1)
+		/sizeof(asn_DEF_Accuracy_tags_1[0]), /* 1 */
+	asn_DEF_Accuracy_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Accuracy_tags_1)
+		/sizeof(asn_DEF_Accuracy_tags_1[0]), /* 1 */
+	&asn_PER_type_Accuracy_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/algorithms/libs/supl/asn-rrlp/Accuracy.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_Accuracy_H_
+#define	_Accuracy_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Accuracy */
+typedef long	 Accuracy_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Accuracy;
+asn_struct_free_f Accuracy_free;
+asn_struct_print_f Accuracy_print;
+asn_constr_check_f Accuracy_constraint;
+ber_type_decoder_f Accuracy_decode_ber;
+der_type_encoder_f Accuracy_encode_der;
+xer_type_decoder_f Accuracy_decode_xer;
+xer_type_encoder_f Accuracy_encode_xer;
+per_type_decoder_f Accuracy_decode_uper;
+per_type_encoder_f Accuracy_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _Accuracy_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/AccuracyOpt.c

@@ -0,0 +1,61 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "AccuracyOpt.h"
+
+static asn_TYPE_member_t asn_MBR_AccuracyOpt_1[] = {
+	{ ATF_POINTER, 1, offsetof(struct AccuracyOpt, accuracy),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_Accuracy,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"accuracy"
+		},
+};
+static int asn_MAP_AccuracyOpt_oms_1[] = { 0 };
+static ber_tlv_tag_t asn_DEF_AccuracyOpt_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_AccuracyOpt_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* accuracy at 125 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_AccuracyOpt_specs_1 = {
+	sizeof(struct AccuracyOpt),
+	offsetof(struct AccuracyOpt, _asn_ctx),
+	asn_MAP_AccuracyOpt_tag2el_1,
+	1,	/* Count of tags in the map */
+	asn_MAP_AccuracyOpt_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_AccuracyOpt = {
+	"AccuracyOpt",
+	"AccuracyOpt",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AccuracyOpt_tags_1,
+	sizeof(asn_DEF_AccuracyOpt_tags_1)
+		/sizeof(asn_DEF_AccuracyOpt_tags_1[0]), /* 1 */
+	asn_DEF_AccuracyOpt_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AccuracyOpt_tags_1)
+		/sizeof(asn_DEF_AccuracyOpt_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_AccuracyOpt_1,
+	1,	/* Elements count */
+	&asn_SPC_AccuracyOpt_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/AccuracyOpt.h

@@ -0,0 +1,37 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_AccuracyOpt_H_
+#define	_AccuracyOpt_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "Accuracy.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AccuracyOpt */
+typedef struct AccuracyOpt {
+	Accuracy_t	*accuracy	/* OPTIONAL */;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} AccuracyOpt_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AccuracyOpt;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AccuracyOpt_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/AcquisAssist.c

@@ -0,0 +1,69 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "AcquisAssist.h"
+
+static asn_TYPE_member_t asn_MBR_AcquisAssist_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct AcquisAssist, timeRelation),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_TimeRelation,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"timeRelation"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AcquisAssist, acquisList),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SeqOfAcquisElement,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"acquisList"
+		},
+};
+static ber_tlv_tag_t asn_DEF_AcquisAssist_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_AcquisAssist_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* timeRelation at 817 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* acquisList at 822 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_AcquisAssist_specs_1 = {
+	sizeof(struct AcquisAssist),
+	offsetof(struct AcquisAssist, _asn_ctx),
+	asn_MAP_AcquisAssist_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_AcquisAssist = {
+	"AcquisAssist",
+	"AcquisAssist",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AcquisAssist_tags_1,
+	sizeof(asn_DEF_AcquisAssist_tags_1)
+		/sizeof(asn_DEF_AcquisAssist_tags_1[0]), /* 1 */
+	asn_DEF_AcquisAssist_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AcquisAssist_tags_1)
+		/sizeof(asn_DEF_AcquisAssist_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_AcquisAssist_1,
+	2,	/* Elements count */
+	&asn_SPC_AcquisAssist_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/AcquisAssist.h

@@ -0,0 +1,39 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_AcquisAssist_H_
+#define	_AcquisAssist_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "TimeRelation.h"
+#include "SeqOfAcquisElement.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AcquisAssist */
+typedef struct AcquisAssist {
+	TimeRelation_t	 timeRelation;
+	SeqOfAcquisElement_t	 acquisList;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} AcquisAssist_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AcquisAssist;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AcquisAssist_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/AcquisElement.c

@@ -0,0 +1,281 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "AcquisElement.h"
+
+static int
+memb_doppler0_constraint_1(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 >= -2048 && value <= 2047)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_codePhase_constraint_1(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 <= 1022)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_intCodePhase_constraint_1(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 <= 19)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_gpsBitNumber_constraint_1(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 <= 3)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_codePhaseSearchWindow_constraint_1(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 <= 15)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_memb_doppler0_constr_3 = {
+	{ APC_CONSTRAINED,	 12,  12, -2048,  2047 }	/* (-2048..2047) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_codePhase_constr_5 = {
+	{ APC_CONSTRAINED,	 10,  10,  0,  1022 }	/* (0..1022) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_intCodePhase_constr_6 = {
+	{ APC_CONSTRAINED,	 5,  5,  0,  19 }	/* (0..19) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_gpsBitNumber_constr_7 = {
+	{ APC_CONSTRAINED,	 2,  2,  0,  3 }	/* (0..3) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_codePhaseSearchWindow_constr_8 = {
+	{ APC_CONSTRAINED,	 4,  4,  0,  15 }	/* (0..15) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_AcquisElement_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct AcquisElement, svid),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SatelliteID,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"svid"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AcquisElement, doppler0),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_doppler0_constraint_1,
+		&asn_PER_memb_doppler0_constr_3,
+		0,
+		"doppler0"
+		},
+	{ ATF_POINTER, 1, offsetof(struct AcquisElement, addionalDoppler),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_AddionalDopplerFields,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"addionalDoppler"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AcquisElement, codePhase),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_codePhase_constraint_1,
+		&asn_PER_memb_codePhase_constr_5,
+		0,
+		"codePhase"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AcquisElement, intCodePhase),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_intCodePhase_constraint_1,
+		&asn_PER_memb_intCodePhase_constr_6,
+		0,
+		"intCodePhase"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AcquisElement, gpsBitNumber),
+		(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_gpsBitNumber_constraint_1,
+		&asn_PER_memb_gpsBitNumber_constr_7,
+		0,
+		"gpsBitNumber"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AcquisElement, codePhaseSearchWindow),
+		(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_codePhaseSearchWindow_constraint_1,
+		&asn_PER_memb_codePhaseSearchWindow_constr_8,
+		0,
+		"codePhaseSearchWindow"
+		},
+	{ ATF_POINTER, 1, offsetof(struct AcquisElement, addionalAngle),
+		(ASN_TAG_CLASS_CONTEXT | (7 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_AddionalAngleFields,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"addionalAngle"
+		},
+};
+static int asn_MAP_AcquisElement_oms_1[] = { 2, 7 };
+static ber_tlv_tag_t asn_DEF_AcquisElement_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_AcquisElement_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* svid at 834 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* doppler0 at 838 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* addionalDoppler at 839 */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* codePhase at 840 */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* intCodePhase at 841 */
+    { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* gpsBitNumber at 842 */
+    { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* codePhaseSearchWindow at 843 */
+    { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 } /* addionalAngle at 844 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_AcquisElement_specs_1 = {
+	sizeof(struct AcquisElement),
+	offsetof(struct AcquisElement, _asn_ctx),
+	asn_MAP_AcquisElement_tag2el_1,
+	8,	/* Count of tags in the map */
+	asn_MAP_AcquisElement_oms_1,	/* Optional members */
+	2, 0,	/* Root/Additions */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_AcquisElement = {
+	"AcquisElement",
+	"AcquisElement",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AcquisElement_tags_1,
+	sizeof(asn_DEF_AcquisElement_tags_1)
+		/sizeof(asn_DEF_AcquisElement_tags_1[0]), /* 1 */
+	asn_DEF_AcquisElement_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AcquisElement_tags_1)
+		/sizeof(asn_DEF_AcquisElement_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_AcquisElement_1,
+	8,	/* Elements count */
+	&asn_SPC_AcquisElement_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/AcquisElement.h

@@ -0,0 +1,53 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_AcquisElement_H_
+#define	_AcquisElement_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "SatelliteID.h"
+#include <NativeInteger.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct AddionalDopplerFields;
+struct AddionalAngleFields;
+
+/* AcquisElement */
+typedef struct AcquisElement {
+	SatelliteID_t	 svid;
+	long	 doppler0;
+	struct AddionalDopplerFields	*addionalDoppler	/* OPTIONAL */;
+	long	 codePhase;
+	long	 intCodePhase;
+	long	 gpsBitNumber;
+	long	 codePhaseSearchWindow;
+	struct AddionalAngleFields	*addionalAngle	/* OPTIONAL */;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} AcquisElement_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AcquisElement;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "AddionalDopplerFields.h"
+#include "AddionalAngleFields.h"
+
+#endif	/* _AcquisElement_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/AddionalAngleFields.c

@@ -0,0 +1,129 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "AddionalAngleFields.h"
+
+static int
+memb_azimuth_constraint_1(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 <= 31)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_elevation_constraint_1(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;
+	}
+}
+
+static asn_per_constraints_t asn_PER_memb_azimuth_constr_2 = {
+	{ APC_CONSTRAINED,	 5,  5,  0,  31 }	/* (0..31) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_elevation_constr_3 = {
+	{ APC_CONSTRAINED,	 3,  3,  0,  7 }	/* (0..7) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_AddionalAngleFields_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct AddionalAngleFields, azimuth),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_azimuth_constraint_1,
+		&asn_PER_memb_azimuth_constr_2,
+		0,
+		"azimuth"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AddionalAngleFields, elevation),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_elevation_constraint_1,
+		&asn_PER_memb_elevation_constr_3,
+		0,
+		"elevation"
+		},
+};
+static ber_tlv_tag_t asn_DEF_AddionalAngleFields_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_AddionalAngleFields_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* azimuth at 858 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* elevation at 860 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_AddionalAngleFields_specs_1 = {
+	sizeof(struct AddionalAngleFields),
+	offsetof(struct AddionalAngleFields, _asn_ctx),
+	asn_MAP_AddionalAngleFields_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_AddionalAngleFields = {
+	"AddionalAngleFields",
+	"AddionalAngleFields",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AddionalAngleFields_tags_1,
+	sizeof(asn_DEF_AddionalAngleFields_tags_1)
+		/sizeof(asn_DEF_AddionalAngleFields_tags_1[0]), /* 1 */
+	asn_DEF_AddionalAngleFields_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AddionalAngleFields_tags_1)
+		/sizeof(asn_DEF_AddionalAngleFields_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_AddionalAngleFields_1,
+	2,	/* Elements count */
+	&asn_SPC_AddionalAngleFields_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/AddionalAngleFields.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_AddionalAngleFields_H_
+#define	_AddionalAngleFields_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AddionalAngleFields */
+typedef struct AddionalAngleFields {
+	long	 azimuth;
+	long	 elevation;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} AddionalAngleFields_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AddionalAngleFields;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AddionalAngleFields_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/AddionalDopplerFields.c

@@ -0,0 +1,129 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "AddionalDopplerFields.h"
+
+static int
+memb_doppler1_constraint_1(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 <= 63)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_dopplerUncertainty_constraint_1(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;
+	}
+}
+
+static asn_per_constraints_t asn_PER_memb_doppler1_constr_2 = {
+	{ APC_CONSTRAINED,	 6,  6,  0,  63 }	/* (0..63) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_dopplerUncertainty_constr_3 = {
+	{ APC_CONSTRAINED,	 3,  3,  0,  7 }	/* (0..7) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_AddionalDopplerFields_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct AddionalDopplerFields, doppler1),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_doppler1_constraint_1,
+		&asn_PER_memb_doppler1_constr_2,
+		0,
+		"doppler1"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AddionalDopplerFields, dopplerUncertainty),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_dopplerUncertainty_constraint_1,
+		&asn_PER_memb_dopplerUncertainty_constr_3,
+		0,
+		"dopplerUncertainty"
+		},
+};
+static ber_tlv_tag_t asn_DEF_AddionalDopplerFields_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_AddionalDopplerFields_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* doppler1 at 850 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* dopplerUncertainty at 851 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_AddionalDopplerFields_specs_1 = {
+	sizeof(struct AddionalDopplerFields),
+	offsetof(struct AddionalDopplerFields, _asn_ctx),
+	asn_MAP_AddionalDopplerFields_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_AddionalDopplerFields = {
+	"AddionalDopplerFields",
+	"AddionalDopplerFields",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AddionalDopplerFields_tags_1,
+	sizeof(asn_DEF_AddionalDopplerFields_tags_1)
+		/sizeof(asn_DEF_AddionalDopplerFields_tags_1[0]), /* 1 */
+	asn_DEF_AddionalDopplerFields_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AddionalDopplerFields_tags_1)
+		/sizeof(asn_DEF_AddionalDopplerFields_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_AddionalDopplerFields_1,
+	2,	/* Elements count */
+	&asn_SPC_AddionalDopplerFields_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/AddionalDopplerFields.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_AddionalDopplerFields_H_
+#define	_AddionalDopplerFields_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AddionalDopplerFields */
+typedef struct AddionalDopplerFields {
+	long	 doppler1;
+	long	 dopplerUncertainty;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} AddionalDopplerFields_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AddionalDopplerFields;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AddionalDopplerFields_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/AdditionalAssistanceData.c

@@ -0,0 +1,81 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "AdditionalAssistanceData.h"
+
+static asn_TYPE_member_t asn_MBR_AdditionalAssistanceData_1[] = {
+	{ ATF_POINTER, 3, offsetof(struct AdditionalAssistanceData, gpsAssistanceData),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GPSAssistanceData,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"gpsAssistanceData"
+		},
+	{ ATF_POINTER, 2, offsetof(struct AdditionalAssistanceData, extensionContainer),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ExtensionContainer,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"extensionContainer"
+		},
+	{ ATF_POINTER, 1, offsetof(struct AdditionalAssistanceData, ganssAssistanceData),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GANSSAssistanceData,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"ganssAssistanceData"
+		},
+};
+static int asn_MAP_AdditionalAssistanceData_oms_1[] = { 0, 1, 2 };
+static ber_tlv_tag_t asn_DEF_AdditionalAssistanceData_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_AdditionalAssistanceData_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* gpsAssistanceData at 520 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* extensionContainer at 521 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* ganssAssistanceData at 523 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_AdditionalAssistanceData_specs_1 = {
+	sizeof(struct AdditionalAssistanceData),
+	offsetof(struct AdditionalAssistanceData, _asn_ctx),
+	asn_MAP_AdditionalAssistanceData_tag2el_1,
+	3,	/* Count of tags in the map */
+	asn_MAP_AdditionalAssistanceData_oms_1,	/* Optional members */
+	2, 1,	/* Root/Additions */
+	1,	/* Start extensions */
+	4	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_AdditionalAssistanceData = {
+	"AdditionalAssistanceData",
+	"AdditionalAssistanceData",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AdditionalAssistanceData_tags_1,
+	sizeof(asn_DEF_AdditionalAssistanceData_tags_1)
+		/sizeof(asn_DEF_AdditionalAssistanceData_tags_1[0]), /* 1 */
+	asn_DEF_AdditionalAssistanceData_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AdditionalAssistanceData_tags_1)
+		/sizeof(asn_DEF_AdditionalAssistanceData_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_AdditionalAssistanceData_1,
+	3,	/* Elements count */
+	&asn_SPC_AdditionalAssistanceData_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/AdditionalAssistanceData.h

@@ -0,0 +1,45 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_AdditionalAssistanceData_H_
+#define	_AdditionalAssistanceData_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "GPSAssistanceData.h"
+#include "ExtensionContainer.h"
+#include "GANSSAssistanceData.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AdditionalAssistanceData */
+typedef struct AdditionalAssistanceData {
+	GPSAssistanceData_t	*gpsAssistanceData	/* OPTIONAL */;
+	ExtensionContainer_t	*extensionContainer	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	GANSSAssistanceData_t	*ganssAssistanceData	/* OPTIONAL */;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} AdditionalAssistanceData_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AdditionalAssistanceData;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AdditionalAssistanceData_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/AdditionalDopplerFields.c

@@ -0,0 +1,129 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "AdditionalDopplerFields.h"
+
+static int
+memb_doppler1_constraint_1(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 <= 63)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_dopplerUncertainty_constraint_1(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 <= 4)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_memb_doppler1_constr_2 = {
+	{ APC_CONSTRAINED,	 6,  6,  0,  63 }	/* (0..63) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_dopplerUncertainty_constr_3 = {
+	{ APC_CONSTRAINED,	 3,  3,  0,  4 }	/* (0..4) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_AdditionalDopplerFields_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct AdditionalDopplerFields, doppler1),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_doppler1_constraint_1,
+		&asn_PER_memb_doppler1_constr_2,
+		0,
+		"doppler1"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AdditionalDopplerFields, dopplerUncertainty),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_dopplerUncertainty_constraint_1,
+		&asn_PER_memb_dopplerUncertainty_constr_3,
+		0,
+		"dopplerUncertainty"
+		},
+};
+static ber_tlv_tag_t asn_DEF_AdditionalDopplerFields_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_AdditionalDopplerFields_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* doppler1 at 1342 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* dopplerUncertainty at 1343 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_AdditionalDopplerFields_specs_1 = {
+	sizeof(struct AdditionalDopplerFields),
+	offsetof(struct AdditionalDopplerFields, _asn_ctx),
+	asn_MAP_AdditionalDopplerFields_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_AdditionalDopplerFields = {
+	"AdditionalDopplerFields",
+	"AdditionalDopplerFields",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AdditionalDopplerFields_tags_1,
+	sizeof(asn_DEF_AdditionalDopplerFields_tags_1)
+		/sizeof(asn_DEF_AdditionalDopplerFields_tags_1[0]), /* 1 */
+	asn_DEF_AdditionalDopplerFields_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AdditionalDopplerFields_tags_1)
+		/sizeof(asn_DEF_AdditionalDopplerFields_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_AdditionalDopplerFields_1,
+	2,	/* Elements count */
+	&asn_SPC_AdditionalDopplerFields_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/AdditionalDopplerFields.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_AdditionalDopplerFields_H_
+#define	_AdditionalDopplerFields_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AdditionalDopplerFields */
+typedef struct AdditionalDopplerFields {
+	long	 doppler1;
+	long	 dopplerUncertainty;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} AdditionalDopplerFields_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AdditionalDopplerFields;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AdditionalDopplerFields_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/AlertFlag.c

@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "AlertFlag.h"
+
+int
+AlertFlag_constraint(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 <= 1)) {
+		/* 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.
+ */
+static void
+AlertFlag_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+AlertFlag_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	AlertFlag_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+AlertFlag_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	AlertFlag_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+AlertFlag_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	AlertFlag_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+AlertFlag_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	AlertFlag_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+AlertFlag_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	AlertFlag_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+AlertFlag_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	AlertFlag_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+AlertFlag_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	AlertFlag_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+AlertFlag_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	AlertFlag_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_AlertFlag_constr_1 = {
+	{ APC_CONSTRAINED,	 1,  1,  0,  1 }	/* (0..1) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static ber_tlv_tag_t asn_DEF_AlertFlag_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_AlertFlag = {
+	"AlertFlag",
+	"AlertFlag",
+	AlertFlag_free,
+	AlertFlag_print,
+	AlertFlag_constraint,
+	AlertFlag_decode_ber,
+	AlertFlag_encode_der,
+	AlertFlag_decode_xer,
+	AlertFlag_encode_xer,
+	AlertFlag_decode_uper,
+	AlertFlag_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AlertFlag_tags_1,
+	sizeof(asn_DEF_AlertFlag_tags_1)
+		/sizeof(asn_DEF_AlertFlag_tags_1[0]), /* 1 */
+	asn_DEF_AlertFlag_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AlertFlag_tags_1)
+		/sizeof(asn_DEF_AlertFlag_tags_1[0]), /* 1 */
+	&asn_PER_type_AlertFlag_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/algorithms/libs/supl/asn-rrlp/AlertFlag.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_AlertFlag_H_
+#define	_AlertFlag_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AlertFlag */
+typedef long	 AlertFlag_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AlertFlag;
+asn_struct_free_f AlertFlag_free;
+asn_struct_print_f AlertFlag_print;
+asn_constr_check_f AlertFlag_constraint;
+ber_type_decoder_f AlertFlag_decode_ber;
+der_type_encoder_f AlertFlag_encode_der;
+xer_type_decoder_f AlertFlag_decode_xer;
+xer_type_encoder_f AlertFlag_encode_xer;
+per_type_decoder_f AlertFlag_decode_uper;
+per_type_encoder_f AlertFlag_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AlertFlag_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/Almanac-KeplerianSet.c

@@ -0,0 +1,449 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "Almanac-KeplerianSet.h"
+
+static int
+memb_kepAlmanacE_constraint_1(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 <= 2047)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_kepAlmanacDeltaI_constraint_1(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 >= -1024 && value <= 1023)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_kepAlmanacOmegaDot_constraint_1(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 >= -1024 && value <= 1023)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_kepSVHealth_constraint_1(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 <= 15)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_kepAlmanacAPowerHalf_constraint_1(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 >= -65536 && 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;
+	}
+}
+
+static int
+memb_kepAlmanacOmega0_constraint_1(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 >= -32768 && value <= 32767)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_kepAlmanacW_constraint_1(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 >= -32768 && value <= 32767)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_kepAlmanacM0_constraint_1(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 >= -32768 && value <= 32767)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_kepAlmanacAF0_constraint_1(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 >= -8192 && value <= 8191)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_kepAlmanacAF1_constraint_1(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 >= -1024 && value <= 1023)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_memb_kepAlmanacE_constr_2 = {
+	{ APC_CONSTRAINED,	 11,  11,  0,  2047 }	/* (0..2047) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_kepAlmanacDeltaI_constr_3 = {
+	{ APC_CONSTRAINED,	 11,  11, -1024,  1023 }	/* (-1024..1023) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_kepAlmanacOmegaDot_constr_4 = {
+	{ APC_CONSTRAINED,	 11,  11, -1024,  1023 }	/* (-1024..1023) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_kepSVHealth_constr_5 = {
+	{ APC_CONSTRAINED,	 4,  4,  0,  15 }	/* (0..15) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_kepAlmanacAPowerHalf_constr_6 = {
+	{ APC_CONSTRAINED,	 17, -1, -65536,  65535 }	/* (-65536..65535) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_kepAlmanacOmega0_constr_7 = {
+	{ APC_CONSTRAINED,	 16,  16, -32768,  32767 }	/* (-32768..32767) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_kepAlmanacW_constr_8 = {
+	{ APC_CONSTRAINED,	 16,  16, -32768,  32767 }	/* (-32768..32767) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_kepAlmanacM0_constr_9 = {
+	{ APC_CONSTRAINED,	 16,  16, -32768,  32767 }	/* (-32768..32767) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_kepAlmanacAF0_constr_10 = {
+	{ APC_CONSTRAINED,	 14,  14, -8192,  8191 }	/* (-8192..8191) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_kepAlmanacAF1_constr_11 = {
+	{ APC_CONSTRAINED,	 11,  11, -1024,  1023 }	/* (-1024..1023) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_Almanac_KeplerianSet_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Almanac_KeplerianSet, kepAlmanacE),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_kepAlmanacE_constraint_1,
+		&asn_PER_memb_kepAlmanacE_constr_2,
+		0,
+		"kepAlmanacE"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Almanac_KeplerianSet, kepAlmanacDeltaI),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_kepAlmanacDeltaI_constraint_1,
+		&asn_PER_memb_kepAlmanacDeltaI_constr_3,
+		0,
+		"kepAlmanacDeltaI"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Almanac_KeplerianSet, kepAlmanacOmegaDot),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_kepAlmanacOmegaDot_constraint_1,
+		&asn_PER_memb_kepAlmanacOmegaDot_constr_4,
+		0,
+		"kepAlmanacOmegaDot"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Almanac_KeplerianSet, kepSVHealth),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_kepSVHealth_constraint_1,
+		&asn_PER_memb_kepSVHealth_constr_5,
+		0,
+		"kepSVHealth"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Almanac_KeplerianSet, kepAlmanacAPowerHalf),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_kepAlmanacAPowerHalf_constraint_1,
+		&asn_PER_memb_kepAlmanacAPowerHalf_constr_6,
+		0,
+		"kepAlmanacAPowerHalf"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Almanac_KeplerianSet, kepAlmanacOmega0),
+		(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_kepAlmanacOmega0_constraint_1,
+		&asn_PER_memb_kepAlmanacOmega0_constr_7,
+		0,
+		"kepAlmanacOmega0"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Almanac_KeplerianSet, kepAlmanacW),
+		(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_kepAlmanacW_constraint_1,
+		&asn_PER_memb_kepAlmanacW_constr_8,
+		0,
+		"kepAlmanacW"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Almanac_KeplerianSet, kepAlmanacM0),
+		(ASN_TAG_CLASS_CONTEXT | (7 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_kepAlmanacM0_constraint_1,
+		&asn_PER_memb_kepAlmanacM0_constr_9,
+		0,
+		"kepAlmanacM0"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Almanac_KeplerianSet, kepAlmanacAF0),
+		(ASN_TAG_CLASS_CONTEXT | (8 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_kepAlmanacAF0_constraint_1,
+		&asn_PER_memb_kepAlmanacAF0_constr_10,
+		0,
+		"kepAlmanacAF0"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Almanac_KeplerianSet, kepAlmanacAF1),
+		(ASN_TAG_CLASS_CONTEXT | (9 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_kepAlmanacAF1_constraint_1,
+		&asn_PER_memb_kepAlmanacAF1_constr_11,
+		0,
+		"kepAlmanacAF1"
+		},
+};
+static ber_tlv_tag_t asn_DEF_Almanac_KeplerianSet_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_Almanac_KeplerianSet_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* kepAlmanacE at 1368 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* kepAlmanacDeltaI at 1369 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* kepAlmanacOmegaDot at 1370 */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* kepSVHealth at 1371 */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* kepAlmanacAPowerHalf at 1372 */
+    { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* kepAlmanacOmega0 at 1373 */
+    { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* kepAlmanacW at 1374 */
+    { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 }, /* kepAlmanacM0 at 1375 */
+    { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 }, /* kepAlmanacAF0 at 1376 */
+    { (ASN_TAG_CLASS_CONTEXT | (9 << 2)), 9, 0, 0 } /* kepAlmanacAF1 at 1377 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_Almanac_KeplerianSet_specs_1 = {
+	sizeof(struct Almanac_KeplerianSet),
+	offsetof(struct Almanac_KeplerianSet, _asn_ctx),
+	asn_MAP_Almanac_KeplerianSet_tag2el_1,
+	10,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_Almanac_KeplerianSet = {
+	"Almanac-KeplerianSet",
+	"Almanac-KeplerianSet",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Almanac_KeplerianSet_tags_1,
+	sizeof(asn_DEF_Almanac_KeplerianSet_tags_1)
+		/sizeof(asn_DEF_Almanac_KeplerianSet_tags_1[0]), /* 1 */
+	asn_DEF_Almanac_KeplerianSet_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Almanac_KeplerianSet_tags_1)
+		/sizeof(asn_DEF_Almanac_KeplerianSet_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_Almanac_KeplerianSet_1,
+	10,	/* Elements count */
+	&asn_SPC_Almanac_KeplerianSet_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/Almanac-KeplerianSet.h

@@ -0,0 +1,46 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_Almanac_KeplerianSet_H_
+#define	_Almanac_KeplerianSet_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Almanac-KeplerianSet */
+typedef struct Almanac_KeplerianSet {
+	long	 kepAlmanacE;
+	long	 kepAlmanacDeltaI;
+	long	 kepAlmanacOmegaDot;
+	long	 kepSVHealth;
+	long	 kepAlmanacAPowerHalf;
+	long	 kepAlmanacOmega0;
+	long	 kepAlmanacW;
+	long	 kepAlmanacM0;
+	long	 kepAlmanacAF0;
+	long	 kepAlmanacAF1;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} Almanac_KeplerianSet_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Almanac_KeplerianSet;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _Almanac_KeplerianSet_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/Almanac.c

@@ -0,0 +1,99 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "Almanac.h"
+
+static int
+memb_alamanacWNa_constraint_1(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 <= 255)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_memb_alamanacWNa_constr_2 = {
+	{ APC_CONSTRAINED,	 8,  8,  0,  255 }	/* (0..255) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_Almanac_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Almanac, alamanacWNa),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_alamanacWNa_constraint_1,
+		&asn_PER_memb_alamanacWNa_constr_2,
+		0,
+		"alamanacWNa"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Almanac, almanacList),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SeqOfAlmanacElement,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"almanacList"
+		},
+};
+static ber_tlv_tag_t asn_DEF_Almanac_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_Almanac_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* alamanacWNa at 789 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* almanacList at 794 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_Almanac_specs_1 = {
+	sizeof(struct Almanac),
+	offsetof(struct Almanac, _asn_ctx),
+	asn_MAP_Almanac_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_Almanac = {
+	"Almanac",
+	"Almanac",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Almanac_tags_1,
+	sizeof(asn_DEF_Almanac_tags_1)
+		/sizeof(asn_DEF_Almanac_tags_1[0]), /* 1 */
+	asn_DEF_Almanac_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Almanac_tags_1)
+		/sizeof(asn_DEF_Almanac_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_Almanac_1,
+	2,	/* Elements count */
+	&asn_SPC_Almanac_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/Almanac.h

@@ -0,0 +1,39 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_Almanac_H_
+#define	_Almanac_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+#include "SeqOfAlmanacElement.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Almanac */
+typedef struct Almanac {
+	long	 alamanacWNa;
+	SeqOfAlmanacElement_t	 almanacList;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} Almanac_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Almanac;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _Almanac_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/AlmanacElement.c

@@ -0,0 +1,499 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "AlmanacElement.h"
+
+static int
+memb_almanacE_constraint_1(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;
+	}
+}
+
+static int
+memb_alamanacToa_constraint_1(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 <= 255)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_almanacKsii_constraint_1(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 >= -32768 && value <= 32767)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_almanacOmegaDot_constraint_1(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 >= -32768 && value <= 32767)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_almanacSVhealth_constraint_1(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 <= 255)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_almanacAPowerHalf_constraint_1(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 <= 16777215)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_almanacOmega0_constraint_1(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 >= -8388608 && value <= 8388607)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_almanacW_constraint_1(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 >= -8388608 && value <= 8388607)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_almanacM0_constraint_1(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 >= -8388608 && value <= 8388607)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_almanacAF0_constraint_1(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 >= -1024 && value <= 1023)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_almanacAF1_constraint_1(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 >= -1024 && value <= 1023)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_memb_almanacE_constr_3 = {
+	{ APC_CONSTRAINED,	 16,  16,  0,  65535 }	/* (0..65535) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_alamanacToa_constr_4 = {
+	{ APC_CONSTRAINED,	 8,  8,  0,  255 }	/* (0..255) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_almanacKsii_constr_5 = {
+	{ APC_CONSTRAINED,	 16,  16, -32768,  32767 }	/* (-32768..32767) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_almanacOmegaDot_constr_6 = {
+	{ APC_CONSTRAINED,	 16,  16, -32768,  32767 }	/* (-32768..32767) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_almanacSVhealth_constr_7 = {
+	{ APC_CONSTRAINED,	 8,  8,  0,  255 }	/* (0..255) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_almanacAPowerHalf_constr_8 = {
+	{ APC_CONSTRAINED,	 24, -1,  0,  16777215 }	/* (0..16777215) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_almanacOmega0_constr_9 = {
+	{ APC_CONSTRAINED,	 24, -1, -8388608,  8388607 }	/* (-8388608..8388607) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_almanacW_constr_10 = {
+	{ APC_CONSTRAINED,	 24, -1, -8388608,  8388607 }	/* (-8388608..8388607) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_almanacM0_constr_11 = {
+	{ APC_CONSTRAINED,	 24, -1, -8388608,  8388607 }	/* (-8388608..8388607) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_almanacAF0_constr_12 = {
+	{ APC_CONSTRAINED,	 11,  11, -1024,  1023 }	/* (-1024..1023) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_almanacAF1_constr_13 = {
+	{ APC_CONSTRAINED,	 11,  11, -1024,  1023 }	/* (-1024..1023) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_AlmanacElement_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct AlmanacElement, satelliteID),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SatelliteID,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"satelliteID"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AlmanacElement, almanacE),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_almanacE_constraint_1,
+		&asn_PER_memb_almanacE_constr_3,
+		0,
+		"almanacE"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AlmanacElement, alamanacToa),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_alamanacToa_constraint_1,
+		&asn_PER_memb_alamanacToa_constr_4,
+		0,
+		"alamanacToa"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AlmanacElement, almanacKsii),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_almanacKsii_constraint_1,
+		&asn_PER_memb_almanacKsii_constr_5,
+		0,
+		"almanacKsii"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AlmanacElement, almanacOmegaDot),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_almanacOmegaDot_constraint_1,
+		&asn_PER_memb_almanacOmegaDot_constr_6,
+		0,
+		"almanacOmegaDot"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AlmanacElement, almanacSVhealth),
+		(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_almanacSVhealth_constraint_1,
+		&asn_PER_memb_almanacSVhealth_constr_7,
+		0,
+		"almanacSVhealth"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AlmanacElement, almanacAPowerHalf),
+		(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_almanacAPowerHalf_constraint_1,
+		&asn_PER_memb_almanacAPowerHalf_constr_8,
+		0,
+		"almanacAPowerHalf"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AlmanacElement, almanacOmega0),
+		(ASN_TAG_CLASS_CONTEXT | (7 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_almanacOmega0_constraint_1,
+		&asn_PER_memb_almanacOmega0_constr_9,
+		0,
+		"almanacOmega0"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AlmanacElement, almanacW),
+		(ASN_TAG_CLASS_CONTEXT | (8 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_almanacW_constraint_1,
+		&asn_PER_memb_almanacW_constr_10,
+		0,
+		"almanacW"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AlmanacElement, almanacM0),
+		(ASN_TAG_CLASS_CONTEXT | (9 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_almanacM0_constraint_1,
+		&asn_PER_memb_almanacM0_constr_11,
+		0,
+		"almanacM0"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AlmanacElement, almanacAF0),
+		(ASN_TAG_CLASS_CONTEXT | (10 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_almanacAF0_constraint_1,
+		&asn_PER_memb_almanacAF0_constr_12,
+		0,
+		"almanacAF0"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AlmanacElement, almanacAF1),
+		(ASN_TAG_CLASS_CONTEXT | (11 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_almanacAF1_constraint_1,
+		&asn_PER_memb_almanacAF1_constr_13,
+		0,
+		"almanacAF1"
+		},
+};
+static ber_tlv_tag_t asn_DEF_AlmanacElement_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_AlmanacElement_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* satelliteID at 799 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* almanacE at 800 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* alamanacToa at 801 */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* almanacKsii at 802 */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* almanacOmegaDot at 803 */
+    { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* almanacSVhealth at 804 */
+    { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* almanacAPowerHalf at 805 */
+    { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 }, /* almanacOmega0 at 806 */
+    { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 }, /* almanacW at 807 */
+    { (ASN_TAG_CLASS_CONTEXT | (9 << 2)), 9, 0, 0 }, /* almanacM0 at 808 */
+    { (ASN_TAG_CLASS_CONTEXT | (10 << 2)), 10, 0, 0 }, /* almanacAF0 at 809 */
+    { (ASN_TAG_CLASS_CONTEXT | (11 << 2)), 11, 0, 0 } /* almanacAF1 at 810 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_AlmanacElement_specs_1 = {
+	sizeof(struct AlmanacElement),
+	offsetof(struct AlmanacElement, _asn_ctx),
+	asn_MAP_AlmanacElement_tag2el_1,
+	12,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_AlmanacElement = {
+	"AlmanacElement",
+	"AlmanacElement",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AlmanacElement_tags_1,
+	sizeof(asn_DEF_AlmanacElement_tags_1)
+		/sizeof(asn_DEF_AlmanacElement_tags_1[0]), /* 1 */
+	asn_DEF_AlmanacElement_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AlmanacElement_tags_1)
+		/sizeof(asn_DEF_AlmanacElement_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_AlmanacElement_1,
+	12,	/* Elements count */
+	&asn_SPC_AlmanacElement_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/AlmanacElement.h

@@ -0,0 +1,49 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_AlmanacElement_H_
+#define	_AlmanacElement_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "SatelliteID.h"
+#include <NativeInteger.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AlmanacElement */
+typedef struct AlmanacElement {
+	SatelliteID_t	 satelliteID;
+	long	 almanacE;
+	long	 alamanacToa;
+	long	 almanacKsii;
+	long	 almanacOmegaDot;
+	long	 almanacSVhealth;
+	long	 almanacAPowerHalf;
+	long	 almanacOmega0;
+	long	 almanacW;
+	long	 almanacM0;
+	long	 almanacAF0;
+	long	 almanacAF1;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} AlmanacElement_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AlmanacElement;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AlmanacElement_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/AntiSpoofFlag.c

@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "AntiSpoofFlag.h"
+
+int
+AntiSpoofFlag_constraint(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 <= 1)) {
+		/* 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.
+ */
+static void
+AntiSpoofFlag_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+AntiSpoofFlag_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	AntiSpoofFlag_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+AntiSpoofFlag_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	AntiSpoofFlag_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+AntiSpoofFlag_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	AntiSpoofFlag_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+AntiSpoofFlag_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	AntiSpoofFlag_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+AntiSpoofFlag_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	AntiSpoofFlag_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+AntiSpoofFlag_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	AntiSpoofFlag_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+AntiSpoofFlag_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	AntiSpoofFlag_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+AntiSpoofFlag_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	AntiSpoofFlag_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_AntiSpoofFlag_constr_1 = {
+	{ APC_CONSTRAINED,	 1,  1,  0,  1 }	/* (0..1) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static ber_tlv_tag_t asn_DEF_AntiSpoofFlag_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_AntiSpoofFlag = {
+	"AntiSpoofFlag",
+	"AntiSpoofFlag",
+	AntiSpoofFlag_free,
+	AntiSpoofFlag_print,
+	AntiSpoofFlag_constraint,
+	AntiSpoofFlag_decode_ber,
+	AntiSpoofFlag_encode_der,
+	AntiSpoofFlag_decode_xer,
+	AntiSpoofFlag_encode_xer,
+	AntiSpoofFlag_decode_uper,
+	AntiSpoofFlag_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AntiSpoofFlag_tags_1,
+	sizeof(asn_DEF_AntiSpoofFlag_tags_1)
+		/sizeof(asn_DEF_AntiSpoofFlag_tags_1[0]), /* 1 */
+	asn_DEF_AntiSpoofFlag_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AntiSpoofFlag_tags_1)
+		/sizeof(asn_DEF_AntiSpoofFlag_tags_1[0]), /* 1 */
+	&asn_PER_type_AntiSpoofFlag_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/algorithms/libs/supl/asn-rrlp/AntiSpoofFlag.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_AntiSpoofFlag_H_
+#define	_AntiSpoofFlag_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AntiSpoofFlag */
+typedef long	 AntiSpoofFlag_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AntiSpoofFlag;
+asn_struct_free_f AntiSpoofFlag_free;
+asn_struct_print_f AntiSpoofFlag_print;
+asn_constr_check_f AntiSpoofFlag_constraint;
+ber_type_decoder_f AntiSpoofFlag_decode_ber;
+der_type_encoder_f AntiSpoofFlag_encode_der;
+xer_type_decoder_f AntiSpoofFlag_decode_xer;
+xer_type_encoder_f AntiSpoofFlag_encode_xer;
+per_type_decoder_f AntiSpoofFlag_decode_uper;
+per_type_encoder_f AntiSpoofFlag_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AntiSpoofFlag_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/AssistBTSData-R98-ExpOTD.c

@@ -0,0 +1,69 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "AssistBTSData-R98-ExpOTD.h"
+
+static asn_TYPE_member_t asn_MBR_AssistBTSData_R98_ExpOTD_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct AssistBTSData_R98_ExpOTD, expectedOTD),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ExpectedOTD,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"expectedOTD"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AssistBTSData_R98_ExpOTD, expOTDuncertainty),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ExpOTDUncertainty,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"expOTDuncertainty"
+		},
+};
+static ber_tlv_tag_t asn_DEF_AssistBTSData_R98_ExpOTD_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_AssistBTSData_R98_ExpOTD_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* expectedOTD at 933 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* expOTDuncertainty at 935 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_AssistBTSData_R98_ExpOTD_specs_1 = {
+	sizeof(struct AssistBTSData_R98_ExpOTD),
+	offsetof(struct AssistBTSData_R98_ExpOTD, _asn_ctx),
+	asn_MAP_AssistBTSData_R98_ExpOTD_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_AssistBTSData_R98_ExpOTD = {
+	"AssistBTSData-R98-ExpOTD",
+	"AssistBTSData-R98-ExpOTD",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AssistBTSData_R98_ExpOTD_tags_1,
+	sizeof(asn_DEF_AssistBTSData_R98_ExpOTD_tags_1)
+		/sizeof(asn_DEF_AssistBTSData_R98_ExpOTD_tags_1[0]), /* 1 */
+	asn_DEF_AssistBTSData_R98_ExpOTD_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AssistBTSData_R98_ExpOTD_tags_1)
+		/sizeof(asn_DEF_AssistBTSData_R98_ExpOTD_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_AssistBTSData_R98_ExpOTD_1,
+	2,	/* Elements count */
+	&asn_SPC_AssistBTSData_R98_ExpOTD_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/AssistBTSData-R98-ExpOTD.h

@@ -0,0 +1,39 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_AssistBTSData_R98_ExpOTD_H_
+#define	_AssistBTSData_R98_ExpOTD_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "ExpectedOTD.h"
+#include "ExpOTDUncertainty.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AssistBTSData-R98-ExpOTD */
+typedef struct AssistBTSData_R98_ExpOTD {
+	ExpectedOTD_t	 expectedOTD;
+	ExpOTDUncertainty_t	 expOTDuncertainty;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} AssistBTSData_R98_ExpOTD_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AssistBTSData_R98_ExpOTD;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AssistBTSData_R98_ExpOTD_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/AssistBTSData.c

@@ -0,0 +1,101 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "AssistBTSData.h"
+
+static asn_TYPE_member_t asn_MBR_AssistBTSData_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct AssistBTSData, bsic),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_BSIC,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"bsic"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AssistBTSData, multiFrameOffset),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_MultiFrameOffset,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"multiFrameOffset"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AssistBTSData, timeSlotScheme),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_TimeSlotScheme,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"timeSlotScheme"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AssistBTSData, roughRTD),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RoughRTD,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"roughRTD"
+		},
+	{ ATF_POINTER, 1, offsetof(struct AssistBTSData, calcAssistanceBTS),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_CalcAssistanceBTS,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"calcAssistanceBTS"
+		},
+};
+static int asn_MAP_AssistBTSData_oms_1[] = { 4 };
+static ber_tlv_tag_t asn_DEF_AssistBTSData_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_AssistBTSData_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* bsic at 229 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* multiFrameOffset at 230 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* timeSlotScheme at 231 */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* roughRTD at 232 */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* calcAssistanceBTS at 235 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_AssistBTSData_specs_1 = {
+	sizeof(struct AssistBTSData),
+	offsetof(struct AssistBTSData, _asn_ctx),
+	asn_MAP_AssistBTSData_tag2el_1,
+	5,	/* Count of tags in the map */
+	asn_MAP_AssistBTSData_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_AssistBTSData = {
+	"AssistBTSData",
+	"AssistBTSData",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AssistBTSData_tags_1,
+	sizeof(asn_DEF_AssistBTSData_tags_1)
+		/sizeof(asn_DEF_AssistBTSData_tags_1[0]), /* 1 */
+	asn_DEF_AssistBTSData_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AssistBTSData_tags_1)
+		/sizeof(asn_DEF_AssistBTSData_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_AssistBTSData_1,
+	5,	/* Elements count */
+	&asn_SPC_AssistBTSData_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/AssistBTSData.h

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_AssistBTSData_H_
+#define	_AssistBTSData_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "BSIC.h"
+#include "MultiFrameOffset.h"
+#include "TimeSlotScheme.h"
+#include "RoughRTD.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct CalcAssistanceBTS;
+
+/* AssistBTSData */
+typedef struct AssistBTSData {
+	BSIC_t	 bsic;
+	MultiFrameOffset_t	 multiFrameOffset;
+	TimeSlotScheme_t	 timeSlotScheme;
+	RoughRTD_t	 roughRTD;
+	struct CalcAssistanceBTS	*calcAssistanceBTS	/* OPTIONAL */;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} AssistBTSData_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AssistBTSData;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "CalcAssistanceBTS.h"
+
+#endif	/* _AssistBTSData_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/AssistanceData.c

@@ -0,0 +1,131 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "AssistanceData.h"
+
+static asn_TYPE_member_t asn_MBR_AssistanceData_1[] = {
+	{ ATF_POINTER, 8, offsetof(struct AssistanceData, referenceAssistData),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ReferenceAssistData,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"referenceAssistData"
+		},
+	{ ATF_POINTER, 7, offsetof(struct AssistanceData, msrAssistData),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_MsrAssistData,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"msrAssistData"
+		},
+	{ ATF_POINTER, 6, offsetof(struct AssistanceData, systemInfoAssistData),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SystemInfoAssistData,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"systemInfoAssistData"
+		},
+	{ ATF_POINTER, 5, offsetof(struct AssistanceData, gps_AssistData),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GPS_AssistData,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"gps-AssistData"
+		},
+	{ ATF_POINTER, 4, offsetof(struct AssistanceData, moreAssDataToBeSent),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_MoreAssDataToBeSent,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"moreAssDataToBeSent"
+		},
+	{ ATF_POINTER, 3, offsetof(struct AssistanceData, extensionContainer),
+		(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ExtensionContainer,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"extensionContainer"
+		},
+	{ ATF_POINTER, 2, offsetof(struct AssistanceData, rel98_AssistanceData_Extension),
+		(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_Rel98_AssistanceData_Extension,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"rel98-AssistanceData-Extension"
+		},
+	{ ATF_POINTER, 1, offsetof(struct AssistanceData, rel5_AssistanceData_Extension),
+		(ASN_TAG_CLASS_CONTEXT | (7 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_Rel5_AssistanceData_Extension,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"rel5-AssistanceData-Extension"
+		},
+};
+static int asn_MAP_AssistanceData_oms_1[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
+static ber_tlv_tag_t asn_DEF_AssistanceData_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_AssistanceData_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* referenceAssistData at 75 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* msrAssistData at 76 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* systemInfoAssistData at 77 */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* gps-AssistData at 78 */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* moreAssDataToBeSent at 79 */
+    { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* extensionContainer at 83 */
+    { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* rel98-AssistanceData-Extension at 86 */
+    { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 } /* rel5-AssistanceData-Extension at 87 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_AssistanceData_specs_1 = {
+	sizeof(struct AssistanceData),
+	offsetof(struct AssistanceData, _asn_ctx),
+	asn_MAP_AssistanceData_tag2el_1,
+	8,	/* Count of tags in the map */
+	asn_MAP_AssistanceData_oms_1,	/* Optional members */
+	6, 2,	/* Root/Additions */
+	5,	/* Start extensions */
+	9	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_AssistanceData = {
+	"AssistanceData",
+	"AssistanceData",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AssistanceData_tags_1,
+	sizeof(asn_DEF_AssistanceData_tags_1)
+		/sizeof(asn_DEF_AssistanceData_tags_1[0]), /* 1 */
+	asn_DEF_AssistanceData_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AssistanceData_tags_1)
+		/sizeof(asn_DEF_AssistanceData_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_AssistanceData_1,
+	8,	/* Elements count */
+	&asn_SPC_AssistanceData_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/AssistanceData.h

@@ -0,0 +1,65 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_AssistanceData_H_
+#define	_AssistanceData_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "MoreAssDataToBeSent.h"
+#include "ExtensionContainer.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct ReferenceAssistData;
+struct MsrAssistData;
+struct SystemInfoAssistData;
+struct GPS_AssistData;
+struct Rel98_AssistanceData_Extension;
+struct Rel5_AssistanceData_Extension;
+
+/* AssistanceData */
+typedef struct AssistanceData {
+	struct ReferenceAssistData	*referenceAssistData	/* OPTIONAL */;
+	struct MsrAssistData	*msrAssistData	/* OPTIONAL */;
+	struct SystemInfoAssistData	*systemInfoAssistData	/* OPTIONAL */;
+	struct GPS_AssistData	*gps_AssistData	/* OPTIONAL */;
+	MoreAssDataToBeSent_t	*moreAssDataToBeSent	/* OPTIONAL */;
+	ExtensionContainer_t	*extensionContainer	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	struct Rel98_AssistanceData_Extension	*rel98_AssistanceData_Extension	/* OPTIONAL */;
+	struct Rel5_AssistanceData_Extension	*rel5_AssistanceData_Extension	/* OPTIONAL */;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} AssistanceData_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AssistanceData;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "ReferenceAssistData.h"
+#include "MsrAssistData.h"
+#include "SystemInfoAssistData.h"
+#include "GPS-AssistData.h"
+#include "Rel98-AssistanceData-Extension.h"
+#include "Rel5-AssistanceData-Extension.h"
+
+#endif	/* _AssistanceData_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/BCCHCarrier.c

@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "BCCHCarrier.h"
+
+int
+BCCHCarrier_constraint(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 <= 1023)) {
+		/* 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.
+ */
+static void
+BCCHCarrier_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+BCCHCarrier_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	BCCHCarrier_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+BCCHCarrier_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	BCCHCarrier_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+BCCHCarrier_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	BCCHCarrier_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+BCCHCarrier_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	BCCHCarrier_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+BCCHCarrier_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	BCCHCarrier_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+BCCHCarrier_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	BCCHCarrier_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+BCCHCarrier_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	BCCHCarrier_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+BCCHCarrier_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	BCCHCarrier_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_BCCHCarrier_constr_1 = {
+	{ APC_CONSTRAINED,	 10,  10,  0,  1023 }	/* (0..1023) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static ber_tlv_tag_t asn_DEF_BCCHCarrier_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_BCCHCarrier = {
+	"BCCHCarrier",
+	"BCCHCarrier",
+	BCCHCarrier_free,
+	BCCHCarrier_print,
+	BCCHCarrier_constraint,
+	BCCHCarrier_decode_ber,
+	BCCHCarrier_encode_der,
+	BCCHCarrier_decode_xer,
+	BCCHCarrier_encode_xer,
+	BCCHCarrier_decode_uper,
+	BCCHCarrier_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_BCCHCarrier_tags_1,
+	sizeof(asn_DEF_BCCHCarrier_tags_1)
+		/sizeof(asn_DEF_BCCHCarrier_tags_1[0]), /* 1 */
+	asn_DEF_BCCHCarrier_tags_1,	/* Same as above */
+	sizeof(asn_DEF_BCCHCarrier_tags_1)
+		/sizeof(asn_DEF_BCCHCarrier_tags_1[0]), /* 1 */
+	&asn_PER_type_BCCHCarrier_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/algorithms/libs/supl/asn-rrlp/BCCHCarrier.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_BCCHCarrier_H_
+#define	_BCCHCarrier_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BCCHCarrier */
+typedef long	 BCCHCarrier_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_BCCHCarrier;
+asn_struct_free_f BCCHCarrier_free;
+asn_struct_print_f BCCHCarrier_print;
+asn_constr_check_f BCCHCarrier_constraint;
+ber_type_decoder_f BCCHCarrier_decode_ber;
+der_type_encoder_f BCCHCarrier_encode_der;
+xer_type_decoder_f BCCHCarrier_decode_xer;
+xer_type_encoder_f BCCHCarrier_encode_xer;
+per_type_decoder_f BCCHCarrier_decode_uper;
+per_type_encoder_f BCCHCarrier_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BCCHCarrier_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/BIT_STRING.c

@@ -0,0 +1,189 @@
+/*-
+ * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <BIT_STRING.h>
+#include <asn_internal.h>
+
+/*
+ * BIT STRING basic type description.
+ */
+static ber_tlv_tag_t asn_DEF_BIT_STRING_tags[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+static asn_OCTET_STRING_specifics_t asn_DEF_BIT_STRING_specs = {
+	sizeof(BIT_STRING_t),
+	offsetof(BIT_STRING_t, _asn_ctx),
+	ASN_OSUBV_BIT
+};
+asn_TYPE_descriptor_t asn_DEF_BIT_STRING = {
+	"BIT STRING",
+	"BIT_STRING",
+	OCTET_STRING_free,         /* Implemented in terms of OCTET STRING */
+	BIT_STRING_print,
+	BIT_STRING_constraint,
+	OCTET_STRING_decode_ber,   /* Implemented in terms of OCTET STRING */
+	OCTET_STRING_encode_der,   /* Implemented in terms of OCTET STRING */
+	OCTET_STRING_decode_xer_binary,
+	BIT_STRING_encode_xer,
+	OCTET_STRING_decode_uper,	/* Unaligned PER decoder */
+	OCTET_STRING_encode_uper,	/* Unaligned PER encoder */
+	0, /* Use generic outmost tag fetcher */
+	asn_DEF_BIT_STRING_tags,
+	sizeof(asn_DEF_BIT_STRING_tags)
+	  / sizeof(asn_DEF_BIT_STRING_tags[0]),
+	asn_DEF_BIT_STRING_tags,	/* Same as above */
+	sizeof(asn_DEF_BIT_STRING_tags)
+	  / sizeof(asn_DEF_BIT_STRING_tags[0]),
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	&asn_DEF_BIT_STRING_specs
+};
+
+/*
+ * BIT STRING generic constraint.
+ */
+int
+BIT_STRING_constraint(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;
+
+	if(st && st->buf) {
+		if((st->size == 0 && st->bits_unused)
+		|| st->bits_unused < 0 || st->bits_unused > 7) {
+			_ASN_CTFAIL(app_key, td, sptr,
+				"%s: invalid padding byte (%s:%d)",
+				td->name, __FILE__, __LINE__);
+			return -1;
+		}
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+
+	return 0;
+}
+
+static char *_bit_pattern[16] = {
+	"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111",
+	"1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"
+};
+
+asn_enc_rval_t
+BIT_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+	int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	asn_enc_rval_t er;
+	char scratch[128];
+	char *p = scratch;
+	char *scend = scratch + (sizeof(scratch) - 10);
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+	int xcan = (flags & XER_F_CANONICAL);
+	uint8_t *buf;
+	uint8_t *end;
+
+	if(!st || !st->buf)
+		_ASN_ENCODE_FAILED;
+
+	er.encoded = 0;
+
+	buf = st->buf;
+	end = buf + st->size - 1;	/* Last byte is special */
+
+	/*
+	 * Binary dump
+	 */
+	for(; buf < end; buf++) {
+		int v = *buf;
+		int nline = xcan?0:(((buf - st->buf) % 8) == 0);
+		if(p >= scend || nline) {
+			er.encoded += p - scratch;
+			_ASN_CALLBACK(scratch, p - scratch);
+			p = scratch;
+			if(nline) _i_ASN_TEXT_INDENT(1, ilevel);
+		}
+		memcpy(p + 0, _bit_pattern[v >> 4], 4);
+		memcpy(p + 4, _bit_pattern[v & 0x0f], 4);
+		p += 8;
+	}
+
+	if(!xcan && ((buf - st->buf) % 8) == 0)
+		_i_ASN_TEXT_INDENT(1, ilevel);
+	er.encoded += p - scratch;
+	_ASN_CALLBACK(scratch, p - scratch);
+	p = scratch;
+
+	if(buf == end) {
+		int v = *buf;
+		int ubits = st->bits_unused;
+		int i;
+		for(i = 7; i >= ubits; i--)
+			*p++ = (v & (1 << i)) ? 0x31 : 0x30;
+		er.encoded += p - scratch;
+		_ASN_CALLBACK(scratch, p - scratch);
+	}
+
+	if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel - 1);
+
+	_ASN_ENCODED_OK(er);
+cb_failed:
+	_ASN_ENCODE_FAILED;
+}
+
+
+/*
+ * BIT STRING specific contents printer.
+ */
+int
+BIT_STRING_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	static const char *h2c = "0123456789ABCDEF";
+	char scratch[64];
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+	uint8_t *buf;
+	uint8_t *end;
+	char *p = scratch;
+
+	(void)td;	/* Unused argument */
+
+	if(!st || !st->buf)
+		return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
+
+	ilevel++;
+	buf = st->buf;
+	end = buf + st->size;
+
+	/*
+	 * Hexadecimal dump.
+	 */
+	for(; buf < end; buf++) {
+		if((buf - st->buf) % 16 == 0 && (st->size > 16)
+				&& buf != st->buf) {
+			_i_INDENT(1);
+			/* Dump the string */
+			if(cb(scratch, p - scratch, app_key) < 0) return -1;
+			p = scratch;
+		}
+		*p++ = h2c[*buf >> 4];
+		*p++ = h2c[*buf & 0x0F];
+		*p++ = 0x20;
+	}
+
+	if(p > scratch) {
+		p--;	/* Eat the tailing space */
+
+		if((st->size > 16)) {
+			_i_INDENT(1);
+		}
+
+		/* Dump the incomplete 16-bytes row */
+		if(cb(scratch, p - scratch, app_key) < 0)
+			return -1;
+	}
+
+	return 0;
+}
+

src/algorithms/libs/supl/asn-rrlp/BIT_STRING.h

@@ -0,0 +1,33 @@
+/*-
+ * Copyright (c) 2003 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 */
+	int 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;
+
+asn_struct_print_f BIT_STRING_print;	/* Human-readable output */
+asn_constr_check_f BIT_STRING_constraint;
+xer_type_encoder_f BIT_STRING_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BIT_STRING_H_ */

src/algorithms/libs/supl/asn-rrlp/BOOLEAN.c

@@ -0,0 +1,284 @@
+/*-
+ * Copyright (c) 2003, 2005 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <asn_codecs_prim.h>
+#include <BOOLEAN.h>
+
+/*
+ * BOOLEAN basic type description.
+ */
+static ber_tlv_tag_t asn_DEF_BOOLEAN_tags[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (1 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_BOOLEAN = {
+	"BOOLEAN",
+	"BOOLEAN",
+	BOOLEAN_free,
+	BOOLEAN_print,
+	asn_generic_no_constraint,
+	BOOLEAN_decode_ber,
+	BOOLEAN_encode_der,
+	BOOLEAN_decode_xer,
+	BOOLEAN_encode_xer,
+	BOOLEAN_decode_uper,	/* Unaligned PER decoder */
+	BOOLEAN_encode_uper,	/* Unaligned PER encoder */
+	0, /* Use generic outmost tag fetcher */
+	asn_DEF_BOOLEAN_tags,
+	sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]),
+	asn_DEF_BOOLEAN_tags,	/* Same as above */
+	sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]),
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+/*
+ * Decode BOOLEAN type.
+ */
+asn_dec_rval_t
+BOOLEAN_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
+		asn_TYPE_descriptor_t *td,
+		void **bool_value, const void *buf_ptr, size_t size,
+		int tag_mode) {
+	BOOLEAN_t *st = (BOOLEAN_t *)*bool_value;
+	asn_dec_rval_t rval;
+	ber_tlv_len_t length;
+	ber_tlv_len_t lidx;
+
+	if(st == NULL) {
+		st = (BOOLEAN_t *)(*bool_value = CALLOC(1, sizeof(*st)));
+		if(st == NULL) {
+			rval.code = RC_FAIL;
+			rval.consumed = 0;
+			return rval;
+		}
+	}
+
+	ASN_DEBUG("Decoding %s as BOOLEAN (tm=%d)",
+		td->name, tag_mode);
+
+	/*
+	 * Check tags.
+	 */
+	rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size,
+		tag_mode, 0, &length, 0);
+	if(rval.code != RC_OK)
+		return rval;
+
+	ASN_DEBUG("Boolean length is %d bytes", (int)length);
+
+	buf_ptr = ((const char *)buf_ptr) + rval.consumed;
+	size -= rval.consumed;
+	if(length > (ber_tlv_len_t)size) {
+		rval.code = RC_WMORE;
+		rval.consumed = 0;
+		return rval;
+	}
+
+	/*
+	 * Compute boolean value.
+	 */
+	for(*st = 0, lidx = 0;
+		(lidx < length) && *st == 0; lidx++) {
+		/*
+		 * Very simple approach: read bytes until the end or
+		 * value is already TRUE.
+		 * BOOLEAN is not supposed to contain meaningful data anyway.
+		 */
+		*st |= ((const uint8_t *)buf_ptr)[lidx];
+	}
+
+	rval.code = RC_OK;
+	rval.consumed += length;
+
+	ASN_DEBUG("Took %ld/%ld bytes to encode %s, value=%d",
+		(long)rval.consumed, (long)length,
+		td->name, *st);
+	
+	return rval;
+}
+
+asn_enc_rval_t
+BOOLEAN_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
+	int tag_mode, ber_tlv_tag_t tag,
+	asn_app_consume_bytes_f *cb, void *app_key) {
+	asn_enc_rval_t erval;
+	BOOLEAN_t *st = (BOOLEAN_t *)sptr;
+
+	erval.encoded = der_write_tags(td, 1, tag_mode, 0, tag, cb, app_key);
+	if(erval.encoded == -1) {
+		erval.failed_type = td;
+		erval.structure_ptr = sptr;
+		return erval;
+	}
+
+	if(cb) {
+		uint8_t bool_value;
+
+		bool_value = *st ? 0xff : 0; /* 0xff mandated by DER */
+
+		if(cb(&bool_value, 1, app_key) < 0) {
+			erval.encoded = -1;
+			erval.failed_type = td;
+			erval.structure_ptr = sptr;
+			return erval;
+		}
+	}
+
+	erval.encoded += 1;
+
+	_ASN_ENCODED_OK(erval);
+}
+
+
+/*
+ * Decode the chunk of XML text encoding INTEGER.
+ */
+static enum xer_pbd_rval
+BOOLEAN__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) {
+	BOOLEAN_t *st = (BOOLEAN_t *)sptr;
+	const char *p = (const char *)chunk_buf;
+
+	(void)td;
+
+	if(chunk_size && p[0] == 0x3c /* '<' */) {
+		switch(xer_check_tag(chunk_buf, chunk_size, "false")) {
+		case XCT_BOTH:
+			/* "<false/>" */
+			*st = 0;
+			break;
+		case XCT_UNKNOWN_BO:
+			if(xer_check_tag(chunk_buf, chunk_size, "true")
+					!= XCT_BOTH)
+				return XPBD_BROKEN_ENCODING;
+			/* "<true/>" */
+			*st = 1;	/* Or 0xff as in DER?.. */
+			break;
+		default:
+			return XPBD_BROKEN_ENCODING;
+		}
+		return XPBD_BODY_CONSUMED;
+	} else {
+		if(xer_is_whitespace(chunk_buf, chunk_size))
+			return XPBD_NOT_BODY_IGNORE;
+		else
+			return XPBD_BROKEN_ENCODING;
+	}
+}
+
+
+asn_dec_rval_t
+BOOLEAN_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
+	asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
+		const void *buf_ptr, size_t size) {
+
+	return xer_decode_primitive(opt_codec_ctx, td,
+		sptr, sizeof(BOOLEAN_t), opt_mname, buf_ptr, size,
+		BOOLEAN__xer_body_decode);
+}
+
+asn_enc_rval_t
+BOOLEAN_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+	int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
+	asn_enc_rval_t er;
+
+	(void)ilevel;
+	(void)flags;
+
+	if(!st) _ASN_ENCODE_FAILED;
+
+	if(*st) {
+		_ASN_CALLBACK("<true/>", 7);
+		er.encoded = 7;
+	} else {
+		_ASN_CALLBACK("<false/>", 8);
+		er.encoded = 8;
+	}
+
+	_ASN_ENCODED_OK(er);
+cb_failed:
+	_ASN_ENCODE_FAILED;
+}
+
+int
+BOOLEAN_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+	asn_app_consume_bytes_f *cb, void *app_key) {
+	const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
+	const char *buf;
+	size_t buflen;
+
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
+	if(st) {
+		if(*st) {
+			buf = "TRUE";
+			buflen = 4;
+		} else {
+			buf = "FALSE";
+			buflen = 5;
+		}
+	} else {
+		buf = "<absent>";
+		buflen = 8;
+	}
+
+	return (cb(buf, buflen, app_key) < 0) ? -1 : 0;
+}
+
+void
+BOOLEAN_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
+	if(td && ptr && !contents_only) {
+		FREEMEM(ptr);
+	}
+}
+
+asn_dec_rval_t
+BOOLEAN_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
+	asn_dec_rval_t rv;
+	BOOLEAN_t *st = (BOOLEAN_t *)*sptr;
+
+	(void)opt_codec_ctx;
+	(void)constraints;
+
+	if(!st) {
+		st = (BOOLEAN_t *)(*sptr = MALLOC(sizeof(*st)));
+		if(!st) _ASN_DECODE_FAILED;
+	}
+
+	/*
+	 * Extract a single bit
+	 */
+	switch(per_get_few_bits(pd, 1)) {
+	case 1: *st = 1; break;
+	case 0: *st = 0; break;
+	case -1: default: _ASN_DECODE_STARVED;
+	}
+
+	ASN_DEBUG("%s decoded as %s", td->name, *st ? "TRUE" : "FALSE");
+
+	rv.code = RC_OK;
+	rv.consumed = 1;
+	return rv;
+}
+
+
+asn_enc_rval_t
+BOOLEAN_encode_uper(asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
+	const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
+	asn_enc_rval_t er;
+
+	(void)constraints;
+
+	if(!st) _ASN_ENCODE_FAILED;
+
+	per_put_few_bits(po, *st ? 1 : 0, 1);
+
+	_ASN_ENCODED_OK(er);
+}

src/algorithms/libs/supl/asn-rrlp/BOOLEAN.h

@@ -0,0 +1,36 @@
+/*-
+ * Copyright (c) 2003 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;
+
+asn_struct_free_f BOOLEAN_free;
+asn_struct_print_f BOOLEAN_print;
+ber_type_decoder_f BOOLEAN_decode_ber;
+der_type_encoder_f BOOLEAN_encode_der;
+xer_type_decoder_f BOOLEAN_decode_xer;
+xer_type_encoder_f BOOLEAN_encode_xer;
+per_type_decoder_f BOOLEAN_decode_uper;
+per_type_encoder_f BOOLEAN_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BOOLEAN_H_ */

src/algorithms/libs/supl/asn-rrlp/BSIC.c

@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "BSIC.h"
+
+int
+BSIC_constraint(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 <= 63)) {
+		/* 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.
+ */
+static void
+BSIC_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+BSIC_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	BSIC_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+BSIC_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	BSIC_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+BSIC_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	BSIC_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+BSIC_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	BSIC_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+BSIC_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	BSIC_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+BSIC_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	BSIC_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+BSIC_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	BSIC_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+BSIC_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	BSIC_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_BSIC_constr_1 = {
+	{ APC_CONSTRAINED,	 6,  6,  0,  63 }	/* (0..63) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static ber_tlv_tag_t asn_DEF_BSIC_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_BSIC = {
+	"BSIC",
+	"BSIC",
+	BSIC_free,
+	BSIC_print,
+	BSIC_constraint,
+	BSIC_decode_ber,
+	BSIC_encode_der,
+	BSIC_decode_xer,
+	BSIC_encode_xer,
+	BSIC_decode_uper,
+	BSIC_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_BSIC_tags_1,
+	sizeof(asn_DEF_BSIC_tags_1)
+		/sizeof(asn_DEF_BSIC_tags_1[0]), /* 1 */
+	asn_DEF_BSIC_tags_1,	/* Same as above */
+	sizeof(asn_DEF_BSIC_tags_1)
+		/sizeof(asn_DEF_BSIC_tags_1[0]), /* 1 */
+	&asn_PER_type_BSIC_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/algorithms/libs/supl/asn-rrlp/BSIC.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_BSIC_H_
+#define	_BSIC_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BSIC */
+typedef long	 BSIC_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_BSIC;
+asn_struct_free_f BSIC_free;
+asn_struct_print_f BSIC_print;
+asn_constr_check_f BSIC_constraint;
+ber_type_decoder_f BSIC_decode_ber;
+der_type_encoder_f BSIC_encode_der;
+xer_type_decoder_f BSIC_decode_xer;
+xer_type_encoder_f BSIC_encode_xer;
+per_type_decoder_f BSIC_decode_uper;
+per_type_encoder_f BSIC_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BSIC_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/BSICAndCarrier.c

@@ -0,0 +1,69 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "BSICAndCarrier.h"
+
+static asn_TYPE_member_t asn_MBR_BSICAndCarrier_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct BSICAndCarrier, carrier),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_BCCHCarrier,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"carrier"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct BSICAndCarrier, bsic),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_BSIC,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"bsic"
+		},
+};
+static ber_tlv_tag_t asn_DEF_BSICAndCarrier_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_BSICAndCarrier_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* carrier at 304 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* bsic at 306 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_BSICAndCarrier_specs_1 = {
+	sizeof(struct BSICAndCarrier),
+	offsetof(struct BSICAndCarrier, _asn_ctx),
+	asn_MAP_BSICAndCarrier_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_BSICAndCarrier = {
+	"BSICAndCarrier",
+	"BSICAndCarrier",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_BSICAndCarrier_tags_1,
+	sizeof(asn_DEF_BSICAndCarrier_tags_1)
+		/sizeof(asn_DEF_BSICAndCarrier_tags_1[0]), /* 1 */
+	asn_DEF_BSICAndCarrier_tags_1,	/* Same as above */
+	sizeof(asn_DEF_BSICAndCarrier_tags_1)
+		/sizeof(asn_DEF_BSICAndCarrier_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_BSICAndCarrier_1,
+	2,	/* Elements count */
+	&asn_SPC_BSICAndCarrier_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/BSICAndCarrier.h

@@ -0,0 +1,39 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_BSICAndCarrier_H_
+#define	_BSICAndCarrier_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "BCCHCarrier.h"
+#include "BSIC.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BSICAndCarrier */
+typedef struct BSICAndCarrier {
+	BCCHCarrier_t	 carrier;
+	BSIC_t	 bsic;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} BSICAndCarrier_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_BSICAndCarrier;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BSICAndCarrier_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/BTSPosition.c

@@ -0,0 +1,141 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "BTSPosition.h"
+
+int
+BTSPosition_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const Ext_GeographicalInformation_t *st = (const Ext_GeographicalInformation_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;
+	}
+	
+	size = st->size;
+	
+	if((size >= 1 && size <= 20)) {
+		/* 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 Ext_GeographicalInformation,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+BTSPosition_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_Ext_GeographicalInformation.free_struct;
+	td->print_struct   = asn_DEF_Ext_GeographicalInformation.print_struct;
+	td->ber_decoder    = asn_DEF_Ext_GeographicalInformation.ber_decoder;
+	td->der_encoder    = asn_DEF_Ext_GeographicalInformation.der_encoder;
+	td->xer_decoder    = asn_DEF_Ext_GeographicalInformation.xer_decoder;
+	td->xer_encoder    = asn_DEF_Ext_GeographicalInformation.xer_encoder;
+	td->uper_decoder   = asn_DEF_Ext_GeographicalInformation.uper_decoder;
+	td->uper_encoder   = asn_DEF_Ext_GeographicalInformation.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Ext_GeographicalInformation.per_constraints;
+	td->elements       = asn_DEF_Ext_GeographicalInformation.elements;
+	td->elements_count = asn_DEF_Ext_GeographicalInformation.elements_count;
+	td->specifics      = asn_DEF_Ext_GeographicalInformation.specifics;
+}
+
+void
+BTSPosition_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	BTSPosition_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+BTSPosition_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	BTSPosition_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+BTSPosition_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	BTSPosition_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+BTSPosition_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	BTSPosition_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+BTSPosition_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	BTSPosition_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+BTSPosition_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	BTSPosition_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+BTSPosition_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	BTSPosition_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+BTSPosition_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	BTSPosition_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static ber_tlv_tag_t asn_DEF_BTSPosition_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_BTSPosition = {
+	"BTSPosition",
+	"BTSPosition",
+	BTSPosition_free,
+	BTSPosition_print,
+	BTSPosition_constraint,
+	BTSPosition_decode_ber,
+	BTSPosition_encode_der,
+	BTSPosition_decode_xer,
+	BTSPosition_encode_xer,
+	BTSPosition_decode_uper,
+	BTSPosition_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_BTSPosition_tags_1,
+	sizeof(asn_DEF_BTSPosition_tags_1)
+		/sizeof(asn_DEF_BTSPosition_tags_1[0]), /* 1 */
+	asn_DEF_BTSPosition_tags_1,	/* Same as above */
+	sizeof(asn_DEF_BTSPosition_tags_1)
+		/sizeof(asn_DEF_BTSPosition_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/algorithms/libs/supl/asn-rrlp/BTSPosition.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_BTSPosition_H_
+#define	_BTSPosition_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "Ext-GeographicalInformation.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BTSPosition */
+typedef Ext_GeographicalInformation_t	 BTSPosition_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_BTSPosition;
+asn_struct_free_f BTSPosition_free;
+asn_struct_print_f BTSPosition_print;
+asn_constr_check_f BTSPosition_constraint;
+ber_type_decoder_f BTSPosition_decode_ber;
+der_type_encoder_f BTSPosition_encode_der;
+xer_type_decoder_f BTSPosition_decode_xer;
+xer_type_encoder_f BTSPosition_encode_xer;
+per_type_decoder_f BTSPosition_decode_uper;
+per_type_encoder_f BTSPosition_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BTSPosition_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/BadSignalElement.c

@@ -0,0 +1,101 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "BadSignalElement.h"
+
+static int
+memb_badSignalID_constraint_1(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 <= 3)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_memb_badSignalID_constr_3 = {
+	{ APC_CONSTRAINED,	 2,  2,  0,  3 }	/* (0..3) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_BadSignalElement_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct BadSignalElement, badSVID),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SVID,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"badSVID"
+		},
+	{ ATF_POINTER, 1, offsetof(struct BadSignalElement, badSignalID),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_badSignalID_constraint_1,
+		&asn_PER_memb_badSignalID_constr_3,
+		0,
+		"badSignalID"
+		},
+};
+static int asn_MAP_BadSignalElement_oms_1[] = { 1 };
+static ber_tlv_tag_t asn_DEF_BadSignalElement_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_BadSignalElement_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* badSVID at 1300 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* badSignalID at 1301 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_BadSignalElement_specs_1 = {
+	sizeof(struct BadSignalElement),
+	offsetof(struct BadSignalElement, _asn_ctx),
+	asn_MAP_BadSignalElement_tag2el_1,
+	2,	/* Count of tags in the map */
+	asn_MAP_BadSignalElement_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_BadSignalElement = {
+	"BadSignalElement",
+	"BadSignalElement",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_BadSignalElement_tags_1,
+	sizeof(asn_DEF_BadSignalElement_tags_1)
+		/sizeof(asn_DEF_BadSignalElement_tags_1[0]), /* 1 */
+	asn_DEF_BadSignalElement_tags_1,	/* Same as above */
+	sizeof(asn_DEF_BadSignalElement_tags_1)
+		/sizeof(asn_DEF_BadSignalElement_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_BadSignalElement_1,
+	2,	/* Elements count */
+	&asn_SPC_BadSignalElement_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/BadSignalElement.h

@@ -0,0 +1,39 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_BadSignalElement_H_
+#define	_BadSignalElement_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "SVID.h"
+#include <NativeInteger.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BadSignalElement */
+typedef struct BadSignalElement {
+	SVID_t	 badSVID;
+	long	*badSignalID	/* OPTIONAL */;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} BadSignalElement_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_BadSignalElement;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BadSignalElement_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/BitNumber.c

@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "BitNumber.h"
+
+int
+BitNumber_constraint(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 <= 156)) {
+		/* 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.
+ */
+static void
+BitNumber_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+BitNumber_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	BitNumber_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+BitNumber_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	BitNumber_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+BitNumber_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	BitNumber_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+BitNumber_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	BitNumber_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+BitNumber_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	BitNumber_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+BitNumber_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	BitNumber_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+BitNumber_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	BitNumber_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+BitNumber_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	BitNumber_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_BitNumber_constr_1 = {
+	{ APC_CONSTRAINED,	 8,  8,  0,  156 }	/* (0..156) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static ber_tlv_tag_t asn_DEF_BitNumber_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_BitNumber = {
+	"BitNumber",
+	"BitNumber",
+	BitNumber_free,
+	BitNumber_print,
+	BitNumber_constraint,
+	BitNumber_decode_ber,
+	BitNumber_encode_der,
+	BitNumber_decode_xer,
+	BitNumber_encode_xer,
+	BitNumber_decode_uper,
+	BitNumber_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_BitNumber_tags_1,
+	sizeof(asn_DEF_BitNumber_tags_1)
+		/sizeof(asn_DEF_BitNumber_tags_1[0]), /* 1 */
+	asn_DEF_BitNumber_tags_1,	/* Same as above */
+	sizeof(asn_DEF_BitNumber_tags_1)
+		/sizeof(asn_DEF_BitNumber_tags_1[0]), /* 1 */
+	&asn_PER_type_BitNumber_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/algorithms/libs/supl/asn-rrlp/BitNumber.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_BitNumber_H_
+#define	_BitNumber_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BitNumber */
+typedef long	 BitNumber_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_BitNumber;
+asn_struct_free_f BitNumber_free;
+asn_struct_print_f BitNumber_print;
+asn_constr_check_f BitNumber_constraint;
+ber_type_decoder_f BitNumber_decode_ber;
+der_type_encoder_f BitNumber_encode_der;
+xer_type_decoder_f BitNumber_decode_xer;
+xer_type_encoder_f BitNumber_encode_xer;
+per_type_decoder_f BitNumber_decode_uper;
+per_type_encoder_f BitNumber_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BitNumber_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/CalcAssistanceBTS.c

@@ -0,0 +1,69 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "CalcAssistanceBTS.h"
+
+static asn_TYPE_member_t asn_MBR_CalcAssistanceBTS_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct CalcAssistanceBTS, fineRTD),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_FineRTD,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"fineRTD"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct CalcAssistanceBTS, referenceWGS84),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ReferenceWGS84,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"referenceWGS84"
+		},
+};
+static ber_tlv_tag_t asn_DEF_CalcAssistanceBTS_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_CalcAssistanceBTS_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* fineRTD at 241 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* referenceWGS84 at 243 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_CalcAssistanceBTS_specs_1 = {
+	sizeof(struct CalcAssistanceBTS),
+	offsetof(struct CalcAssistanceBTS, _asn_ctx),
+	asn_MAP_CalcAssistanceBTS_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_CalcAssistanceBTS = {
+	"CalcAssistanceBTS",
+	"CalcAssistanceBTS",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CalcAssistanceBTS_tags_1,
+	sizeof(asn_DEF_CalcAssistanceBTS_tags_1)
+		/sizeof(asn_DEF_CalcAssistanceBTS_tags_1[0]), /* 1 */
+	asn_DEF_CalcAssistanceBTS_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CalcAssistanceBTS_tags_1)
+		/sizeof(asn_DEF_CalcAssistanceBTS_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_CalcAssistanceBTS_1,
+	2,	/* Elements count */
+	&asn_SPC_CalcAssistanceBTS_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/CalcAssistanceBTS.h

@@ -0,0 +1,39 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_CalcAssistanceBTS_H_
+#define	_CalcAssistanceBTS_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "FineRTD.h"
+#include "ReferenceWGS84.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CalcAssistanceBTS */
+typedef struct CalcAssistanceBTS {
+	FineRTD_t	 fineRTD;
+	ReferenceWGS84_t	 referenceWGS84;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} CalcAssistanceBTS_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CalcAssistanceBTS;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CalcAssistanceBTS_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/CellID.c

@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "CellID.h"
+
+int
+CellID_constraint(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 NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CellID_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+CellID_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CellID_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CellID_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CellID_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CellID_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CellID_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CellID_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CellID_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CellID_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CellID_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CellID_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CellID_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+CellID_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	CellID_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+CellID_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	CellID_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_CellID_constr_1 = {
+	{ APC_CONSTRAINED,	 16,  16,  0,  65535 }	/* (0..65535) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static ber_tlv_tag_t asn_DEF_CellID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CellID = {
+	"CellID",
+	"CellID",
+	CellID_free,
+	CellID_print,
+	CellID_constraint,
+	CellID_decode_ber,
+	CellID_encode_der,
+	CellID_decode_xer,
+	CellID_encode_xer,
+	CellID_decode_uper,
+	CellID_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CellID_tags_1,
+	sizeof(asn_DEF_CellID_tags_1)
+		/sizeof(asn_DEF_CellID_tags_1[0]), /* 1 */
+	asn_DEF_CellID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CellID_tags_1)
+		/sizeof(asn_DEF_CellID_tags_1[0]), /* 1 */
+	&asn_PER_type_CellID_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/algorithms/libs/supl/asn-rrlp/CellID.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_CellID_H_
+#define	_CellID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CellID */
+typedef long	 CellID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CellID;
+asn_struct_free_f CellID_free;
+asn_struct_print_f CellID_print;
+asn_constr_check_f CellID_constraint;
+ber_type_decoder_f CellID_decode_ber;
+der_type_encoder_f CellID_encode_der;
+xer_type_decoder_f CellID_decode_xer;
+xer_type_encoder_f CellID_encode_xer;
+per_type_decoder_f CellID_decode_uper;
+per_type_encoder_f CellID_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CellID_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/CellIDAndLAC.c

@@ -0,0 +1,69 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "CellIDAndLAC.h"
+
+static asn_TYPE_member_t asn_MBR_CellIDAndLAC_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct CellIDAndLAC, referenceLAC),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_LAC,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"referenceLAC"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct CellIDAndLAC, referenceCI),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_CellID,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"referenceCI"
+		},
+};
+static ber_tlv_tag_t asn_DEF_CellIDAndLAC_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_CellIDAndLAC_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* referenceLAC at 313 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* referenceCI at 315 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_CellIDAndLAC_specs_1 = {
+	sizeof(struct CellIDAndLAC),
+	offsetof(struct CellIDAndLAC, _asn_ctx),
+	asn_MAP_CellIDAndLAC_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_CellIDAndLAC = {
+	"CellIDAndLAC",
+	"CellIDAndLAC",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CellIDAndLAC_tags_1,
+	sizeof(asn_DEF_CellIDAndLAC_tags_1)
+		/sizeof(asn_DEF_CellIDAndLAC_tags_1[0]), /* 1 */
+	asn_DEF_CellIDAndLAC_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CellIDAndLAC_tags_1)
+		/sizeof(asn_DEF_CellIDAndLAC_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_CellIDAndLAC_1,
+	2,	/* Elements count */
+	&asn_SPC_CellIDAndLAC_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/CellIDAndLAC.h

@@ -0,0 +1,39 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_CellIDAndLAC_H_
+#define	_CellIDAndLAC_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "LAC.h"
+#include "CellID.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CellIDAndLAC */
+typedef struct CellIDAndLAC {
+	LAC_t	 referenceLAC;
+	CellID_t	 referenceCI;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} CellIDAndLAC_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CellIDAndLAC;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CellIDAndLAC_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/ControlHeader.c

@@ -0,0 +1,141 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "ControlHeader.h"
+
+static asn_TYPE_member_t asn_MBR_ControlHeader_1[] = {
+	{ ATF_POINTER, 9, offsetof(struct ControlHeader, referenceTime),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ReferenceTime,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"referenceTime"
+		},
+	{ ATF_POINTER, 8, offsetof(struct ControlHeader, refLocation),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RefLocation,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"refLocation"
+		},
+	{ ATF_POINTER, 7, offsetof(struct ControlHeader, dgpsCorrections),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_DGPSCorrections,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"dgpsCorrections"
+		},
+	{ ATF_POINTER, 6, offsetof(struct ControlHeader, navigationModel),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NavigationModel,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"navigationModel"
+		},
+	{ ATF_POINTER, 5, offsetof(struct ControlHeader, ionosphericModel),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_IonosphericModel,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"ionosphericModel"
+		},
+	{ ATF_POINTER, 4, offsetof(struct ControlHeader, utcModel),
+		(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_UTCModel,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"utcModel"
+		},
+	{ ATF_POINTER, 3, offsetof(struct ControlHeader, almanac),
+		(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_Almanac,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"almanac"
+		},
+	{ ATF_POINTER, 2, offsetof(struct ControlHeader, acquisAssist),
+		(ASN_TAG_CLASS_CONTEXT | (7 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_AcquisAssist,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"acquisAssist"
+		},
+	{ ATF_POINTER, 1, offsetof(struct ControlHeader, realTimeIntegrity),
+		(ASN_TAG_CLASS_CONTEXT | (8 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SeqOf_BadSatelliteSet,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"realTimeIntegrity"
+		},
+};
+static int asn_MAP_ControlHeader_oms_1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
+static ber_tlv_tag_t asn_DEF_ControlHeader_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_ControlHeader_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* referenceTime at 574 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* refLocation at 575 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* dgpsCorrections at 576 */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* navigationModel at 577 */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* ionosphericModel at 578 */
+    { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* utcModel at 579 */
+    { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* almanac at 580 */
+    { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 }, /* acquisAssist at 581 */
+    { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 } /* realTimeIntegrity at 582 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_ControlHeader_specs_1 = {
+	sizeof(struct ControlHeader),
+	offsetof(struct ControlHeader, _asn_ctx),
+	asn_MAP_ControlHeader_tag2el_1,
+	9,	/* Count of tags in the map */
+	asn_MAP_ControlHeader_oms_1,	/* Optional members */
+	9, 0,	/* Root/Additions */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_ControlHeader = {
+	"ControlHeader",
+	"ControlHeader",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_ControlHeader_tags_1,
+	sizeof(asn_DEF_ControlHeader_tags_1)
+		/sizeof(asn_DEF_ControlHeader_tags_1[0]), /* 1 */
+	asn_DEF_ControlHeader_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ControlHeader_tags_1)
+		/sizeof(asn_DEF_ControlHeader_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_ControlHeader_1,
+	9,	/* Elements count */
+	&asn_SPC_ControlHeader_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/ControlHeader.h

@@ -0,0 +1,66 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_ControlHeader_H_
+#define	_ControlHeader_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct ReferenceTime;
+struct RefLocation;
+struct DGPSCorrections;
+struct NavigationModel;
+struct IonosphericModel;
+struct UTCModel;
+struct Almanac;
+struct AcquisAssist;
+struct SeqOf_BadSatelliteSet;
+
+/* ControlHeader */
+typedef struct ControlHeader {
+	struct ReferenceTime	*referenceTime	/* OPTIONAL */;
+	struct RefLocation	*refLocation	/* OPTIONAL */;
+	struct DGPSCorrections	*dgpsCorrections	/* OPTIONAL */;
+	struct NavigationModel	*navigationModel	/* OPTIONAL */;
+	struct IonosphericModel	*ionosphericModel	/* OPTIONAL */;
+	struct UTCModel	*utcModel	/* OPTIONAL */;
+	struct Almanac	*almanac	/* OPTIONAL */;
+	struct AcquisAssist	*acquisAssist	/* OPTIONAL */;
+	struct SeqOf_BadSatelliteSet	*realTimeIntegrity	/* OPTIONAL */;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ControlHeader_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ControlHeader;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "ReferenceTime.h"
+#include "RefLocation.h"
+#include "DGPSCorrections.h"
+#include "NavigationModel.h"
+#include "IonosphericModel.h"
+#include "UTCModel.h"
+#include "Almanac.h"
+#include "AcquisAssist.h"
+#include "SeqOf-BadSatelliteSet.h"
+
+#endif	/* _ControlHeader_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/DGANSSSgnElement.c

@@ -0,0 +1,219 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "DGANSSSgnElement.h"
+
+static int
+memb_iod_constraint_1(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 <= 1023)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_udre_constraint_1(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 <= 3)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_pseudoRangeCor_constraint_1(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 >= -2047 && value <= 2047)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_rangeRateCor_constraint_1(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 >= -127 && value <= 127)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_memb_iod_constr_3 = {
+	{ APC_CONSTRAINED,	 10,  10,  0,  1023 }	/* (0..1023) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_udre_constr_4 = {
+	{ APC_CONSTRAINED,	 2,  2,  0,  3 }	/* (0..3) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_pseudoRangeCor_constr_5 = {
+	{ APC_CONSTRAINED,	 12,  12, -2047,  2047 }	/* (-2047..2047) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_rangeRateCor_constr_6 = {
+	{ APC_CONSTRAINED,	 8,  8, -127,  127 }	/* (-127..127) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_DGANSSSgnElement_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct DGANSSSgnElement, svID),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SVID,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"svID"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct DGANSSSgnElement, iod),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_iod_constraint_1,
+		&asn_PER_memb_iod_constr_3,
+		0,
+		"iod"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct DGANSSSgnElement, udre),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_udre_constraint_1,
+		&asn_PER_memb_udre_constr_4,
+		0,
+		"udre"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct DGANSSSgnElement, pseudoRangeCor),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_pseudoRangeCor_constraint_1,
+		&asn_PER_memb_pseudoRangeCor_constr_5,
+		0,
+		"pseudoRangeCor"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct DGANSSSgnElement, rangeRateCor),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_rangeRateCor_constraint_1,
+		&asn_PER_memb_rangeRateCor_constr_6,
+		0,
+		"rangeRateCor"
+		},
+};
+static ber_tlv_tag_t asn_DEF_DGANSSSgnElement_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_DGANSSSgnElement_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* svID at 1207 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* iod at 1210 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* udre at 1213 */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* pseudoRangeCor at 1217 */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* rangeRateCor at 1221 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_DGANSSSgnElement_specs_1 = {
+	sizeof(struct DGANSSSgnElement),
+	offsetof(struct DGANSSSgnElement, _asn_ctx),
+	asn_MAP_DGANSSSgnElement_tag2el_1,
+	5,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_DGANSSSgnElement = {
+	"DGANSSSgnElement",
+	"DGANSSSgnElement",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_DGANSSSgnElement_tags_1,
+	sizeof(asn_DEF_DGANSSSgnElement_tags_1)
+		/sizeof(asn_DEF_DGANSSSgnElement_tags_1[0]), /* 1 */
+	asn_DEF_DGANSSSgnElement_tags_1,	/* Same as above */
+	sizeof(asn_DEF_DGANSSSgnElement_tags_1)
+		/sizeof(asn_DEF_DGANSSSgnElement_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_DGANSSSgnElement_1,
+	5,	/* Elements count */
+	&asn_SPC_DGANSSSgnElement_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/DGANSSSgnElement.h

@@ -0,0 +1,42 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_DGANSSSgnElement_H_
+#define	_DGANSSSgnElement_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "SVID.h"
+#include <NativeInteger.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* DGANSSSgnElement */
+typedef struct DGANSSSgnElement {
+	SVID_t	 svID;
+	long	 iod;
+	long	 udre;
+	long	 pseudoRangeCor;
+	long	 rangeRateCor;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} DGANSSSgnElement_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_DGANSSSgnElement;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _DGANSSSgnElement_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/DGPSCorrections.c

@@ -0,0 +1,139 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "DGPSCorrections.h"
+
+static int
+memb_gpsTOW_constraint_1(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 <= 604799)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_status_constraint_1(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;
+	}
+}
+
+static asn_per_constraints_t asn_PER_memb_gpsTOW_constr_2 = {
+	{ APC_CONSTRAINED,	 20, -1,  0,  604799 }	/* (0..604799) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_status_constr_3 = {
+	{ APC_CONSTRAINED,	 3,  3,  0,  7 }	/* (0..7) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_DGPSCorrections_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct DGPSCorrections, gpsTOW),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_gpsTOW_constraint_1,
+		&asn_PER_memb_gpsTOW_constr_2,
+		0,
+		"gpsTOW"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct DGPSCorrections, status),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_status_constraint_1,
+		&asn_PER_memb_status_constr_3,
+		0,
+		"status"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct DGPSCorrections, satList),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SeqOfSatElement,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"satList"
+		},
+};
+static ber_tlv_tag_t asn_DEF_DGPSCorrections_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_DGPSCorrections_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* gpsTOW at 655 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* status at 656 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* satList at 659 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_DGPSCorrections_specs_1 = {
+	sizeof(struct DGPSCorrections),
+	offsetof(struct DGPSCorrections, _asn_ctx),
+	asn_MAP_DGPSCorrections_tag2el_1,
+	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_DGPSCorrections = {
+	"DGPSCorrections",
+	"DGPSCorrections",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_DGPSCorrections_tags_1,
+	sizeof(asn_DEF_DGPSCorrections_tags_1)
+		/sizeof(asn_DEF_DGPSCorrections_tags_1[0]), /* 1 */
+	asn_DEF_DGPSCorrections_tags_1,	/* Same as above */
+	sizeof(asn_DEF_DGPSCorrections_tags_1)
+		/sizeof(asn_DEF_DGPSCorrections_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_DGPSCorrections_1,
+	3,	/* Elements count */
+	&asn_SPC_DGPSCorrections_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/DGPSCorrections.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_DGPSCorrections_H_
+#define	_DGPSCorrections_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+#include "SeqOfSatElement.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* DGPSCorrections */
+typedef struct DGPSCorrections {
+	long	 gpsTOW;
+	long	 status;
+	SeqOfSatElement_t	 satList;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} DGPSCorrections_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_DGPSCorrections;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _DGPSCorrections_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/ENUMERATED.c

@@ -0,0 +1,71 @@
+/*-
+ * Copyright (c) 2003, 2005, 2006 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <ENUMERATED.h>
+#include <NativeEnumerated.h>
+#include <asn_codecs_prim.h>	/* Encoder and decoder of a primitive type */
+
+/*
+ * ENUMERATED basic type description.
+ */
+static ber_tlv_tag_t asn_DEF_ENUMERATED_tags[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_ENUMERATED = {
+	"ENUMERATED",
+	"ENUMERATED",
+	ASN__PRIMITIVE_TYPE_free,
+	INTEGER_print,			/* Implemented in terms of INTEGER */
+	asn_generic_no_constraint,
+	ber_decode_primitive,
+	INTEGER_encode_der,		/* Implemented in terms of INTEGER */
+	INTEGER_decode_xer,	/* This is temporary! */
+	INTEGER_encode_xer,
+	ENUMERATED_decode_uper,	/* Unaligned PER decoder */
+	ENUMERATED_encode_uper,	/* Unaligned PER encoder */
+	0, /* Use generic outmost tag fetcher */
+	asn_DEF_ENUMERATED_tags,
+	sizeof(asn_DEF_ENUMERATED_tags) / sizeof(asn_DEF_ENUMERATED_tags[0]),
+	asn_DEF_ENUMERATED_tags,	/* Same as above */
+	sizeof(asn_DEF_ENUMERATED_tags) / sizeof(asn_DEF_ENUMERATED_tags[0]),
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+asn_dec_rval_t
+ENUMERATED_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
+	asn_dec_rval_t rval;
+	ENUMERATED_t *st = (ENUMERATED_t *)*sptr;
+	long value;
+	void *vptr = &value;
+
+	if(!st) {
+		st = (ENUMERATED_t *)(*sptr = CALLOC(1, sizeof(*st)));
+		if(!st) _ASN_DECODE_FAILED;
+	}
+
+	rval = NativeEnumerated_decode_uper(opt_codec_ctx, td, constraints,
+			(void **)&vptr, pd);
+	if(rval.code == RC_OK)
+		if(asn_long2INTEGER(st, value))
+			rval.code = RC_FAIL;
+	return rval;
+}
+
+asn_enc_rval_t
+ENUMERATED_encode_uper(asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
+	ENUMERATED_t *st = (ENUMERATED_t *)sptr;
+	long value;
+
+	if(asn_INTEGER2long(st, &value))
+		_ASN_ENCODE_FAILED;
+
+	return NativeEnumerated_encode_uper(td, constraints, &value, po);
+}
+

src/algorithms/libs/supl/asn-rrlp/ENUMERATED.h

@@ -0,0 +1,25 @@
+/*-
+ * Copyright (c) 2003, 2005 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_ENUMERATED_H_
+#define	_ENUMERATED_H_
+
+#include <INTEGER.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef INTEGER_t ENUMERATED_t;		/* Implemented via INTEGER */
+
+extern asn_TYPE_descriptor_t asn_DEF_ENUMERATED;
+
+per_type_decoder_f ENUMERATED_decode_uper;
+per_type_encoder_f ENUMERATED_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ENUMERATED_H_ */

src/algorithms/libs/supl/asn-rrlp/EOTDQuality.c

@@ -0,0 +1,129 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "EOTDQuality.h"
+
+static int
+memb_nbrOfMeasurements_constraint_1(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;
+	}
+}
+
+static int
+memb_stdOfEOTD_constraint_1(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 <= 31)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_memb_nbrOfMeasurements_constr_2 = {
+	{ APC_CONSTRAINED,	 3,  3,  0,  7 }	/* (0..7) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_stdOfEOTD_constr_3 = {
+	{ APC_CONSTRAINED,	 5,  5,  0,  31 }	/* (0..31) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_EOTDQuality_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct EOTDQuality, nbrOfMeasurements),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_nbrOfMeasurements_constraint_1,
+		&asn_PER_memb_nbrOfMeasurements_constr_2,
+		0,
+		"nbrOfMeasurements"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct EOTDQuality, stdOfEOTD),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_stdOfEOTD_constraint_1,
+		&asn_PER_memb_stdOfEOTD_constr_3,
+		0,
+		"stdOfEOTD"
+		},
+};
+static ber_tlv_tag_t asn_DEF_EOTDQuality_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_EOTDQuality_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* nbrOfMeasurements at 393 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* stdOfEOTD at 394 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_EOTDQuality_specs_1 = {
+	sizeof(struct EOTDQuality),
+	offsetof(struct EOTDQuality, _asn_ctx),
+	asn_MAP_EOTDQuality_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_EOTDQuality = {
+	"EOTDQuality",
+	"EOTDQuality",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_EOTDQuality_tags_1,
+	sizeof(asn_DEF_EOTDQuality_tags_1)
+		/sizeof(asn_DEF_EOTDQuality_tags_1[0]), /* 1 */
+	asn_DEF_EOTDQuality_tags_1,	/* Same as above */
+	sizeof(asn_DEF_EOTDQuality_tags_1)
+		/sizeof(asn_DEF_EOTDQuality_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_EOTDQuality_1,
+	2,	/* Elements count */
+	&asn_SPC_EOTDQuality_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/EOTDQuality.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_EOTDQuality_H_
+#define	_EOTDQuality_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* EOTDQuality */
+typedef struct EOTDQuality {
+	long	 nbrOfMeasurements;
+	long	 stdOfEOTD;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} EOTDQuality_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_EOTDQuality;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _EOTDQuality_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/EnvironmentCharacter.c

@@ -0,0 +1,149 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "EnvironmentCharacter.h"
+
+int
+EnvironmentCharacter_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_ENUMERATED.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using ENUMERATED,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+EnvironmentCharacter_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_ENUMERATED.free_struct;
+	td->print_struct   = asn_DEF_ENUMERATED.print_struct;
+	td->ber_decoder    = asn_DEF_ENUMERATED.ber_decoder;
+	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
+	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
+	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	td->uper_encoder   = asn_DEF_ENUMERATED.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
+	td->elements       = asn_DEF_ENUMERATED.elements;
+	td->elements_count = asn_DEF_ENUMERATED.elements_count;
+     /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
+}
+
+void
+EnvironmentCharacter_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	EnvironmentCharacter_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+EnvironmentCharacter_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	EnvironmentCharacter_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+EnvironmentCharacter_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	EnvironmentCharacter_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+EnvironmentCharacter_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	EnvironmentCharacter_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+EnvironmentCharacter_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	EnvironmentCharacter_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+EnvironmentCharacter_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	EnvironmentCharacter_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+EnvironmentCharacter_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	EnvironmentCharacter_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+EnvironmentCharacter_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	EnvironmentCharacter_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_EnvironmentCharacter_constr_1 = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  2,  2,  0,  2 }	/* (0..2,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_INTEGER_enum_map_t asn_MAP_EnvironmentCharacter_value2enum_1[] = {
+	{ 0,	7,	"badArea" },
+	{ 1,	10,	"notBadArea" },
+	{ 2,	9,	"mixedArea" }
+	/* This list is extensible */
+};
+static unsigned int asn_MAP_EnvironmentCharacter_enum2value_1[] = {
+	0,	/* badArea(0) */
+	2,	/* mixedArea(2) */
+	1	/* notBadArea(1) */
+	/* This list is extensible */
+};
+static asn_INTEGER_specifics_t asn_SPC_EnvironmentCharacter_specs_1 = {
+	asn_MAP_EnvironmentCharacter_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_EnvironmentCharacter_enum2value_1,	/* N => "tag"; sorted by N */
+	3,	/* Number of elements in the maps */
+	4,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static ber_tlv_tag_t asn_DEF_EnvironmentCharacter_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_EnvironmentCharacter = {
+	"EnvironmentCharacter",
+	"EnvironmentCharacter",
+	EnvironmentCharacter_free,
+	EnvironmentCharacter_print,
+	EnvironmentCharacter_constraint,
+	EnvironmentCharacter_decode_ber,
+	EnvironmentCharacter_encode_der,
+	EnvironmentCharacter_decode_xer,
+	EnvironmentCharacter_encode_xer,
+	EnvironmentCharacter_decode_uper,
+	EnvironmentCharacter_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_EnvironmentCharacter_tags_1,
+	sizeof(asn_DEF_EnvironmentCharacter_tags_1)
+		/sizeof(asn_DEF_EnvironmentCharacter_tags_1[0]), /* 1 */
+	asn_DEF_EnvironmentCharacter_tags_1,	/* Same as above */
+	sizeof(asn_DEF_EnvironmentCharacter_tags_1)
+		/sizeof(asn_DEF_EnvironmentCharacter_tags_1[0]), /* 1 */
+	&asn_PER_type_EnvironmentCharacter_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_EnvironmentCharacter_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/EnvironmentCharacter.h

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_EnvironmentCharacter_H_
+#define	_EnvironmentCharacter_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <ENUMERATED.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum EnvironmentCharacter {
+	EnvironmentCharacter_badArea	= 0,
+	EnvironmentCharacter_notBadArea	= 1,
+	EnvironmentCharacter_mixedArea	= 2
+	/*
+	 * Enumeration is extensible
+	 */
+} e_EnvironmentCharacter;
+
+/* EnvironmentCharacter */
+typedef ENUMERATED_t	 EnvironmentCharacter_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_EnvironmentCharacter;
+asn_struct_free_f EnvironmentCharacter_free;
+asn_struct_print_f EnvironmentCharacter_print;
+asn_constr_check_f EnvironmentCharacter_constraint;
+ber_type_decoder_f EnvironmentCharacter_decode_ber;
+der_type_encoder_f EnvironmentCharacter_encode_der;
+xer_type_decoder_f EnvironmentCharacter_decode_xer;
+xer_type_encoder_f EnvironmentCharacter_encode_xer;
+per_type_decoder_f EnvironmentCharacter_decode_uper;
+per_type_encoder_f EnvironmentCharacter_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _EnvironmentCharacter_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/EphemerisSubframe1Reserved.c

@@ -0,0 +1,209 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "EphemerisSubframe1Reserved.h"
+
+static int
+memb_reserved1_constraint_1(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 <= 8388607)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_reserved2_constraint_1(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 <= 16777215)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_reserved3_constraint_1(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 <= 16777215)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_reserved4_constraint_1(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;
+	}
+}
+
+static asn_per_constraints_t asn_PER_memb_reserved1_constr_2 = {
+	{ APC_CONSTRAINED,	 23, -1,  0,  8388607 }	/* (0..8388607) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_reserved2_constr_3 = {
+	{ APC_CONSTRAINED,	 24, -1,  0,  16777215 }	/* (0..16777215) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_reserved3_constr_4 = {
+	{ APC_CONSTRAINED,	 24, -1,  0,  16777215 }	/* (0..16777215) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_reserved4_constr_5 = {
+	{ APC_CONSTRAINED,	 16,  16,  0,  65535 }	/* (0..65535) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_EphemerisSubframe1Reserved_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct EphemerisSubframe1Reserved, reserved1),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_reserved1_constraint_1,
+		&asn_PER_memb_reserved1_constr_2,
+		0,
+		"reserved1"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct EphemerisSubframe1Reserved, reserved2),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_reserved2_constraint_1,
+		&asn_PER_memb_reserved2_constr_3,
+		0,
+		"reserved2"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct EphemerisSubframe1Reserved, reserved3),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_reserved3_constraint_1,
+		&asn_PER_memb_reserved3_constr_4,
+		0,
+		"reserved3"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct EphemerisSubframe1Reserved, reserved4),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_reserved4_constraint_1,
+		&asn_PER_memb_reserved4_constr_5,
+		0,
+		"reserved4"
+		},
+};
+static ber_tlv_tag_t asn_DEF_EphemerisSubframe1Reserved_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_EphemerisSubframe1Reserved_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* reserved1 at 755 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* reserved2 at 756 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* reserved3 at 757 */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* reserved4 at 758 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_EphemerisSubframe1Reserved_specs_1 = {
+	sizeof(struct EphemerisSubframe1Reserved),
+	offsetof(struct EphemerisSubframe1Reserved, _asn_ctx),
+	asn_MAP_EphemerisSubframe1Reserved_tag2el_1,
+	4,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_EphemerisSubframe1Reserved = {
+	"EphemerisSubframe1Reserved",
+	"EphemerisSubframe1Reserved",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_EphemerisSubframe1Reserved_tags_1,
+	sizeof(asn_DEF_EphemerisSubframe1Reserved_tags_1)
+		/sizeof(asn_DEF_EphemerisSubframe1Reserved_tags_1[0]), /* 1 */
+	asn_DEF_EphemerisSubframe1Reserved_tags_1,	/* Same as above */
+	sizeof(asn_DEF_EphemerisSubframe1Reserved_tags_1)
+		/sizeof(asn_DEF_EphemerisSubframe1Reserved_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_EphemerisSubframe1Reserved_1,
+	4,	/* Elements count */
+	&asn_SPC_EphemerisSubframe1Reserved_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/EphemerisSubframe1Reserved.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_EphemerisSubframe1Reserved_H_
+#define	_EphemerisSubframe1Reserved_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* EphemerisSubframe1Reserved */
+typedef struct EphemerisSubframe1Reserved {
+	long	 reserved1;
+	long	 reserved2;
+	long	 reserved3;
+	long	 reserved4;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} EphemerisSubframe1Reserved_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_EphemerisSubframe1Reserved;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _EphemerisSubframe1Reserved_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/ErrorCodes.c

@@ -0,0 +1,155 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "ErrorCodes.h"
+
+int
+ErrorCodes_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_ENUMERATED.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using ENUMERATED,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+ErrorCodes_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_ENUMERATED.free_struct;
+	td->print_struct   = asn_DEF_ENUMERATED.print_struct;
+	td->ber_decoder    = asn_DEF_ENUMERATED.ber_decoder;
+	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
+	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
+	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	td->uper_encoder   = asn_DEF_ENUMERATED.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
+	td->elements       = asn_DEF_ENUMERATED.elements;
+	td->elements_count = asn_DEF_ENUMERATED.elements_count;
+     /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
+}
+
+void
+ErrorCodes_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	ErrorCodes_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+ErrorCodes_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	ErrorCodes_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+ErrorCodes_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	ErrorCodes_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+ErrorCodes_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ErrorCodes_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+ErrorCodes_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	ErrorCodes_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+ErrorCodes_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ErrorCodes_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+ErrorCodes_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	ErrorCodes_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+ErrorCodes_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	ErrorCodes_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_ErrorCodes_constr_1 = {
+	{ APC_CONSTRAINED | APC_EXTENSIBLE,  3,  3,  0,  5 }	/* (0..5,...) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_INTEGER_enum_map_t asn_MAP_ErrorCodes_value2enum_1[] = {
+	{ 0,	9,	"unDefined" },
+	{ 1,	15,	"missingComponet" },
+	{ 2,	13,	"incorrectData" },
+	{ 3,	27,	"missingIEorComponentElement" },
+	{ 4,	15,	"messageTooShort" },
+	{ 5,	21,	"unknowReferenceNumber" }
+	/* This list is extensible */
+};
+static unsigned int asn_MAP_ErrorCodes_enum2value_1[] = {
+	2,	/* incorrectData(2) */
+	4,	/* messageTooShort(4) */
+	1,	/* missingComponet(1) */
+	3,	/* missingIEorComponentElement(3) */
+	0,	/* unDefined(0) */
+	5	/* unknowReferenceNumber(5) */
+	/* This list is extensible */
+};
+static asn_INTEGER_specifics_t asn_SPC_ErrorCodes_specs_1 = {
+	asn_MAP_ErrorCodes_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_ErrorCodes_enum2value_1,	/* N => "tag"; sorted by N */
+	6,	/* Number of elements in the maps */
+	7,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static ber_tlv_tag_t asn_DEF_ErrorCodes_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_ErrorCodes = {
+	"ErrorCodes",
+	"ErrorCodes",
+	ErrorCodes_free,
+	ErrorCodes_print,
+	ErrorCodes_constraint,
+	ErrorCodes_decode_ber,
+	ErrorCodes_encode_der,
+	ErrorCodes_decode_xer,
+	ErrorCodes_encode_xer,
+	ErrorCodes_decode_uper,
+	ErrorCodes_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_ErrorCodes_tags_1,
+	sizeof(asn_DEF_ErrorCodes_tags_1)
+		/sizeof(asn_DEF_ErrorCodes_tags_1[0]), /* 1 */
+	asn_DEF_ErrorCodes_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ErrorCodes_tags_1)
+		/sizeof(asn_DEF_ErrorCodes_tags_1[0]), /* 1 */
+	&asn_PER_type_ErrorCodes_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_ErrorCodes_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/ErrorCodes.h

@@ -0,0 +1,53 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_ErrorCodes_H_
+#define	_ErrorCodes_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <ENUMERATED.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum ErrorCodes {
+	ErrorCodes_unDefined	= 0,
+	ErrorCodes_missingComponet	= 1,
+	ErrorCodes_incorrectData	= 2,
+	ErrorCodes_missingIEorComponentElement	= 3,
+	ErrorCodes_messageTooShort	= 4,
+	ErrorCodes_unknowReferenceNumber	= 5
+	/*
+	 * Enumeration is extensible
+	 */
+} e_ErrorCodes;
+
+/* ErrorCodes */
+typedef ENUMERATED_t	 ErrorCodes_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ErrorCodes;
+asn_struct_free_f ErrorCodes_free;
+asn_struct_print_f ErrorCodes_print;
+asn_constr_check_f ErrorCodes_constraint;
+ber_type_decoder_f ErrorCodes_decode_ber;
+der_type_encoder_f ErrorCodes_encode_der;
+xer_type_decoder_f ErrorCodes_decode_xer;
+xer_type_encoder_f ErrorCodes_encode_xer;
+per_type_decoder_f ErrorCodes_decode_uper;
+per_type_encoder_f ErrorCodes_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ErrorCodes_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/ExpOTDUncertainty.c

@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "ExpOTDUncertainty.h"
+
+int
+ExpOTDUncertainty_constraint(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.
+ */
+static void
+ExpOTDUncertainty_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+ExpOTDUncertainty_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	ExpOTDUncertainty_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+ExpOTDUncertainty_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	ExpOTDUncertainty_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+ExpOTDUncertainty_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	ExpOTDUncertainty_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+ExpOTDUncertainty_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ExpOTDUncertainty_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+ExpOTDUncertainty_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	ExpOTDUncertainty_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+ExpOTDUncertainty_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ExpOTDUncertainty_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+ExpOTDUncertainty_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	ExpOTDUncertainty_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+ExpOTDUncertainty_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	ExpOTDUncertainty_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_ExpOTDUncertainty_constr_1 = {
+	{ APC_CONSTRAINED,	 3,  3,  0,  7 }	/* (0..7) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static ber_tlv_tag_t asn_DEF_ExpOTDUncertainty_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_ExpOTDUncertainty = {
+	"ExpOTDUncertainty",
+	"ExpOTDUncertainty",
+	ExpOTDUncertainty_free,
+	ExpOTDUncertainty_print,
+	ExpOTDUncertainty_constraint,
+	ExpOTDUncertainty_decode_ber,
+	ExpOTDUncertainty_encode_der,
+	ExpOTDUncertainty_decode_xer,
+	ExpOTDUncertainty_encode_xer,
+	ExpOTDUncertainty_decode_uper,
+	ExpOTDUncertainty_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_ExpOTDUncertainty_tags_1,
+	sizeof(asn_DEF_ExpOTDUncertainty_tags_1)
+		/sizeof(asn_DEF_ExpOTDUncertainty_tags_1[0]), /* 1 */
+	asn_DEF_ExpOTDUncertainty_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ExpOTDUncertainty_tags_1)
+		/sizeof(asn_DEF_ExpOTDUncertainty_tags_1[0]), /* 1 */
+	&asn_PER_type_ExpOTDUncertainty_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/algorithms/libs/supl/asn-rrlp/ExpOTDUncertainty.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_ExpOTDUncertainty_H_
+#define	_ExpOTDUncertainty_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ExpOTDUncertainty */
+typedef long	 ExpOTDUncertainty_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ExpOTDUncertainty;
+asn_struct_free_f ExpOTDUncertainty_free;
+asn_struct_print_f ExpOTDUncertainty_print;
+asn_constr_check_f ExpOTDUncertainty_constraint;
+ber_type_decoder_f ExpOTDUncertainty_decode_ber;
+der_type_encoder_f ExpOTDUncertainty_encode_der;
+xer_type_decoder_f ExpOTDUncertainty_decode_xer;
+xer_type_encoder_f ExpOTDUncertainty_encode_xer;
+per_type_decoder_f ExpOTDUncertainty_decode_uper;
+per_type_encoder_f ExpOTDUncertainty_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ExpOTDUncertainty_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/ExpectedOTD.c

@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "ExpectedOTD.h"
+
+int
+ExpectedOTD_constraint(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 <= 1250)) {
+		/* 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.
+ */
+static void
+ExpectedOTD_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+ExpectedOTD_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	ExpectedOTD_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+ExpectedOTD_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	ExpectedOTD_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+ExpectedOTD_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	ExpectedOTD_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+ExpectedOTD_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ExpectedOTD_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+ExpectedOTD_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	ExpectedOTD_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+ExpectedOTD_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ExpectedOTD_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+ExpectedOTD_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	ExpectedOTD_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+ExpectedOTD_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	ExpectedOTD_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_ExpectedOTD_constr_1 = {
+	{ APC_CONSTRAINED,	 11,  11,  0,  1250 }	/* (0..1250) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static ber_tlv_tag_t asn_DEF_ExpectedOTD_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_ExpectedOTD = {
+	"ExpectedOTD",
+	"ExpectedOTD",
+	ExpectedOTD_free,
+	ExpectedOTD_print,
+	ExpectedOTD_constraint,
+	ExpectedOTD_decode_ber,
+	ExpectedOTD_encode_der,
+	ExpectedOTD_decode_xer,
+	ExpectedOTD_encode_xer,
+	ExpectedOTD_decode_uper,
+	ExpectedOTD_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_ExpectedOTD_tags_1,
+	sizeof(asn_DEF_ExpectedOTD_tags_1)
+		/sizeof(asn_DEF_ExpectedOTD_tags_1[0]), /* 1 */
+	asn_DEF_ExpectedOTD_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ExpectedOTD_tags_1)
+		/sizeof(asn_DEF_ExpectedOTD_tags_1[0]), /* 1 */
+	&asn_PER_type_ExpectedOTD_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/algorithms/libs/supl/asn-rrlp/ExpectedOTD.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_ExpectedOTD_H_
+#define	_ExpectedOTD_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ExpectedOTD */
+typedef long	 ExpectedOTD_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ExpectedOTD;
+asn_struct_free_f ExpectedOTD_free;
+asn_struct_print_f ExpectedOTD_print;
+asn_constr_check_f ExpectedOTD_constraint;
+ber_type_decoder_f ExpectedOTD_decode_ber;
+der_type_encoder_f ExpectedOTD_encode_der;
+xer_type_decoder_f ExpectedOTD_decode_xer;
+xer_type_encoder_f ExpectedOTD_encode_xer;
+per_type_decoder_f ExpectedOTD_decode_uper;
+per_type_encoder_f ExpectedOTD_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ExpectedOTD_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/Ext-GeographicalInformation.c

@@ -0,0 +1,146 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "Ext-GeographicalInformation.h"
+
+int
+Ext_GeographicalInformation_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_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;
+	}
+	
+	size = st->size;
+	
+	if((size >= 1 && size <= 20)) {
+		/* 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 OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Ext_GeographicalInformation_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+Ext_GeographicalInformation_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Ext_GeographicalInformation_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Ext_GeographicalInformation_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Ext_GeographicalInformation_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Ext_GeographicalInformation_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	Ext_GeographicalInformation_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Ext_GeographicalInformation_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Ext_GeographicalInformation_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Ext_GeographicalInformation_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	Ext_GeographicalInformation_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Ext_GeographicalInformation_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Ext_GeographicalInformation_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+Ext_GeographicalInformation_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	Ext_GeographicalInformation_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+Ext_GeographicalInformation_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	Ext_GeographicalInformation_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_Ext_GeographicalInformation_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 5,  5,  1,  20 }	/* (SIZE(1..20)) */,
+	0, 0	/* No PER value map */
+};
+static ber_tlv_tag_t asn_DEF_Ext_GeographicalInformation_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Ext_GeographicalInformation = {
+	"Ext-GeographicalInformation",
+	"Ext-GeographicalInformation",
+	Ext_GeographicalInformation_free,
+	Ext_GeographicalInformation_print,
+	Ext_GeographicalInformation_constraint,
+	Ext_GeographicalInformation_decode_ber,
+	Ext_GeographicalInformation_encode_der,
+	Ext_GeographicalInformation_decode_xer,
+	Ext_GeographicalInformation_encode_xer,
+	Ext_GeographicalInformation_decode_uper,
+	Ext_GeographicalInformation_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Ext_GeographicalInformation_tags_1,
+	sizeof(asn_DEF_Ext_GeographicalInformation_tags_1)
+		/sizeof(asn_DEF_Ext_GeographicalInformation_tags_1[0]), /* 1 */
+	asn_DEF_Ext_GeographicalInformation_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Ext_GeographicalInformation_tags_1)
+		/sizeof(asn_DEF_Ext_GeographicalInformation_tags_1[0]), /* 1 */
+	&asn_PER_type_Ext_GeographicalInformation_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/algorithms/libs/supl/asn-rrlp/Ext-GeographicalInformation.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_Ext_GeographicalInformation_H_
+#define	_Ext_GeographicalInformation_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Ext-GeographicalInformation */
+typedef OCTET_STRING_t	 Ext_GeographicalInformation_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Ext_GeographicalInformation;
+asn_struct_free_f Ext_GeographicalInformation_free;
+asn_struct_print_f Ext_GeographicalInformation_print;
+asn_constr_check_f Ext_GeographicalInformation_constraint;
+ber_type_decoder_f Ext_GeographicalInformation_decode_ber;
+der_type_encoder_f Ext_GeographicalInformation_encode_der;
+xer_type_decoder_f Ext_GeographicalInformation_decode_xer;
+xer_type_encoder_f Ext_GeographicalInformation_encode_xer;
+per_type_decoder_f Ext_GeographicalInformation_decode_uper;
+per_type_encoder_f Ext_GeographicalInformation_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _Ext_GeographicalInformation_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/Extended-reference.c

@@ -0,0 +1,129 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "Extended-reference.h"
+
+static int
+memb_smlc_code_constraint_1(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 <= 63)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_transaction_ID_constraint_1(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;
+	}
+}
+
+static asn_per_constraints_t asn_PER_memb_smlc_code_constr_2 = {
+	{ APC_CONSTRAINED,	 6,  6,  0,  63 }	/* (0..63) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_transaction_ID_constr_3 = {
+	{ APC_CONSTRAINED,	 18, -1,  0,  262143 }	/* (0..262143) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_Extended_reference_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Extended_reference, smlc_code),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_smlc_code_constraint_1,
+		&asn_PER_memb_smlc_code_constr_2,
+		0,
+		"smlc-code"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Extended_reference, transaction_ID),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_transaction_ID_constraint_1,
+		&asn_PER_memb_transaction_ID_constr_3,
+		0,
+		"transaction-ID"
+		},
+};
+static ber_tlv_tag_t asn_DEF_Extended_reference_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_Extended_reference_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* smlc-code at 999 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* transaction-ID at 1000 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_Extended_reference_specs_1 = {
+	sizeof(struct Extended_reference),
+	offsetof(struct Extended_reference, _asn_ctx),
+	asn_MAP_Extended_reference_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_Extended_reference = {
+	"Extended-reference",
+	"Extended-reference",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Extended_reference_tags_1,
+	sizeof(asn_DEF_Extended_reference_tags_1)
+		/sizeof(asn_DEF_Extended_reference_tags_1[0]), /* 1 */
+	asn_DEF_Extended_reference_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Extended_reference_tags_1)
+		/sizeof(asn_DEF_Extended_reference_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_Extended_reference_1,
+	2,	/* Elements count */
+	&asn_SPC_Extended_reference_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/Extended-reference.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_Extended_reference_H_
+#define	_Extended_reference_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Extended-reference */
+typedef struct Extended_reference {
+	long	 smlc_code;
+	long	 transaction_ID;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} Extended_reference_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Extended_reference;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _Extended_reference_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/ExtensionContainer.c

@@ -0,0 +1,123 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "ExtensionContainer.h"
+
+int
+ExtensionContainer_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_INTEGER.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+ExtensionContainer_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_INTEGER.free_struct;
+	td->print_struct   = asn_DEF_INTEGER.print_struct;
+	td->ber_decoder    = asn_DEF_INTEGER.ber_decoder;
+	td->der_encoder    = asn_DEF_INTEGER.der_encoder;
+	td->xer_decoder    = asn_DEF_INTEGER.xer_decoder;
+	td->xer_encoder    = asn_DEF_INTEGER.xer_encoder;
+	td->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	td->uper_encoder   = asn_DEF_INTEGER.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+ExtensionContainer_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	ExtensionContainer_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+ExtensionContainer_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	ExtensionContainer_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+ExtensionContainer_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	ExtensionContainer_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+ExtensionContainer_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ExtensionContainer_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+ExtensionContainer_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	ExtensionContainer_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+ExtensionContainer_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ExtensionContainer_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+ExtensionContainer_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	ExtensionContainer_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+ExtensionContainer_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	ExtensionContainer_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static ber_tlv_tag_t asn_DEF_ExtensionContainer_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_ExtensionContainer = {
+	"ExtensionContainer",
+	"ExtensionContainer",
+	ExtensionContainer_free,
+	ExtensionContainer_print,
+	ExtensionContainer_constraint,
+	ExtensionContainer_decode_ber,
+	ExtensionContainer_encode_der,
+	ExtensionContainer_decode_xer,
+	ExtensionContainer_encode_xer,
+	ExtensionContainer_decode_uper,
+	ExtensionContainer_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_ExtensionContainer_tags_1,
+	sizeof(asn_DEF_ExtensionContainer_tags_1)
+		/sizeof(asn_DEF_ExtensionContainer_tags_1[0]), /* 1 */
+	asn_DEF_ExtensionContainer_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ExtensionContainer_tags_1)
+		/sizeof(asn_DEF_ExtensionContainer_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/algorithms/libs/supl/asn-rrlp/ExtensionContainer.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_ExtensionContainer_H_
+#define	_ExtensionContainer_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <INTEGER.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ExtensionContainer */
+typedef INTEGER_t	 ExtensionContainer_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ExtensionContainer;
+asn_struct_free_f ExtensionContainer_free;
+asn_struct_print_f ExtensionContainer_print;
+asn_constr_check_f ExtensionContainer_constraint;
+ber_type_decoder_f ExtensionContainer_decode_ber;
+der_type_encoder_f ExtensionContainer_encode_der;
+xer_type_decoder_f ExtensionContainer_decode_xer;
+xer_type_encoder_f ExtensionContainer_encode_xer;
+per_type_decoder_f ExtensionContainer_decode_uper;
+per_type_encoder_f ExtensionContainer_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ExtensionContainer_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/FineRTD.c

@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "FineRTD.h"
+
+int
+FineRTD_constraint(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 <= 255)) {
+		/* 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.
+ */
+static void
+FineRTD_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+FineRTD_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FineRTD_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FineRTD_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FineRTD_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FineRTD_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	FineRTD_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FineRTD_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	FineRTD_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FineRTD_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	FineRTD_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FineRTD_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	FineRTD_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FineRTD_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FineRTD_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FineRTD_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FineRTD_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FineRTD_constr_1 = {
+	{ APC_CONSTRAINED,	 8,  8,  0,  255 }	/* (0..255) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static ber_tlv_tag_t asn_DEF_FineRTD_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FineRTD = {
+	"FineRTD",
+	"FineRTD",
+	FineRTD_free,
+	FineRTD_print,
+	FineRTD_constraint,
+	FineRTD_decode_ber,
+	FineRTD_encode_der,
+	FineRTD_decode_xer,
+	FineRTD_encode_xer,
+	FineRTD_decode_uper,
+	FineRTD_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FineRTD_tags_1,
+	sizeof(asn_DEF_FineRTD_tags_1)
+		/sizeof(asn_DEF_FineRTD_tags_1[0]), /* 1 */
+	asn_DEF_FineRTD_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FineRTD_tags_1)
+		/sizeof(asn_DEF_FineRTD_tags_1[0]), /* 1 */
+	&asn_PER_type_FineRTD_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/algorithms/libs/supl/asn-rrlp/FineRTD.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_FineRTD_H_
+#define	_FineRTD_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FineRTD */
+typedef long	 FineRTD_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FineRTD;
+asn_struct_free_f FineRTD_free;
+asn_struct_print_f FineRTD_print;
+asn_constr_check_f FineRTD_constraint;
+ber_type_decoder_f FineRTD_decode_ber;
+der_type_encoder_f FineRTD_encode_der;
+xer_type_decoder_f FineRTD_decode_xer;
+xer_type_encoder_f FineRTD_encode_xer;
+per_type_decoder_f FineRTD_decode_uper;
+per_type_encoder_f FineRTD_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FineRTD_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/FixType.c

@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "FixType.h"
+
+int
+FixType_constraint(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 <= 1)) {
+		/* 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.
+ */
+static void
+FixType_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+FixType_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FixType_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FixType_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FixType_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FixType_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	FixType_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FixType_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	FixType_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FixType_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	FixType_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FixType_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	FixType_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FixType_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FixType_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FixType_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FixType_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FixType_constr_1 = {
+	{ APC_CONSTRAINED,	 1,  1,  0,  1 }	/* (0..1) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static ber_tlv_tag_t asn_DEF_FixType_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FixType = {
+	"FixType",
+	"FixType",
+	FixType_free,
+	FixType_print,
+	FixType_constraint,
+	FixType_decode_ber,
+	FixType_encode_der,
+	FixType_decode_xer,
+	FixType_encode_xer,
+	FixType_decode_uper,
+	FixType_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FixType_tags_1,
+	sizeof(asn_DEF_FixType_tags_1)
+		/sizeof(asn_DEF_FixType_tags_1[0]), /* 1 */
+	asn_DEF_FixType_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FixType_tags_1)
+		/sizeof(asn_DEF_FixType_tags_1[0]), /* 1 */
+	&asn_PER_type_FixType_constr_1,
+	0, 0,	/* Defined elsewhere */
+	0	/* No specifics */
+};
+

src/algorithms/libs/supl/asn-rrlp/FixType.h

@@ -0,0 +1,46 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_FixType_H_
+#define	_FixType_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum FixType {
+	FixType_twoDFix	= 0,
+	FixType_threeDFix	= 1
+} e_FixType;
+
+/* FixType */
+typedef long	 FixType_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FixType;
+asn_struct_free_f FixType_free;
+asn_struct_print_f FixType_print;
+asn_constr_check_f FixType_constraint;
+ber_type_decoder_f FixType_decode_ber;
+der_type_encoder_f FixType_encode_der;
+xer_type_decoder_f FixType_decode_xer;
+xer_type_encoder_f FixType_encode_xer;
+per_type_decoder_f FixType_decode_uper;
+per_type_encoder_f FixType_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FixType_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/FrameDrift.c

@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "FrameDrift.h"
+
+int
+FrameDrift_constraint(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 >= -64 && value <= 63)) {
+		/* 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.
+ */
+static void
+FrameDrift_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+FrameDrift_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FrameDrift_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FrameDrift_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FrameDrift_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FrameDrift_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	FrameDrift_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FrameDrift_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	FrameDrift_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FrameDrift_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	FrameDrift_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FrameDrift_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	FrameDrift_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FrameDrift_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FrameDrift_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FrameDrift_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FrameDrift_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FrameDrift_constr_1 = {
+	{ APC_CONSTRAINED,	 7,  7, -64,  63 }	/* (-64..63) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static ber_tlv_tag_t asn_DEF_FrameDrift_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FrameDrift = {
+	"FrameDrift",
+	"FrameDrift",
+	FrameDrift_free,
+	FrameDrift_print,
+	FrameDrift_constraint,
+	FrameDrift_decode_ber,
+	FrameDrift_encode_der,
+	FrameDrift_decode_xer,
+	FrameDrift_encode_xer,
+	FrameDrift_decode_uper,
+	FrameDrift_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FrameDrift_tags_1,
+	sizeof(asn_DEF_FrameDrift_tags_1)
+		/sizeof(asn_DEF_FrameDrift_tags_1[0]), /* 1 */
+	asn_DEF_FrameDrift_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FrameDrift_tags_1)
+		/sizeof(asn_DEF_FrameDrift_tags_1[0]), /* 1 */
+	&asn_PER_type_FrameDrift_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/algorithms/libs/supl/asn-rrlp/FrameDrift.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_FrameDrift_H_
+#define	_FrameDrift_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FrameDrift */
+typedef long	 FrameDrift_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FrameDrift;
+asn_struct_free_f FrameDrift_free;
+asn_struct_print_f FrameDrift_print;
+asn_constr_check_f FrameDrift_constraint;
+ber_type_decoder_f FrameDrift_decode_ber;
+der_type_encoder_f FrameDrift_encode_der;
+xer_type_decoder_f FrameDrift_decode_xer;
+xer_type_encoder_f FrameDrift_encode_xer;
+per_type_decoder_f FrameDrift_decode_uper;
+per_type_encoder_f FrameDrift_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FrameDrift_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/FrameNumber.c

@@ -0,0 +1,145 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "FrameNumber.h"
+
+int
+FrameNumber_constraint(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 <= 2097151)) {
+		/* 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.
+ */
+static void
+FrameNumber_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+FrameNumber_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FrameNumber_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FrameNumber_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FrameNumber_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FrameNumber_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	FrameNumber_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FrameNumber_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	FrameNumber_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FrameNumber_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	FrameNumber_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FrameNumber_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	FrameNumber_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FrameNumber_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FrameNumber_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FrameNumber_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FrameNumber_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FrameNumber_constr_1 = {
+	{ APC_CONSTRAINED,	 21, -1,  0,  2097151 }	/* (0..2097151) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static ber_tlv_tag_t asn_DEF_FrameNumber_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FrameNumber = {
+	"FrameNumber",
+	"FrameNumber",
+	FrameNumber_free,
+	FrameNumber_print,
+	FrameNumber_constraint,
+	FrameNumber_decode_ber,
+	FrameNumber_encode_der,
+	FrameNumber_decode_xer,
+	FrameNumber_encode_xer,
+	FrameNumber_decode_uper,
+	FrameNumber_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FrameNumber_tags_1,
+	sizeof(asn_DEF_FrameNumber_tags_1)
+		/sizeof(asn_DEF_FrameNumber_tags_1[0]), /* 1 */
+	asn_DEF_FrameNumber_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FrameNumber_tags_1)
+		/sizeof(asn_DEF_FrameNumber_tags_1[0]), /* 1 */
+	&asn_PER_type_FrameNumber_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

src/algorithms/libs/supl/asn-rrlp/FrameNumber.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_FrameNumber_H_
+#define	_FrameNumber_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FrameNumber */
+typedef long	 FrameNumber_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FrameNumber;
+asn_struct_free_f FrameNumber_free;
+asn_struct_print_f FrameNumber_print;
+asn_constr_check_f FrameNumber_constraint;
+ber_type_decoder_f FrameNumber_decode_ber;
+der_type_encoder_f FrameNumber_encode_der;
+xer_type_decoder_f FrameNumber_decode_xer;
+xer_type_encoder_f FrameNumber_encode_xer;
+per_type_decoder_f FrameNumber_decode_uper;
+per_type_encoder_f FrameNumber_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FrameNumber_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/GANSS-AssistData.c

@@ -0,0 +1,59 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "GANSS-AssistData.h"
+
+static asn_TYPE_member_t asn_MBR_GANSS_AssistData_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct GANSS_AssistData, ganss_controlHeader),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GANSS_ControlHeader,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"ganss-controlHeader"
+		},
+};
+static ber_tlv_tag_t asn_DEF_GANSS_AssistData_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_GANSS_AssistData_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* ganss-controlHeader at 1062 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_GANSS_AssistData_specs_1 = {
+	sizeof(struct GANSS_AssistData),
+	offsetof(struct GANSS_AssistData, _asn_ctx),
+	asn_MAP_GANSS_AssistData_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_GANSS_AssistData = {
+	"GANSS-AssistData",
+	"GANSS-AssistData",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_GANSS_AssistData_tags_1,
+	sizeof(asn_DEF_GANSS_AssistData_tags_1)
+		/sizeof(asn_DEF_GANSS_AssistData_tags_1[0]), /* 1 */
+	asn_DEF_GANSS_AssistData_tags_1,	/* Same as above */
+	sizeof(asn_DEF_GANSS_AssistData_tags_1)
+		/sizeof(asn_DEF_GANSS_AssistData_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_GANSS_AssistData_1,
+	1,	/* Elements count */
+	&asn_SPC_GANSS_AssistData_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/GANSS-AssistData.h

@@ -0,0 +1,37 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_GANSS_AssistData_H_
+#define	_GANSS_AssistData_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "GANSS-ControlHeader.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* GANSS-AssistData */
+typedef struct GANSS_AssistData {
+	GANSS_ControlHeader_t	 ganss_controlHeader;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} GANSS_AssistData_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_GANSS_AssistData;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _GANSS_AssistData_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/GANSS-ControlHeader.c

@@ -0,0 +1,71 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "GANSS-ControlHeader.h"
+
+static asn_TYPE_member_t asn_MBR_GANSS_ControlHeader_1[] = {
+	{ ATF_POINTER, 2, offsetof(struct GANSS_ControlHeader, ganssCommonAssistData),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GANSSCommonAssistData,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"ganssCommonAssistData"
+		},
+	{ ATF_POINTER, 1, offsetof(struct GANSS_ControlHeader, ganssGenericAssistDataList),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SeqOfGANSSGenericAssistDataElement,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"ganssGenericAssistDataList"
+		},
+};
+static int asn_MAP_GANSS_ControlHeader_oms_1[] = { 0, 1 };
+static ber_tlv_tag_t asn_DEF_GANSS_ControlHeader_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_GANSS_ControlHeader_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ganssCommonAssistData at 1065 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* ganssGenericAssistDataList at 1066 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_GANSS_ControlHeader_specs_1 = {
+	sizeof(struct GANSS_ControlHeader),
+	offsetof(struct GANSS_ControlHeader, _asn_ctx),
+	asn_MAP_GANSS_ControlHeader_tag2el_1,
+	2,	/* Count of tags in the map */
+	asn_MAP_GANSS_ControlHeader_oms_1,	/* Optional members */
+	2, 0,	/* Root/Additions */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_GANSS_ControlHeader = {
+	"GANSS-ControlHeader",
+	"GANSS-ControlHeader",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_GANSS_ControlHeader_tags_1,
+	sizeof(asn_DEF_GANSS_ControlHeader_tags_1)
+		/sizeof(asn_DEF_GANSS_ControlHeader_tags_1[0]), /* 1 */
+	asn_DEF_GANSS_ControlHeader_tags_1,	/* Same as above */
+	sizeof(asn_DEF_GANSS_ControlHeader_tags_1)
+		/sizeof(asn_DEF_GANSS_ControlHeader_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_GANSS_ControlHeader_1,
+	2,	/* Elements count */
+	&asn_SPC_GANSS_ControlHeader_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/GANSS-ControlHeader.h

@@ -0,0 +1,45 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_GANSS_ControlHeader_H_
+#define	_GANSS_ControlHeader_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct GANSSCommonAssistData;
+struct SeqOfGANSSGenericAssistDataElement;
+
+/* GANSS-ControlHeader */
+typedef struct GANSS_ControlHeader {
+	struct GANSSCommonAssistData	*ganssCommonAssistData	/* OPTIONAL */;
+	struct SeqOfGANSSGenericAssistDataElement	*ganssGenericAssistDataList	/* OPTIONAL */;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} GANSS_ControlHeader_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_GANSS_ControlHeader;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "GANSSCommonAssistData.h"
+#include "SeqOfGANSSGenericAssistDataElement.h"
+
+#endif	/* _GANSS_ControlHeader_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/GANSS-MsrSetElement.c

@@ -0,0 +1,131 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "GANSS-MsrSetElement.h"
+
+static int
+memb_deltaGNASSTOD_constraint_1(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 <= 127)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_memb_deltaGNASSTOD_constr_4 = {
+	{ APC_CONSTRAINED,	 7,  7,  0,  127 }	/* (0..127) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_GANSS_MsrSetElement_1[] = {
+	{ ATF_POINTER, 4, offsetof(struct GANSS_MsrSetElement, referenceFrame),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ReferenceFrame,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"referenceFrame"
+		},
+	{ ATF_POINTER, 3, offsetof(struct GANSS_MsrSetElement, ganssTODm),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GANSSTODm,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"ganssTODm"
+		},
+	{ ATF_POINTER, 2, offsetof(struct GANSS_MsrSetElement, deltaGNASSTOD),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_deltaGNASSTOD_constraint_1,
+		&asn_PER_memb_deltaGNASSTOD_constr_4,
+		0,
+		"deltaGNASSTOD"
+		},
+	{ ATF_POINTER, 1, offsetof(struct GANSS_MsrSetElement, ganssTODUncertainty),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_GANSSTODUncertainty,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"ganssTODUncertainty"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct GANSS_MsrSetElement, ganss_SgnTypeList),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SeqOfGANSS_SgnTypeElement,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"ganss-SgnTypeList"
+		},
+};
+static int asn_MAP_GANSS_MsrSetElement_oms_1[] = { 0, 1, 2, 3 };
+static ber_tlv_tag_t asn_DEF_GANSS_MsrSetElement_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_GANSS_MsrSetElement_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* referenceFrame at 1456 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* ganssTODm at 1457 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* deltaGNASSTOD at 1458 */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* ganssTODUncertainty at 1459 */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* ganss-SgnTypeList at 1463 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_GANSS_MsrSetElement_specs_1 = {
+	sizeof(struct GANSS_MsrSetElement),
+	offsetof(struct GANSS_MsrSetElement, _asn_ctx),
+	asn_MAP_GANSS_MsrSetElement_tag2el_1,
+	5,	/* Count of tags in the map */
+	asn_MAP_GANSS_MsrSetElement_oms_1,	/* Optional members */
+	4, 0,	/* Root/Additions */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_GANSS_MsrSetElement = {
+	"GANSS-MsrSetElement",
+	"GANSS-MsrSetElement",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_GANSS_MsrSetElement_tags_1,
+	sizeof(asn_DEF_GANSS_MsrSetElement_tags_1)
+		/sizeof(asn_DEF_GANSS_MsrSetElement_tags_1[0]), /* 1 */
+	asn_DEF_GANSS_MsrSetElement_tags_1,	/* Same as above */
+	sizeof(asn_DEF_GANSS_MsrSetElement_tags_1)
+		/sizeof(asn_DEF_GANSS_MsrSetElement_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_GANSS_MsrSetElement_1,
+	5,	/* Elements count */
+	&asn_SPC_GANSS_MsrSetElement_specs_1	/* Additional specs */
+};
+

src/algorithms/libs/supl/asn-rrlp/GANSS-MsrSetElement.h

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#ifndef	_GANSS_MsrSetElement_H_
+#define	_GANSS_MsrSetElement_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "GANSSTODm.h"
+#include <NativeInteger.h>
+#include "GANSSTODUncertainty.h"
+#include "SeqOfGANSS-SgnTypeElement.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct ReferenceFrame;
+
+/* GANSS-MsrSetElement */
+typedef struct GANSS_MsrSetElement {
+	struct ReferenceFrame	*referenceFrame	/* OPTIONAL */;
+	GANSSTODm_t	*ganssTODm	/* OPTIONAL */;
+	long	*deltaGNASSTOD	/* OPTIONAL */;
+	GANSSTODUncertainty_t	*ganssTODUncertainty	/* OPTIONAL */;
+	SeqOfGANSS_SgnTypeElement_t	 ganss_SgnTypeList;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} GANSS_MsrSetElement_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_GANSS_MsrSetElement;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "ReferenceFrame.h"
+
+#endif	/* _GANSS_MsrSetElement_H_ */
+#include <asn_internal.h>

src/algorithms/libs/supl/asn-rrlp/GANSS-SgnElement.c

@@ -0,0 +1,351 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "RRLP-Components"
+ * 	found in "../rrlp-components.asn"
+ */
+
+#include "GANSS-SgnElement.h"
+
+static int
+memb_cNo_constraint_1(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 <= 63)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_carrierQualityInd_constraint_1(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 <= 3)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_codePhase_constraint_1(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 <= 2097151)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_integerCodePhase_constraint_1(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 <= 63)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_codePhaseRMSError_constraint_1(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 <= 63)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_doppler_constraint_1(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 >= -32768 && value <= 32767)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_adr_constraint_1(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 <= 33554431)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_per_constraints_t asn_PER_memb_cNo_constr_3 = {
+	{ APC_CONSTRAINED,	 6,  6,  0,  63 }	/* (0..63) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_carrierQualityInd_constr_5 = {
+	{ APC_CONSTRAINED,	 2,  2,  0,  3 }	/* (0..3) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_codePhase_constr_6 = {
+	{ APC_CONSTRAINED,	 21, -1,  0,  2097151 }	/* (0..2097151) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_integerCodePhase_constr_7 = {
+	{ APC_CONSTRAINED,	 6,  6,  0,  63 }	/* (0..63) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_codePhaseRMSError_constr_8 = {
+	{ APC_CONSTRAINED,	 6,  6,  0,  63 }	/* (0..63) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_doppler_constr_9 = {
+	{ APC_CONSTRAINED,	 16,  16, -32768,  32767 }	/* (-32768..32767) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_per_constraints_t asn_PER_memb_adr_constr_10 = {
+	{ APC_CONSTRAINED,	 25, -1,  0,  33554431 }	/* (0..33554431) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_GANSS_SgnElement_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct GANSS_SgnElement, svID),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SVID,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"svID"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct GANSS_SgnElement, cNo),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_cNo_constraint_1,
+		&asn_PER_memb_cNo_constr_3,
+		0,
+		"cNo"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct GANSS_SgnElement, mpathDet),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_MpathIndic,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"mpathDet"
+		},
+	{ ATF_POINTER, 1, offsetof(struct GANSS_SgnElement, carrierQualityInd),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_carrierQualityInd_constraint_1,
+		&asn_PER_memb_carrierQualityInd_constr_5,
+		0,
+		"carrierQualityInd"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct GANSS_SgnElement, codePhase),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_codePhase_constraint_1,
+		&asn_PER_memb_codePhase_constr_6,
+		0,
+		"codePhase"
+		},
+	{ ATF_POINTER, 1, offsetof(struct GANSS_SgnElement, integerCodePhase),
+		(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_integerCodePhase_constraint_1,
+		&asn_PER_memb_integerCodePhase_constr_7,
+		0,
+		"integerCodePhase"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct GANSS_SgnElement, codePhaseRMSError),
+		(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_codePhaseRMSError_constraint_1,
+		&asn_PER_memb_codePhaseRMSError_constr_8,
+		0,
+		"codePhaseRMSError"
+		},
+	{ ATF_POINTER, 2, offsetof(struct GANSS_SgnElement, doppler),
+		(ASN_TAG_CLASS_CONTEXT | (7 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_doppler_constraint_1,
+		&asn_PER_memb_doppler_constr_9,
+		0,
+		"doppler"
+		},
+	{ ATF_POINTER, 1, offsetof(struct GANSS_SgnElement, adr),
+		(ASN_TAG_CLASS_CONTEXT | (8 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_NativeInteger,
+		memb_adr_constraint_1,
+		&asn_PER_memb_adr_constr_10,
+		0,
+		"adr"
+		},
+};
+static int asn_MAP_GANSS_SgnElement_oms_1[] = { 3, 5, 7, 8 };
+static ber_tlv_tag_t asn_DEF_GANSS_SgnElement_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_GANSS_SgnElement_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* svID at 1479 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* cNo at 1480 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* mpathDet at 1481 */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* carrierQualityInd at 1482 */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* codePhase at 1483 */
+    { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* integerCodePhase at 1484 */
+    { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* codePhaseRMSError at 1485 */
+    { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 }, /* doppler at 1486 */
+    { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 } /* adr at 1487 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_GANSS_SgnElement_specs_1 = {
+	sizeof(struct GANSS_SgnElement),
+	offsetof(struct GANSS_SgnElement, _asn_ctx),
+	asn_MAP_GANSS_SgnElement_tag2el_1,
+	9,	/* Count of tags in the map */
+	asn_MAP_GANSS_SgnElement_oms_1,	/* Optional members */
+	4, 0,	/* Root/Additions */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_GANSS_SgnElement = {
+	"GANSS-SgnElement",
+	"GANSS-SgnElement",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_GANSS_SgnElement_tags_1,
+	sizeof(asn_DEF_GANSS_SgnElement_tags_1)
+		/sizeof(asn_DEF_GANSS_SgnElement_tags_1[0]), /* 1 */
+	asn_DEF_GANSS_SgnElement_tags_1,	/* Same as above */
+	sizeof(asn_DEF_GANSS_SgnElement_tags_1)
+		/sizeof(asn_DEF_GANSS_SgnElement_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_GANSS_SgnElement_1,
+	9,	/* Elements count */
+	&asn_SPC_GANSS_SgnElement_specs_1	/* Additional specs */
+};
+