parameters.c

This a framework to test new ideas in transmission technology. Actual development is a LDPC-coder in

/***************************************************************************
         parameter.c -- manage configuration and statistics parameter
         segments.   
                              -------------------
 
    begin                :  2002
    authors              :  Silvio Boehler
    emails               :  [e-mail]
 ***************************************************************************/

/***************************************************************************
                                 Changes
                                 -------
 date - name - description
09.09.2002 - silvio - begin work
 
 **************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program 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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/



#include "system.h"

/**
 * The interface for this file
 */

#include "parameters.h"

/**
 * Includes
 */

#include "parameter_types.h"
#include "debugging.h"
#include "memory.h"

/**
 * Debug level & testing
 */

#define DBG_LVL 4




//-------------------------------------------------------------------
// PRIVATE FUNCTIONS
//-------------------------------------------------------------------



/**
 * Allocate space for a parameter segment description.
 */

swr_parameters_desc_t *allocate_params_desc(void) {
  return (swr_parameters_desc_t *)swr_malloc(sizeof(swr_parameters_desc_t));
}



/**
 * Allocate space for the parameter description array.
 */

swr_parameter_desc_t *allocate_descs_array(int nbr_params) {
  return (swr_parameter_desc_t *)swr_malloc(sizeof(swr_parameter_desc_t[nbr_params]));
}




//-------------------------------------------------------------------
// INTERFACE FUNCTIONS
//-------------------------------------------------------------------


/**
 * Initialize a swr_parameters_desc_t
 */

int init_parameters_desc(swr_parameters_desc_t *desc, int nbr_params) {
  int i;
  if (!desc) {
    PR_DBG(0, "init_parameters_desc: desc == 0\n");
    return -1;
  }
  if (nbr_params > 0)
    desc->descs = allocate_descs_array(nbr_params);
  desc->max_nbr_params = nbr_params;
  desc->nbr_params = 0;
  desc->segment_size = 0;
  for (i = 0; i < nbr_params; i++) {
    desc->descs[i].name = 0;
    desc->descs[i].offset = 0;
  }
  desc->complete = (desc->nbr_params == desc->max_nbr_params);
  return 0;
}



/**
 * Finalize a swr_parameters_desc_t
 */

int finalize_parameters_desc(swr_parameters_desc_t *desc) {
  int i, error = 0;
  if (!desc) {
    PR_DBG(0, "finalize_parameters_desc: desc == 0\n");
    return -1;
  }
  if (desc->max_nbr_params > 0) {
    for (i = 0; i < desc->nbr_params; i++) {
      error |= swr_free(desc->descs[i].name);
    }
    error |= swr_free(desc->descs);
    if (error) {
      return -1;
      PR_DBG(0, "finalize_parameters_desc: Freeing produced errors\n");
    }
  }
  desc->nbr_params = 0;
  desc->max_nbr_params = 0;
  return 0;
}


/**
 * Add a parameter to a swr_parameters_desc_t.
 */

int add_parameter(swr_parameters_desc_t *desc,
                  parameter_type_t type,
		  unsigned long flags,
                  const char *name) {
  int align;
  if (!desc) {
    PR_DBG(0, "add_parameter: desc == NULL\n");
    return -1;
  }
  if (desc->complete) {
    PR_DBG(0, "add_parameter: desc already complete, couldn't add parameter\n");
    return -2;
  }
  if (!name) {
    PR_DBG(0, "add_parameter: name == NULL");
    return -3;
  }
  desc->descs[desc->nbr_params].type = type;
  desc->descs[desc->nbr_params].flags = flags;
  desc->descs[desc->nbr_params].name = (char *)swr_malloc(MAX_PARAM_NAME_LENGTH);
  strncpy(desc->descs[desc->nbr_params].name, name, MAX_PARAM_NAME_LENGTH);
  align = get_alignment(type);
  desc->descs[desc->nbr_params].offset = ((align + desc->segment_size - 1) / align) * align;
  desc->segment_size = get_size(type) + desc->descs[desc->nbr_params].offset;
  desc->complete = (desc->nbr_params == desc->max_nbr_params - 1);
  return (desc->nbr_params++);
}



/**
 * Check whether a parameters description is already complete.
 */

inline int parameters_desc_complete(const swr_parameters_desc_t desc) {
  return desc.complete;
}



/**
 * Get the number of a parameter, given its name.
 */

int get_parameter_nbr(const swr_parameters_desc_t desc, const char *name) {
#ifndef FAST
  int i = 0;
  if (!desc.complete) {
    PR_DBG(0, "get_parameter_nbr: Desc not complete!\n");
    return -1;
  }
#endif
  while (i < desc.nbr_params) {
    if (!strcmp(name, desc.descs[i].name))
      return i;
    i++;
  }
  PR_DBG(0, "get_parameter_nbr: name %s doesn't exist\n", name);
  return -2;
}


/**
 * Get the type of a parameter
 */
parameter_type_t get_parameter_type(const swr_parameters_desc_t desc, int index) {
#ifndef FAST
  if ( index >= desc.nbr_params ) {
    PR_DBG( 0, "No such index %i in description (max:%i)\n",
            index, desc.nbr_params );
    return UNDEFINED;
  }
#endif
  return desc.descs[index].type;
}


/**
 * Get the flags of a parameter
 */
unsigned long get_parameter_flags(const swr_parameters_desc_t desc, int index) {
#ifndef FAST
  if ( index >= desc.nbr_params ) {
    PR_DBG( 0, "No such index %i in description (max:%i)\n",
            index, desc.nbr_params );
    return UNDEFINED;
  }
#endif
  return desc.descs[index].flags;
}


/**
 * Get the size that a memory block must have in order to store all
 * parameters of a parameter description. This is the size which has
 * to be passed to a memory allocation function.
 */

int get_memory_size(const swr_parameters_desc_t desc) {
  if (!desc.complete) {
    PR_DBG(0, "get_memory_size: Description not complete\n");
    return -1;
  }
  return desc.segment_size;
}



/**
 * Set parameter value into offset of a parameter segment which has
 * the layout of parameter_desc. Value can be a stack variable.
 */

inline void *set_parameter_value(const swr_parameters_desc_t desc,
                                 void *segment,
                                 int parameter,
                                 const void *value) {
  return memcpy(segment + desc.descs[parameter].offset, value, get_size(desc.descs[parameter].type));
}


/**
 * Get parameter value
 */

inline void *get_parameter_value(const swr_parameters_desc_t desc,
                                 const void *segment,
                                 int parameter,
                                 void *value) {
#ifdef FAST
  int error = 0;
  if (!desc.complete) {
    PR_DBG(0, "get_parameter_pointer: description not complete\n");
    error++;
  }
  if (!segment) {
    PR_DBG(0, "get_parameter_pointer: pointer to segment == NULL\n");
    error++;
  }
  if (parameter < 0 || parameter >= desc.max_nbr_params) {
    PR_DBG(0, "get_parameter_pointer: Parameter number out of range\n");
    error++;
  }
  if (!error)
#endif

    return memcpy(value, segment + desc.descs[parameter].offset, get_size(desc.descs[parameter].type));
#ifdef FAST

  PR_DBG(0, "get_parameter_value: failed, returning NULL\n");
  return NULL;
#endif
}


/**
 * Get a pointer to a parameter located on the specified segment.
 */

inline void *get_parameter_pointer(const swr_parameters_desc_t desc,
                                   const void *segment,
                                   int parameter) {

#ifndef FAST
  int error = 0;
  if (!desc.complete) {
    PR_DBG(0, "get_parameter_pointer: description not complete\n");
    error++;
  }
  if (!segment) {
    PR_DBG(0, "get_parameter_pointer: pointer to segment == NULL\n");
    error++;
  }
  if (parameter < 0 || parameter >= desc.max_nbr_params) {
    PR_DBG(0, "get_parameter_pointer: Parameter number out of range\n");
    error++;
  }
  if (!error)
#endif

    return (void *)segment + desc.descs[parameter].offset;

#ifndef FAST

  PR_DBG(0, "get_parameter_pointer: failed, returning NULL\n");
  return NULL;
#endif
}



/**
 * Get the offset of a parameter
 */

inline int get_parameter_offset(const swr_parameters_desc_t desc,
                                int parameter) {

#ifndef FAST
  int error = 0;
  if (!desc.complete) {
    PR_DBG(0, "get_parameter_offset: description not complete\n");
    error++;
  }
  if (parameter < 0 || parameter >= desc.max_nbr_params) {
    PR_DBG(0, "get_parameter_offset: Parameter number out of range\n");
    error++;
  }
  if (!error)
#endif

    return desc.descs[parameter].offset;

#ifndef FAST

  PR_DBG(0, "get_parameter_offset: failed, returning NULL\n");
  return -1;
#endif
}



/**
 * Get a list with all config/stats parameter-names
 */
inline int get_parameter_names(const swr_parameters_desc_t desc,
                               char *str, int len) {
  int num, pos = 0;

  for ( num=0; num < desc.nbr_params; num++ ) {
    if ( len - pos < strlen( desc.descs[num].name ) ) {
      return -1;
    }
    pos += sprintf( str + pos, "%s,", desc.descs[num].name );
  }
  return num;
}