Updated comment + starts ifs headers

Makefile

 
 all: .deps pyrpn.so
 
-pyrpn.so: python_pyrpn.o python_rpnexpr.o rpn_lib.o rpn_jit.o rpn_parse.o rpn_mutation.o rpn_if.o rpn_if_default.o
+pyrpn.so: python_pyrpn.o python_rpnexpr.o rpn_lib.o rpn_jit.o rpn_parse.o rpn_mutation.o rpn_if.o rpn_if_default.o rpn_ifs.o
 	$(LD) $(LDFLAGS) $(PYTHON_LDFLAGS) -o $@ $^
 
 python_pyrpn.o: python_pyrpn.c python_rpnexpr.h python_rpnexpr.o rpn_jit.o
 rpn_if_default.o: rpn_if_default.c rpn_if_default.h rpn_if.o
 	$(CC) $(CFLAGS) -c $<
 
+rpn_ifs.o: rpn_ifs.c rpn_ifs.h rpn_if.o
+	$(CC) $(CFLAGS) -c $<
+
 rpn_lib.o: rpn_lib.asm rpn_lib.h
 	$(NASM) $(NASMCFLAGS) -o $@ $<
 

python_rpnexpr.h

 
 /**@defgroup python_type RPNExpr Python class
  * @brief Exposed Python class : RPNExpr
- * @ingroup python_ext
+ * @ingroup python_module
  */
 
 /**@file python_rpnexpr.h

rpn_if.c

  */
 #include "rpn_if.h"
 
-rpn_if_t* rpn_if_new(const rpn_if_param_t *params, rpn_expr_t *rpn)
+rpn_if_t* rpn_if_new(const rpn_if_param_t *params, rpn_expr_t *rpn,
+	rpn_value_t *memmap)
 {
 	rpn_if_t *res;
+	size_t i;
 	int err;
 
 	res = malloc(sizeof(rpn_if_t));
 		goto error;
 	}
 	
-	memcpy(&res->params, params, sizeof(rpn_if_param_t));
+	//memcpy(&res->params, params, sizeof(rpn_if_param_t));
+	res->params = params;
 
-	res->mem = mmap(NULL, params->mem_sz, PROT_READ|PROT_WRITE, MAP_ANON,
-		-1, 0);
-	if(res->mem == (void*)-1)
+	if(memmap)
+	{
+		res->self_mem = 0;
+		res->mem = memmap;
+	}
+	else
 	{
-		goto mmap_err;
+		res->self_mem = 1;
+		res->mem = mmap(NULL, params->mem_sz, PROT_READ|PROT_WRITE, MAP_ANON,
+			-1, 0);
+		if(res->mem == (void*)-1)
+		{
+			goto mmap_err;
+		}
 	}
 
 	res->rpn_res = malloc(sizeof(rpn_value_t) *
 	}
 	res->rpn_args = &(res->rpn_res[params->rpn_sz]);
 
-	res->rpn = malloc(sizeof(rpn_expr_t) * params->rpn_sz);
+	res->rpn = malloc(sizeof(rpn_expr_t*) * params->rpn_sz);
 	if(!res->rpn)
 	{
 		goto rpn_expr_err;
 	}
+	for(i=0; i<params->rpn_sz; i++)
+	{
+		if(rpn_expr_init(&(res->rpn[i]), params->rpn_stack_sz,
+				params->rpn_argc) < 0)
+		{
+			goto rpn_init_error;
+		}
+	}
 
 	return res;
 
+	rpn_init_error:
+		err = errno;
+		while(i)
+		{
+			rpn_expr_close(&(res->rpn[i]));
+			i--;
+		}
 	rpn_expr_err:
 		err = errno;
 		free(res->rpn_res);
 	rpn_malloc_err:
 		err = errno;
-		munmap(res->mem, params->mem_sz);
+		if(res->self_mem)
+		{
+			munmap(res->mem, params->mem_sz);
+		}
 	mmap_err:
 		err = errno;
 		free(res);
 void rpn_if_free(rpn_if_t* rif)
 {
 	size_t i;
-	for(i=0; i<rif->params.rpn_sz; i++)
+	for(i=0; i<rif->params->rpn_sz; i++)
 	{
 		rpn_expr_close(&(rif->rpn[i]));
 	}
 	free(rif->rpn);
 	free(rif->rpn_res);
-	munmap(rif->mem, rif->params.mem_sz);
+	if(rif->self_mem)
+	{
+		munmap(rif->mem, rif->params->mem_sz);
+	}
 	free(rif);
 }
 
 {
 	size_t i;
 	size_t newpos;
-	rif->params.arg_f(rif, pos, rif->rpn_args);
+	rif->params->arg_f(rif, pos, rif->rpn_args);
 	/* WRONG ! rif->rpn_args is in rif structure and do not have to be
 	   given as argument... */
-	for(i=0; i<rif->params.rpn_sz; i++)
+	for(i=0; i<rif->params->rpn_sz; i++)
 	{
 		rif->rpn_res[i] = rpn_expr_eval(&(rif->rpn[i]), rif->rpn_args);
 	}
-	//rif->params.res_f(rif, &newpos, rif->rpn_res);
+	//rif->params->res_f(rif, &newpos, rif->rpn_res);
 	/* MEGA WRONG ! rif->rpn_res is in rif structure and do not have to be
 	   given as argument... */
-	rif->params.res_f(rif, &newpos, NULL);
+	rif->params->res_f(rif, &newpos, NULL);
 	return newpos;
 }
 
 int rpn_if_rpn_upd(rpn_if_t *rif, rpn_tokenized_t *rpns)
 {
-	return rpn_if_rpn_upd_rng(rif, rpns, rif->params.rpn_sz, 0);
+	return rpn_if_rpn_upd_rng(rif, rpns, rif->params->rpn_sz, 0);
 }
 
 int rpn_if_rpn_upd_rng(rpn_if_t *rif, rpn_tokenized_t *rpns, size_t sz,

rpn_if.h

 #include "rpn_jit.h"
 
 /**@defgroup ifs_if Iterated function
+ * @ingroup ifs
  * @brief Iterated RPN expression
  *
  * A single Iterated Function implemented using an RPN expression.
 	/**@brief Number of arguments expected by RPN expressions */
 	size_t rpn_argc;
 
+	/**@brief Sizeof RPN expression stacks */
+	unsigned char rpn_stack_sz;
+
 	/**@brief Set RPN arguments given a position
 	 * @note transform position to arguments and fetch other arguments
 	 * from memory map*/
 struct rpn_if_s
 {
 	/**@brief IF parameters */
-	rpn_if_param_t params;
+	const rpn_if_param_t *params;
 	/**@brief RPN expression(s) pointer(s) */
 	rpn_expr_t *rpn;
 	/**@brief RPN expression(s) result(s) buffer */
 	rpn_value_t *rpn_args;
 	/**@brief Memory map in wich data are fetch & stored */
 	rpn_value_t *mem;
+	/**@brief If 1 the mmap is called at initialization time, munmap
+	 * should be called by @ref rpn_if_free */
+	short self_mem;
 };
 
 /**@brief Macro fetching a memory pointer given a position
  * @return rpn_value_t* values
  */
-#define rpn_if_getitem(rif, pos) (rif->mem + (rif->params.value_sz * pos))
+#define rpn_if_getitem(rif, pos) (rif->mem + ((rif->params->value_sz) * pos))
 
-/**@brief Alloc a new @ref rpn_if_s from two transformation functions
+/**@brief Alloc a new @ref rpn_if_s using given parameters
  * @param params IF parameters
  * @param rpn list of RPN expresions of params->rpn_sz size
+ * @param memmap A suitable memory map. If NULL given, a new mmap is used
  * @return A pointer on an allocated @ref rpn_if_s
+ * @todo Delete rpn argument : rpn expressions are initialized and
+ * have to be compiled later
  */
-rpn_if_t* rpn_if_new(const rpn_if_param_t *params, rpn_expr_t *rpn);
+rpn_if_t* rpn_if_new(const rpn_if_param_t *params, rpn_expr_t *rpn,
+	rpn_value_t *memmap);
 
-/**@brief Deallocate an @ref rpn_ifs_s and its ressources and close associated 
+/**@brief Deallocate an @ref rpn_if_s and its ressources and close associated 
  * @ref rpn_expr_s
  * @param rif The IF to deallocate
  */
 
 /**@brief Update all RPN expressions
  * @param rif The concerned IF
- * @param rpn A list of tokenized expressions (must be of rif->rpn_sz size)
+ * @param rpns A list of tokenized expressions (must be of rif->rpn_sz size)
  * @return 0 if no error else -1
  * @note Shortcut for @ref rpn_if_rpn_upd_rng(rif, rpns, rif->rpn_sz, 0);
  */
 
 /**@brief Update a range of RPN expressions
  * @param rif The concerned IF
- * @param rpn A list of tokenized expressions
+ * @param rpns A list of tokenized expressions
  * @param sz Number of rpn expression in rpn argument
  * @param offset Start updating expressions from this offset
  * @return 0 if no error else -1
 
 /**@brief New @ref rpn_if_s and partial initialisation
  * @param mem_sz memory size in bytes
- * @param argc number of arguments taken by @ref rpn_expr_s
+ * @param rpn_argc number of arguments taken by @ref rpn_expr_s
  * @param rpn_count number of @ref rpn_expr_s
+ * @param value_sz the count of rpn_value_t in one memory map value
+ * @return a pointer on the initialized rif
  */
 rpn_if_t* _rpn_if_new(size_t mem_sz, size_t rpn_argc, size_t rpn_count,
 	size_t value_sz);
 
-/**@page doc_ifs
+/**@page doc_ifs Iterated function system
+ * @brief Iterated function system using RPN
  *
  * Iterated functions system are a composed of Iterated function choosed
  * randomly.

rpn_if_default.h

 #define __rpn_if_default__h__
 
 /**@file rpn_if_default.h Defines default IF
+ * @ingroup ifs_if_default
  * @brief Default IF definitions
  */
+
 /**@defgroup ifs_if_default Default functions
+ * @ingroup ifs_if
  * @brief Simple iterated functions functions
+ *
+ * Defines default @ref rpn_if_param_s.res_f and @ref rpn_if_param_s.arg_f
+ * functions.
  */
 
 #include "config.h"
 	size_t *size_lim;
 
 	/**@brief Store constant values to set mem giver res_flag
-	 * - For @ref RPN_IF_CONST_RGBA const_val points on a single value
+	 * - For @ref RPN_IF_RES_CONST_RGBA const_val points on a single value
 	 * - For @ref RPN_IF_RES_CONST_RGBA const_val points on 4 values
 	 */
 	rpn_value_t *const_val;
 int rpn_if_resf_default(rpn_if_t *rif, size_t *pos, rpn_value_t *data);
 
 /**@brief Set the first expression argument from position
- * @params rif Expressions
- * @params pos Memory map offset
- * @params args pointer on expressions arguments
+ * @param rif Expressions
+ * @param pos Memory map offset
+ * @param args pointer on expressions arguments
  * @note Other arguments are set using the generic @ref rpn_if_argf_default
  * function
  */
 int rpn_if_argf_linear(rpn_if_t *rif, size_t pos, rpn_value_t *args);
 /**@brief Transform 1st expression result to position 
- * @params rif Expressions
- * @params pos Pointer on resulting position in memory map
- * @params data Pointer on resulting data
+ * @param rif Expressions
+ * @param pos Pointer on resulting position in memory map
+ * @param data Pointer on resulting data
  * @note Data from position fecth is done by generic @ref rpn_if_resf_default
  * function
  */
 int rpn_if_resf_linear(rpn_if_t *rif, size_t *pos, rpn_value_t *data);
 
 /**@brief Set the 1st & 2nd argument from position
- * @params rif Expressions
- * @params pos Memory map offset
- * @params args pointer on expression arguments
+ * @param rif Expressions
+ * @param pos Memory map offset
+ * @param args pointer on expression arguments
  * @note Other arguments are set using the generic @ref rpn_if_argf_default
  * function
  */
 int rpn_if_argf_xy(rpn_if_t *rif, size_t pos, rpn_value_t *args);
 /**@brief Transform 1st and 2nd result into a memory map's offset
- * @params rif Expressions
+ * @param rif Expressions
  * @param pos Memory map offset pointer
- * @params data Pointer on resulting data
+ * @param data Pointer on resulting data
  * @note Data from position fetch is done by generic @ref rpn_if_resf_default
  * function
  */
 int rpn_if_resf_xy(rpn_if_t *rif, size_t *pos, rpn_value_t *data);
 
 /**@brief Set X first arguments from position
- * @params rif Expressions
- * @params pos Memory map offset
- * @params args Pointer on expression arguments
+ * @param rif Expressions
+ * @param pos Memory map offset
+ * @param args Pointer on expression arguments
  * @note Other arguments are set using the generic @ref rpn_if_argf_default
  * function
  */
 int rpn_if_argf_xdim(rpn_if_t *rif, size_t pos, rpn_value_t *args);
 /**@brief Transform X arguments into a memory map's offset
- * @params rif Expressions
+ * @param rif Expressions
  * @param pos Memory map offset pointer
  * @param data Pointer on resulting data
  * @note Data from position fetch is done by generic @ref rpn_if_resf_default

rpn_ifs.h

 #include "config.h"
 
 #include "rpn_jit.h"
+#include "rpn_if.h"
 
 /**@defgroup ifs Iterated function system
  * @brief IFS implementation with RPN expressions
  * be able to use both IFS and IF almost tansparently via Python API.
  */
 
+/**@brief struct @ref rpn_ifs_s shortcut */
+typedef struct rpn_ifs_s rpn_ifs_t;
+
+/**@brief Stores IFS informations */
+struct rpn_ifs_s
+{
+	/**@brief Parameters shared by all IF of the system */
+	rpn_if_param_t params;
+
+	/**@brief Memory map shared by all iterated functions */
+	rpn_value_t *mem;
+	/**@brief If 1 the mem has to be munmap at free time */
+	short self_mem;
+
+	/**@brief Pointers on iterated function structures */
+	rpn_if_t **rpn_if;
+	/**@brief Number of iterated functions in the system */
+	size_t if_sz;
+
+	/**@brief Current position in memory map */
+	size_t pos;
+
+	/**@brief Stores the original chance of choosing corresponding IF */
+	unsigned int *weight;
+	/** @brief Stores an array of 255 pointers on IF allowing fast
+	 * random choice */
+	rpn_if_t *if_proba[255];
+};
+
+/**@brief Initialize a new IFS struct given params
+ * @param params Individual, but shared, parameters for iteraed functions
+ * in the system
+ * @param memmap A suitable memory map or NULL
+ * @return NULL if error and set errno
+ * @note Initialized system is empty. Use @ref rpn_ifs_add_if to add an iterated
+ * function to the system
+ */
+rpn_ifs_t* rpn_ifs_new(rpn_if_param_t *params, rpn_value_t *memmap);
+
+/**@brief Free ressources of an iterated function system
+ * @param rifs The iterated function system to free
+ */
+void rpn_ifs_free(rpn_ifs_t *rifs);
+
+/**@brief Add a new iterated function to the system
+ * @param rifs The iterated function system
+ * @param exprs Optionnal strings representing RPN expressions for
+ * the new @ref rpn_if_s
+ * @return 0 on error, else returns the new @ref rpn_if_s index
+ * @note if epxrs is NULL empty RPN expressions are used
+ * @todo change the exprs argument when if init will be updated
+ */
+size_t rpn_ifs_add_if(rpn_ifs_t *rifs, rpn_expr_t **exprs, unsigned int weight);
+
+/**@brief Delete an iterated function from the system given its index
+ * @param rifs The iterated function system
+ * @param if_idx The iterated function index in the system
+ * @return -1 if error else 0
+ */
+int rpn_ifs_del_if(rpn_ifs_t *rifs, size_t if_idx);
+
+/**@brief Updates the @ref rpn_ifs_s.if_proba array using
+ * @ref rpn_ifs_s.if_proba values
+ * @param rifs The iterated function system
+ * @return -1 if error else 0
+ */
+int rpn_ifs_weight_update(rpn_ifs_t *rifs);
+
+/**@brief Randomly choose an IF and make a step updating ifs current posisition
+ * @return -1 on error else 0
+ */
+int rpn_ifs_step(rpn_ifs_t *rifs);
+
 #endif