CMSCOPE changed

6 files changed, 2253 insertions, 0 deletions

diff --git a/modules/scicos_blocks/includes/Make.Blocks b/modules/scicos_blocks/includes/Make.Blocks
new file mode 100755
index 000000000..c73fb68b9
--- /dev/null
+++ b/modules/scicos_blocks/includes/Make.Blocks
@@ -0,0 +1,14 @@
+
+
+blocks.h: Makefile
+	@echo "generation of blocks.h"
+	@$(RM) Fblocknames Cblockname
+	@for i in $(BLOCKSF:.o=); do  (echo $$i );done > Fblocknames 
+	@for i in $(BLOCKSC:.o=); do  (echo $$i );done > Cblocknames 
+	@./GenBlocks
+
+all:: blocks-vc.h 
+
+blocks-vc.h : blocks.h 
+	@$(RM) blocks-vc.h 
+	cp blocks.h blocks-vc.h 
diff --git a/modules/scicos_blocks/includes/blocks.h b/modules/scicos_blocks/includes/blocks.h
new file mode 100755
index 000000000..51bda9a09
--- /dev/null
+++ b/modules/scicos_blocks/includes/blocks.h
@@ -0,0 +1,750 @@
+#ifndef __SCICOS_BLOCKS__ 
+#define __SCICOS_BLOCKS__ 
+#include "scicos.h" 
+/******* Copyright INRIA *************/
+/******* Please do not edit (file automatically generated) *************/
+extern void F2C(csslti) (ARGS_scicos);
+extern void F2C(cstblk) (ARGS_scicos);
+extern void F2C(delay) (ARGS_scicos);
+extern void F2C(delayv) (ARGS_scicos);
+extern void F2C(demux) (ARGS_scicos);
+extern void F2C(diffblk) (ARGS_scicos);
+extern void F2C(dlradp) (ARGS_scicos);
+extern void F2C(dollar) (ARGS_scicos);
+extern void F2C(dsslti) (ARGS_scicos);
+extern void F2C(eselect) (ARGS_scicos);
+extern void F2C(evtdly) (ARGS_scicos);
+extern void F2C(expblk) (ARGS_scicos);
+extern void F2C(forblk) (ARGS_scicos);
+extern void F2C(fsv) (ARGS_scicos);
+extern void F2C(gensin) (ARGS_scicos);
+extern void F2C(gensqr) (ARGS_scicos);
+extern void F2C(hltblk) (ARGS_scicos);
+extern void F2C(ifthel) (ARGS_scicos);
+extern void F2C(integr) (ARGS_scicos);
+extern void F2C(intplt) (ARGS_scicos);
+extern void F2C(intpol) (ARGS_scicos);
+extern void F2C(intrp2) (ARGS_scicos);
+extern void F2C(intrpl) (ARGS_scicos);
+extern void F2C(invblk) (ARGS_scicos);
+extern void F2C(iocopy) (ARGS_scicos);
+extern void F2C(logblk) (ARGS_scicos);
+extern void F2C(lookup) (ARGS_scicos);
+extern void F2C(lsplit) (ARGS_scicos);
+extern void F2C(lusat) (ARGS_scicos);
+extern void F2C(maxblk) (ARGS_scicos);
+extern void F2C(memo) (ARGS_scicos);
+extern void F2C(mfclck) (ARGS_scicos);
+extern void F2C(minblk) (ARGS_scicos);
+extern void F2C(mux) (ARGS_scicos);
+extern void F2C(pload) (ARGS_scicos);
+extern void F2C(powblk) (ARGS_scicos);
+extern void F2C(qzcel) (ARGS_scicos);
+extern void F2C(qzflr) (ARGS_scicos);
+extern void F2C(qzrnd) (ARGS_scicos);
+extern void F2C(qztrn) (ARGS_scicos);
+extern void F2C(readf) (ARGS_scicos);
+extern void F2C(rndblk) (ARGS_scicos);
+extern void F2C(samphold) (ARGS_scicos);
+extern void F2C(sawtth) (ARGS_scicos);
+extern void F2C(sciblk) (ARGS_scicos);
+extern void F2C(selblk) (ARGS_scicos);
+extern void F2C(sinblk) (ARGS_scicos);
+extern void F2C(sqrblk) (ARGS_scicos);
+extern void F2C(sum2) (ARGS_scicos);
+extern void F2C(sum3) (ARGS_scicos);
+extern void F2C(tanblk) (ARGS_scicos);
+extern void F2C(tcslti) (ARGS_scicos);
+extern void F2C(tcsltj) (ARGS_scicos);
+extern void F2C(timblk) (ARGS_scicos);
+extern void F2C(trash) (ARGS_scicos);
+extern void F2C(writef) (ARGS_scicos);
+extern void F2C(zcross) (ARGS_scicos);
+extern void absblk (ARGS_scicos);
+extern void absolute_value (ARGS_scicos);
+extern void acos_blk (ARGS_scicos);
+extern void acosh_blk (ARGS_scicos);
+extern void andlog (ARGS_scicos);
+extern void asin_blk (ARGS_scicos);
+extern void asinh_blk (ARGS_scicos);
+extern void assignment (ARGS_scicos);
+extern void atan_blk (ARGS_scicos);
+extern void atanh_blk (ARGS_scicos);
+extern void automat (ARGS_scicos);
+extern void backlash (ARGS_scicos);
+extern void bidon (ARGS_scicos);
+extern void bit_clear_16 (ARGS_scicos);
+extern void bit_clear_32 (ARGS_scicos);
+extern void bit_clear_8 (ARGS_scicos);
+extern void bit_set_16 (ARGS_scicos);
+extern void bit_set_32 (ARGS_scicos);
+extern void bit_set_8 (ARGS_scicos);
+extern void bounce_ball (ARGS_scicos);
+extern void bouncexy (ARGS_scicos);
+extern void canimxy3d (ARGS_scicos);
+extern void canimxy (ARGS_scicos);
+extern void cdummy (ARGS_scicos);
+extern void cevscpe (ARGS_scicos);
+extern void cfscope (ARGS_scicos);
+extern void cmat3d (ARGS_scicos);
+extern void cmatview (ARGS_scicos);
+extern void cmscope (ARGS_scicos);
+extern void constraint_c (ARGS_scicos);
+extern void convert (ARGS_scicos);
+extern void cos_blk (ARGS_scicos);
+extern void cosblk (ARGS_scicos);
+extern void cosh_blk (ARGS_scicos);
+extern void counter (ARGS_scicos);
+extern void cscope (ARGS_scicos);
+extern void cscopxy3d (ARGS_scicos);
+extern void cscopxy (ARGS_scicos);
+extern void csslti4 (ARGS_scicos);
+extern void cstblk4 (ARGS_scicos);
+extern void cstblk4_m (ARGS_scicos);
+extern void cumsum_c (ARGS_scicos);
+extern void cumsum_m (ARGS_scicos);
+extern void cumsum_r (ARGS_scicos);
+extern void cumsumz_c (ARGS_scicos);
+extern void cumsumz_m (ARGS_scicos);
+extern void cumsumz_r (ARGS_scicos);
+extern void curve_c (ARGS_scicos);
+extern void dband (ARGS_scicos);
+extern void deadband (ARGS_scicos);
+extern void delay4 (ARGS_scicos);
+extern void delay4_i16 (ARGS_scicos);
+extern void delay4_i32 (ARGS_scicos);
+extern void delay4_i8 (ARGS_scicos);
+extern void delay4_ui16 (ARGS_scicos);
+extern void delay4_ui32 (ARGS_scicos);
+extern void delay4_ui8 (ARGS_scicos);
+extern void deriv (ARGS_scicos);
+extern void diffblk_c (ARGS_scicos);
+extern void dmmul1 (ARGS_scicos);
+extern void dmmul (ARGS_scicos);
+extern void dollar4 (ARGS_scicos);
+extern void dollar4_m (ARGS_scicos);
+extern void dsslti4 (ARGS_scicos);
+extern void edgetrig (ARGS_scicos);
+extern void evaluate_expr (ARGS_scicos);
+extern void evtdly4 (ARGS_scicos);
+extern void evtvardly (ARGS_scicos);
+extern void expblk_m (ARGS_scicos);
+extern void extdiag (ARGS_scicos);
+extern void extdiagz (ARGS_scicos);
+extern void extract_bit_16_LH (ARGS_scicos);
+extern void extract_bit_16_LSB (ARGS_scicos);
+extern void extract_bit_16_MSB0 (ARGS_scicos);
+extern void extract_bit_16_MSB1 (ARGS_scicos);
+extern void extract_bit_16_RB0 (ARGS_scicos);
+extern void extract_bit_16_RB1 (ARGS_scicos);
+extern void extract_bit_16_UH0 (ARGS_scicos);
+extern void extract_bit_16_UH1 (ARGS_scicos);
+extern void extract_bit_32_LH (ARGS_scicos);
+extern void extract_bit_32_LSB (ARGS_scicos);
+extern void extract_bit_32_MSB0 (ARGS_scicos);
+extern void extract_bit_32_MSB1 (ARGS_scicos);
+extern void extract_bit_32_RB0 (ARGS_scicos);
+extern void extract_bit_32_RB1 (ARGS_scicos);
+extern void extract_bit_32_UH0 (ARGS_scicos);
+extern void extract_bit_32_UH1 (ARGS_scicos);
+extern void extract_bit_8_LH (ARGS_scicos);
+extern void extract_bit_8_LSB (ARGS_scicos);
+extern void extract_bit_8_MSB0 (ARGS_scicos);
+extern void extract_bit_8_MSB1 (ARGS_scicos);
+extern void extract_bit_8_RB0 (ARGS_scicos);
+extern void extract_bit_8_RB1 (ARGS_scicos);
+extern void extract_bit_8_UH0 (ARGS_scicos);
+extern void extract_bit_8_UH1 (ARGS_scicos);
+extern void extract_bit_u16_MSB1 (ARGS_scicos);
+extern void extract_bit_u16_RB1 (ARGS_scicos);
+extern void extract_bit_u16_UH1 (ARGS_scicos);
+extern void extract_bit_u32_MSB1 (ARGS_scicos);
+extern void extract_bit_u32_RB1 (ARGS_scicos);
+extern void extract_bit_u32_UH1 (ARGS_scicos);
+extern void extract_bit_u8_MSB1 (ARGS_scicos);
+extern void extract_bit_u8_RB1 (ARGS_scicos);
+extern void extract_bit_u8_UH1 (ARGS_scicos);
+extern void extract (ARGS_scicos);
+extern void extractor (ARGS_scicos);
+extern void extractz (ARGS_scicos);
+extern void exttril (ARGS_scicos);
+extern void exttrilz (ARGS_scicos);
+extern void exttriu (ARGS_scicos);
+extern void exttriuz (ARGS_scicos);
+extern void foriterator (ARGS_scicos);
+extern void fromws_c (ARGS_scicos);
+extern void gainblk (ARGS_scicos);
+extern void gainblk_i16e (ARGS_scicos);
+extern void gainblk_i16n (ARGS_scicos);
+extern void gainblk_i16s (ARGS_scicos);
+extern void gainblk_i32e (ARGS_scicos);
+extern void gainblk_i32n (ARGS_scicos);
+extern void gainblk_i32s (ARGS_scicos);
+extern void gainblk_i8e (ARGS_scicos);
+extern void gainblk_i8n (ARGS_scicos);
+extern void gainblk_i8s (ARGS_scicos);
+extern void gainblk_ui16e (ARGS_scicos);
+extern void gainblk_ui16n (ARGS_scicos);
+extern void gainblk_ui16s (ARGS_scicos);
+extern void gainblk_ui32e (ARGS_scicos);
+extern void gainblk_ui32n (ARGS_scicos);
+extern void gainblk_ui32s (ARGS_scicos);
+extern void gainblk_ui8e (ARGS_scicos);
+extern void gainblk_ui8n (ARGS_scicos);
+extern void gainblk_ui8s (ARGS_scicos);
+extern void gain (ARGS_scicos);
+extern void hystheresis (ARGS_scicos);
+extern void integral_func (ARGS_scicos);
+extern void integralz_func (ARGS_scicos);
+extern void invblk4 (ARGS_scicos);
+extern void logicalop (ARGS_scicos);
+extern void logicalop_i16 (ARGS_scicos);
+extern void logicalop_i32 (ARGS_scicos);
+extern void logicalop_i8 (ARGS_scicos);
+extern void logicalop_m (ARGS_scicos);
+extern void logicalop_ui16 (ARGS_scicos);
+extern void logicalop_ui32 (ARGS_scicos);
+extern void logicalop_ui8 (ARGS_scicos);
+extern void logic (ARGS_scicos);
+extern void lookup2d (ARGS_scicos);
+extern void lookup_c (ARGS_scicos);
+extern void mat_bksl (ARGS_scicos);
+extern void matbyscal (ARGS_scicos);
+extern void matbyscal_e (ARGS_scicos);
+extern void matbyscal_s (ARGS_scicos);
+extern void mat_cath (ARGS_scicos);
+extern void mat_catv (ARGS_scicos);
+extern void mat_det (ARGS_scicos);
+extern void mat_diag (ARGS_scicos);
+extern void mat_div (ARGS_scicos);
+extern void mat_expm (ARGS_scicos);
+extern void mathermit_m (ARGS_scicos);
+extern void mat_inv (ARGS_scicos);
+extern void mat_lu (ARGS_scicos);
+extern void matmul2_e (ARGS_scicos);
+extern void matmul2_m (ARGS_scicos);
+extern void matmul2_s (ARGS_scicos);
+extern void matmul_i16e (ARGS_scicos);
+extern void matmul_i16n (ARGS_scicos);
+extern void matmul_i16s (ARGS_scicos);
+extern void matmul_i32e (ARGS_scicos);
+extern void matmul_i32n (ARGS_scicos);
+extern void matmul_i32s (ARGS_scicos);
+extern void matmul_i8e (ARGS_scicos);
+extern void matmul_i8n (ARGS_scicos);
+extern void matmul_i8s (ARGS_scicos);
+extern void matmul_m (ARGS_scicos);
+extern void matmul_ui16e (ARGS_scicos);
+extern void matmul_ui16n (ARGS_scicos);
+extern void matmul_ui16s (ARGS_scicos);
+extern void matmul_ui32e (ARGS_scicos);
+extern void matmul_ui32n (ARGS_scicos);
+extern void matmul_ui32s (ARGS_scicos);
+extern void matmul_ui8e (ARGS_scicos);
+extern void matmul_ui8n (ARGS_scicos);
+extern void matmul_ui8s (ARGS_scicos);
+extern void mat_pinv (ARGS_scicos);
+extern void mat_reshape (ARGS_scicos);
+extern void mat_sing (ARGS_scicos);
+extern void mat_sqrt (ARGS_scicos);
+extern void mat_sum (ARGS_scicos);
+extern void mat_sumc (ARGS_scicos);
+extern void mat_suml (ARGS_scicos);
+extern void mat_svd (ARGS_scicos);
+extern void mattran_m (ARGS_scicos);
+extern void mat_vps (ARGS_scicos);
+extern void mat_vpv (ARGS_scicos);
+extern void matz_abs (ARGS_scicos);
+extern void matz_absc (ARGS_scicos);
+extern void matz_bksl (ARGS_scicos);
+extern void matz_cath (ARGS_scicos);
+extern void matz_catv (ARGS_scicos);
+extern void matz_conj (ARGS_scicos);
+extern void matz_det (ARGS_scicos);
+extern void matz_diag (ARGS_scicos);
+extern void matz_div (ARGS_scicos);
+extern void matz_expm (ARGS_scicos);
+extern void matz_inv (ARGS_scicos);
+extern void matz_lu (ARGS_scicos);
+extern void matzmul2_m (ARGS_scicos);
+extern void matzmul_m (ARGS_scicos);
+extern void matz_pinv (ARGS_scicos);
+extern void matz_reim (ARGS_scicos);
+extern void matz_reimc (ARGS_scicos);
+extern void matz_reshape (ARGS_scicos);
+extern void matz_sing (ARGS_scicos);
+extern void matz_sqrt (ARGS_scicos);
+extern void matz_sum (ARGS_scicos);
+extern void matz_sumc (ARGS_scicos);
+extern void matz_suml (ARGS_scicos);
+extern void matz_svd (ARGS_scicos);
+extern void matztran_m (ARGS_scicos);
+extern void matz_vps (ARGS_scicos);
+extern void matz_vpv (ARGS_scicos);
+extern void m_frequ (ARGS_scicos);
+extern void minmax (ARGS_scicos);
+extern void modulo_count (ARGS_scicos);
+extern void mswitch (ARGS_scicos);
+extern void multiplex (ARGS_scicos);
+extern void plusblk (ARGS_scicos);
+extern void prod (ARGS_scicos);
+extern void product (ARGS_scicos);
+extern void ramp (ARGS_scicos);
+extern void ratelimiter (ARGS_scicos);
+extern void readau (ARGS_scicos);
+extern void readc (ARGS_scicos);
+extern void relational_op (ARGS_scicos);
+extern void relationalop (ARGS_scicos);
+extern void relational_op_i16 (ARGS_scicos);
+extern void relational_op_i32 (ARGS_scicos);
+extern void relational_op_i8 (ARGS_scicos);
+extern void relational_op_ui16 (ARGS_scicos);
+extern void relational_op_ui32 (ARGS_scicos);
+extern void relational_op_ui8 (ARGS_scicos);
+extern void relay (ARGS_scicos);
+extern void ricc_m (ARGS_scicos);
+extern void rndblk_m (ARGS_scicos);
+extern void rndblkz_m (ARGS_scicos);
+extern void root_coef (ARGS_scicos);
+extern void rootz_coef (ARGS_scicos);
+extern void samphold4 (ARGS_scicos);
+extern void samphold4_m (ARGS_scicos);
+extern void satur (ARGS_scicos);
+extern void scalar2vector (ARGS_scicos);
+extern void scicosexit (ARGS_scicos);
+extern void selector (ARGS_scicos);
+extern void selector_m (ARGS_scicos);
+extern void shift_16_LA (ARGS_scicos);
+extern void shift_16_LC (ARGS_scicos);
+extern void shift_16_RA (ARGS_scicos);
+extern void shift_16_RC (ARGS_scicos);
+extern void shift_32_LA (ARGS_scicos);
+extern void shift_32_LC (ARGS_scicos);
+extern void shift_32_RA (ARGS_scicos);
+extern void shift_32_RC (ARGS_scicos);
+extern void shift_8_LA (ARGS_scicos);
+extern void shift_8_LC (ARGS_scicos);
+extern void shift_8_RA (ARGS_scicos);
+extern void shift_8_RC (ARGS_scicos);
+extern void shift_u16_RA (ARGS_scicos);
+extern void shift_u32_RA (ARGS_scicos);
+extern void shift_u8_RA (ARGS_scicos);
+extern void signum (ARGS_scicos);
+extern void sin_blk (ARGS_scicos);
+extern void sinh_blk (ARGS_scicos);
+extern void step_func (ARGS_scicos);
+extern void submat (ARGS_scicos);
+extern void submatz (ARGS_scicos);
+extern void sum (ARGS_scicos);
+extern void summation (ARGS_scicos);
+extern void summation_i16e (ARGS_scicos);
+extern void summation_i16n (ARGS_scicos);
+extern void summation_i16s (ARGS_scicos);
+extern void summation_i32e (ARGS_scicos);
+extern void summation_i32n (ARGS_scicos);
+extern void summation_i32s (ARGS_scicos);
+extern void summation_i8e (ARGS_scicos);
+extern void summation_i8n (ARGS_scicos);
+extern void summation_i8s (ARGS_scicos);
+extern void summation_ui16e (ARGS_scicos);
+extern void summation_ui16n (ARGS_scicos);
+extern void summation_ui16s (ARGS_scicos);
+extern void summation_ui32e (ARGS_scicos);
+extern void summation_ui32n (ARGS_scicos);
+extern void summation_ui32s (ARGS_scicos);
+extern void summation_ui8e (ARGS_scicos);
+extern void summation_ui8n (ARGS_scicos);
+extern void summation_ui8s (ARGS_scicos);
+extern void summation_z (ARGS_scicos);
+extern void switch2 (ARGS_scicos);
+extern void switch2_m (ARGS_scicos);
+extern void switchn (ARGS_scicos);
+extern void tablex2d_c (ARGS_scicos);
+extern void tan_blk (ARGS_scicos);
+extern void tanh_blk (ARGS_scicos);
+extern void tcslti4 (ARGS_scicos);
+extern void tcsltj4 (ARGS_scicos);
+extern void time_delay (ARGS_scicos);
+extern void tows_c (ARGS_scicos);
+extern void variable_delay (ARGS_scicos);
+extern void whileiterator (ARGS_scicos);
+extern void writeau (ARGS_scicos);
+extern void writec (ARGS_scicos);
+extern void zcross2 (ARGS_scicos);
+extern void affich2 (ARGS_scicos);
+ 
+OpTab tabsim[] ={
+{"absblk",(ScicosF) absblk},
+{"absolute_value",(ScicosF) absolute_value},
+{"acos_blk",(ScicosF) acos_blk},
+{"acosh_blk",(ScicosF) acosh_blk},
+{"affich2",(ScicosF4) affich2},
+{"andlog",(ScicosF) andlog},
+{"asin_blk",(ScicosF) asin_blk},
+{"asinh_blk",(ScicosF) asinh_blk},
+{"assignment",(ScicosF) assignment},
+{"atan_blk",(ScicosF) atan_blk},
+{"atanh_blk",(ScicosF) atanh_blk},
+{"automat",(ScicosF) automat},
+{"backlash",(ScicosF) backlash},
+{"bidon",(ScicosF) bidon},
+{"bit_clear_16",(ScicosF) bit_clear_16},
+{"bit_clear_32",(ScicosF) bit_clear_32},
+{"bit_clear_8",(ScicosF) bit_clear_8},
+{"bit_set_16",(ScicosF) bit_set_16},
+{"bit_set_32",(ScicosF) bit_set_32},
+{"bit_set_8",(ScicosF) bit_set_8},
+{"bounce_ball",(ScicosF) bounce_ball},
+{"bouncexy",(ScicosF) bouncexy},
+{"canimxy3d",(ScicosF) canimxy3d},
+{"canimxy",(ScicosF) canimxy},
+{"cdummy",(ScicosF) cdummy},
+{"cevscpe",(ScicosF) cevscpe},
+{"cfscope",(ScicosF) cfscope},
+{"cmat3d",(ScicosF) cmat3d},
+{"cmatview",(ScicosF) cmatview},
+{"cmscope",(ScicosF) cmscope},
+{"constraint_c",(ScicosF) constraint_c},
+{"convert",(ScicosF) convert},
+{"cos_blk",(ScicosF) cos_blk},
+{"cosblk",(ScicosF) cosblk},
+{"cosh_blk",(ScicosF) cosh_blk},
+{"counter",(ScicosF) counter},
+{"cscope",(ScicosF) cscope},
+{"cscopxy3d",(ScicosF) cscopxy3d},
+{"cscopxy",(ScicosF) cscopxy},
+{"csslti4",(ScicosF) csslti4},
+{"csslti",(ScicosF) F2C(csslti)},
+{"cstblk4_m",(ScicosF) cstblk4_m},
+{"cstblk4",(ScicosF) cstblk4},
+{"cstblk",(ScicosF) F2C(cstblk)},
+{"cumsum_c",(ScicosF) cumsum_c},
+{"cumsum_m",(ScicosF) cumsum_m},
+{"cumsum_r",(ScicosF) cumsum_r},
+{"cumsumz_c",(ScicosF) cumsumz_c},
+{"cumsumz_m",(ScicosF) cumsumz_m},
+{"cumsumz_r",(ScicosF) cumsumz_r},
+{"curve_c",(ScicosF) curve_c},
+{"dband",(ScicosF) dband},
+{"deadband",(ScicosF) deadband},
+{"delay4_i16",(ScicosF) delay4_i16},
+{"delay4_i32",(ScicosF) delay4_i32},
+{"delay4_i8",(ScicosF) delay4_i8},
+{"delay4",(ScicosF) delay4},
+{"delay4_ui16",(ScicosF) delay4_ui16},
+{"delay4_ui32",(ScicosF) delay4_ui32},
+{"delay4_ui8",(ScicosF) delay4_ui8},
+{"delay",(ScicosF) F2C(delay)},
+{"delayv",(ScicosF) F2C(delayv)},
+{"demux",(ScicosF) F2C(demux)},
+{"deriv",(ScicosF) deriv},
+{"diffblk_c",(ScicosF) diffblk_c},
+{"diffblk",(ScicosF) F2C(diffblk)},
+{"dlradp",(ScicosF) F2C(dlradp)},
+{"dmmul1",(ScicosF) dmmul1},
+{"dmmul",(ScicosF) dmmul},
+{"dollar4_m",(ScicosF) dollar4_m},
+{"dollar4",(ScicosF) dollar4},
+{"dollar",(ScicosF) F2C(dollar)},
+{"dsslti4",(ScicosF) dsslti4},
+{"dsslti",(ScicosF) F2C(dsslti)},
+{"edgetrig",(ScicosF) edgetrig},
+{"eselect",(ScicosF) F2C(eselect)},
+{"evaluate_expr",(ScicosF) evaluate_expr},
+{"evtdly4",(ScicosF) evtdly4},
+{"evtdly",(ScicosF) F2C(evtdly)},
+{"evtvardly",(ScicosF) evtvardly},
+{"expblk_m",(ScicosF) expblk_m},
+{"expblk",(ScicosF) F2C(expblk)},
+{"extdiag",(ScicosF) extdiag},
+{"extdiagz",(ScicosF) extdiagz},
+{"extract_bit_16_LH",(ScicosF) extract_bit_16_LH},
+{"extract_bit_16_LSB",(ScicosF) extract_bit_16_LSB},
+{"extract_bit_16_MSB0",(ScicosF) extract_bit_16_MSB0},
+{"extract_bit_16_MSB1",(ScicosF) extract_bit_16_MSB1},
+{"extract_bit_16_RB0",(ScicosF) extract_bit_16_RB0},
+{"extract_bit_16_RB1",(ScicosF) extract_bit_16_RB1},
+{"extract_bit_16_UH0",(ScicosF) extract_bit_16_UH0},
+{"extract_bit_16_UH1",(ScicosF) extract_bit_16_UH1},
+{"extract_bit_32_LH",(ScicosF) extract_bit_32_LH},
+{"extract_bit_32_LSB",(ScicosF) extract_bit_32_LSB},
+{"extract_bit_32_MSB0",(ScicosF) extract_bit_32_MSB0},
+{"extract_bit_32_MSB1",(ScicosF) extract_bit_32_MSB1},
+{"extract_bit_32_RB0",(ScicosF) extract_bit_32_RB0},
+{"extract_bit_32_RB1",(ScicosF) extract_bit_32_RB1},
+{"extract_bit_32_UH0",(ScicosF) extract_bit_32_UH0},
+{"extract_bit_32_UH1",(ScicosF) extract_bit_32_UH1},
+{"extract_bit_8_LH",(ScicosF) extract_bit_8_LH},
+{"extract_bit_8_LSB",(ScicosF) extract_bit_8_LSB},
+{"extract_bit_8_MSB0",(ScicosF) extract_bit_8_MSB0},
+{"extract_bit_8_MSB1",(ScicosF) extract_bit_8_MSB1},
+{"extract_bit_8_RB0",(ScicosF) extract_bit_8_RB0},
+{"extract_bit_8_RB1",(ScicosF) extract_bit_8_RB1},
+{"extract_bit_8_UH0",(ScicosF) extract_bit_8_UH0},
+{"extract_bit_8_UH1",(ScicosF) extract_bit_8_UH1},
+{"extract_bit_u16_MSB1",(ScicosF) extract_bit_u16_MSB1},
+{"extract_bit_u16_RB1",(ScicosF) extract_bit_u16_RB1},
+{"extract_bit_u16_UH1",(ScicosF) extract_bit_u16_UH1},
+{"extract_bit_u32_MSB1",(ScicosF) extract_bit_u32_MSB1},
+{"extract_bit_u32_RB1",(ScicosF) extract_bit_u32_RB1},
+{"extract_bit_u32_UH1",(ScicosF) extract_bit_u32_UH1},
+{"extract_bit_u8_MSB1",(ScicosF) extract_bit_u8_MSB1},
+{"extract_bit_u8_RB1",(ScicosF) extract_bit_u8_RB1},
+{"extract_bit_u8_UH1",(ScicosF) extract_bit_u8_UH1},
+{"extractor",(ScicosF) extractor},
+{"extract",(ScicosF) extract},
+{"extractz",(ScicosF) extractz},
+{"exttril",(ScicosF) exttril},
+{"exttrilz",(ScicosF) exttrilz},
+{"exttriu",(ScicosF) exttriu},
+{"exttriuz",(ScicosF) exttriuz},
+{"forblk",(ScicosF) F2C(forblk)},
+{"foriterator",(ScicosF) foriterator},
+{"fromws_c",(ScicosF) fromws_c},
+{"fsv",(ScicosF) F2C(fsv)},
+{"gainblk_i16e",(ScicosF) gainblk_i16e},
+{"gainblk_i16n",(ScicosF) gainblk_i16n},
+{"gainblk_i16s",(ScicosF) gainblk_i16s},
+{"gainblk_i32e",(ScicosF) gainblk_i32e},
+{"gainblk_i32n",(ScicosF) gainblk_i32n},
+{"gainblk_i32s",(ScicosF) gainblk_i32s},
+{"gainblk_i8e",(ScicosF) gainblk_i8e},
+{"gainblk_i8n",(ScicosF) gainblk_i8n},
+{"gainblk_i8s",(ScicosF) gainblk_i8s},
+{"gainblk",(ScicosF) gainblk},
+{"gainblk_ui16e",(ScicosF) gainblk_ui16e},
+{"gainblk_ui16n",(ScicosF) gainblk_ui16n},
+{"gainblk_ui16s",(ScicosF) gainblk_ui16s},
+{"gainblk_ui32e",(ScicosF) gainblk_ui32e},
+{"gainblk_ui32n",(ScicosF) gainblk_ui32n},
+{"gainblk_ui32s",(ScicosF) gainblk_ui32s},
+{"gainblk_ui8e",(ScicosF) gainblk_ui8e},
+{"gainblk_ui8n",(ScicosF) gainblk_ui8n},
+{"gainblk_ui8s",(ScicosF) gainblk_ui8s},
+{"gain",(ScicosF) gain},
+{"gensin",(ScicosF) F2C(gensin)},
+{"gensqr",(ScicosF) F2C(gensqr)},
+{"hltblk",(ScicosF) F2C(hltblk)},
+{"hystheresis",(ScicosF) hystheresis},
+{"ifthel",(ScicosF) F2C(ifthel)},
+{"integral_func",(ScicosF) integral_func},
+{"integralz_func",(ScicosF) integralz_func},
+{"integr",(ScicosF) F2C(integr)},
+{"intplt",(ScicosF) F2C(intplt)},
+{"intpol",(ScicosF) F2C(intpol)},
+{"intrp2",(ScicosF) F2C(intrp2)},
+{"intrpl",(ScicosF) F2C(intrpl)},
+{"invblk4",(ScicosF) invblk4},
+{"invblk",(ScicosF) F2C(invblk)},
+{"iocopy",(ScicosF) F2C(iocopy)},
+{"logblk",(ScicosF) F2C(logblk)},
+{"logicalop_i16",(ScicosF) logicalop_i16},
+{"logicalop_i32",(ScicosF) logicalop_i32},
+{"logicalop_i8",(ScicosF) logicalop_i8},
+{"logicalop_m",(ScicosF) logicalop_m},
+{"logicalop",(ScicosF) logicalop},
+{"logicalop_ui16",(ScicosF) logicalop_ui16},
+{"logicalop_ui32",(ScicosF) logicalop_ui32},
+{"logicalop_ui8",(ScicosF) logicalop_ui8},
+{"logic",(ScicosF) logic},
+{"lookup2d",(ScicosF) lookup2d},
+{"lookup_c",(ScicosF) lookup_c},
+{"lookup",(ScicosF) F2C(lookup)},
+{"lsplit",(ScicosF) F2C(lsplit)},
+{"lusat",(ScicosF) F2C(lusat)},
+{"mat_bksl",(ScicosF) mat_bksl},
+{"matbyscal_e",(ScicosF) matbyscal_e},
+{"matbyscal",(ScicosF) matbyscal},
+{"matbyscal_s",(ScicosF) matbyscal_s},
+{"mat_cath",(ScicosF) mat_cath},
+{"mat_catv",(ScicosF) mat_catv},
+{"mat_det",(ScicosF) mat_det},
+{"mat_diag",(ScicosF) mat_diag},
+{"mat_div",(ScicosF) mat_div},
+{"mat_expm",(ScicosF) mat_expm},
+{"mathermit_m",(ScicosF) mathermit_m},
+{"mat_inv",(ScicosF) mat_inv},
+{"mat_lu",(ScicosF) mat_lu},
+{"matmul2_e",(ScicosF) matmul2_e},
+{"matmul2_m",(ScicosF) matmul2_m},
+{"matmul2_s",(ScicosF) matmul2_s},
+{"matmul_i16e",(ScicosF) matmul_i16e},
+{"matmul_i16n",(ScicosF) matmul_i16n},
+{"matmul_i16s",(ScicosF) matmul_i16s},
+{"matmul_i32e",(ScicosF) matmul_i32e},
+{"matmul_i32n",(ScicosF) matmul_i32n},
+{"matmul_i32s",(ScicosF) matmul_i32s},
+{"matmul_i8e",(ScicosF) matmul_i8e},
+{"matmul_i8n",(ScicosF) matmul_i8n},
+{"matmul_i8s",(ScicosF) matmul_i8s},
+{"matmul_m",(ScicosF) matmul_m},
+{"matmul_ui16e",(ScicosF) matmul_ui16e},
+{"matmul_ui16n",(ScicosF) matmul_ui16n},
+{"matmul_ui16s",(ScicosF) matmul_ui16s},
+{"matmul_ui32e",(ScicosF) matmul_ui32e},
+{"matmul_ui32n",(ScicosF) matmul_ui32n},
+{"matmul_ui32s",(ScicosF) matmul_ui32s},
+{"matmul_ui8e",(ScicosF) matmul_ui8e},
+{"matmul_ui8n",(ScicosF) matmul_ui8n},
+{"matmul_ui8s",(ScicosF) matmul_ui8s},
+{"mat_pinv",(ScicosF) mat_pinv},
+{"mat_reshape",(ScicosF) mat_reshape},
+{"mat_sing",(ScicosF) mat_sing},
+{"mat_sqrt",(ScicosF) mat_sqrt},
+{"mat_sumc",(ScicosF) mat_sumc},
+{"mat_suml",(ScicosF) mat_suml},
+{"mat_sum",(ScicosF) mat_sum},
+{"mat_svd",(ScicosF) mat_svd},
+{"mattran_m",(ScicosF) mattran_m},
+{"mat_vps",(ScicosF) mat_vps},
+{"mat_vpv",(ScicosF) mat_vpv},
+{"matz_absc",(ScicosF) matz_absc},
+{"matz_abs",(ScicosF) matz_abs},
+{"matz_bksl",(ScicosF) matz_bksl},
+{"matz_cath",(ScicosF) matz_cath},
+{"matz_catv",(ScicosF) matz_catv},
+{"matz_conj",(ScicosF) matz_conj},
+{"matz_det",(ScicosF) matz_det},
+{"matz_diag",(ScicosF) matz_diag},
+{"matz_div",(ScicosF) matz_div},
+{"matz_expm",(ScicosF) matz_expm},
+{"matz_inv",(ScicosF) matz_inv},
+{"matz_lu",(ScicosF) matz_lu},
+{"matzmul2_m",(ScicosF) matzmul2_m},
+{"matzmul_m",(ScicosF) matzmul_m},
+{"matz_pinv",(ScicosF) matz_pinv},
+{"matz_reimc",(ScicosF) matz_reimc},
+{"matz_reim",(ScicosF) matz_reim},
+{"matz_reshape",(ScicosF) matz_reshape},
+{"matz_sing",(ScicosF) matz_sing},
+{"matz_sqrt",(ScicosF) matz_sqrt},
+{"matz_sumc",(ScicosF) matz_sumc},
+{"matz_suml",(ScicosF) matz_suml},
+{"matz_sum",(ScicosF) matz_sum},
+{"matz_svd",(ScicosF) matz_svd},
+{"matztran_m",(ScicosF) matztran_m},
+{"matz_vps",(ScicosF) matz_vps},
+{"matz_vpv",(ScicosF) matz_vpv},
+{"maxblk",(ScicosF) F2C(maxblk)},
+{"memo",(ScicosF) F2C(memo)},
+{"mfclck",(ScicosF) F2C(mfclck)},
+{"m_frequ",(ScicosF) m_frequ},
+{"minblk",(ScicosF) F2C(minblk)},
+{"minmax",(ScicosF) minmax},
+{"modulo_count",(ScicosF) modulo_count},
+{"mswitch",(ScicosF) mswitch},
+{"multiplex",(ScicosF) multiplex},
+{"mux",(ScicosF) F2C(mux)},
+{"pload",(ScicosF) F2C(pload)},
+{"plusblk",(ScicosF) plusblk},
+{"powblk",(ScicosF) F2C(powblk)},
+{"prod",(ScicosF) prod},
+{"product",(ScicosF) product},
+{"qzcel",(ScicosF) F2C(qzcel)},
+{"qzflr",(ScicosF) F2C(qzflr)},
+{"qzrnd",(ScicosF) F2C(qzrnd)},
+{"qztrn",(ScicosF) F2C(qztrn)},
+{"ramp",(ScicosF) ramp},
+{"ratelimiter",(ScicosF) ratelimiter},
+{"readau",(ScicosF) readau},
+{"readc",(ScicosF) readc},
+{"readf",(ScicosF) F2C(readf)},
+{"relational_op_i16",(ScicosF) relational_op_i16},
+{"relational_op_i32",(ScicosF) relational_op_i32},
+{"relational_op_i8",(ScicosF) relational_op_i8},
+{"relational_op",(ScicosF) relational_op},
+{"relationalop",(ScicosF) relationalop},
+{"relational_op_ui16",(ScicosF) relational_op_ui16},
+{"relational_op_ui32",(ScicosF) relational_op_ui32},
+{"relational_op_ui8",(ScicosF) relational_op_ui8},
+{"relay",(ScicosF) relay},
+{"ricc_m",(ScicosF) ricc_m},
+{"rndblk_m",(ScicosF) rndblk_m},
+{"rndblk",(ScicosF) F2C(rndblk)},
+{"rndblkz_m",(ScicosF) rndblkz_m},
+{"root_coef",(ScicosF) root_coef},
+{"rootz_coef",(ScicosF) rootz_coef},
+{"samphold4_m",(ScicosF) samphold4_m},
+{"samphold4",(ScicosF) samphold4},
+{"samphold",(ScicosF) F2C(samphold)},
+{"satur",(ScicosF) satur},
+{"sawtth",(ScicosF) F2C(sawtth)},
+{"scalar2vector",(ScicosF) scalar2vector},
+{"sciblk",(ScicosF) F2C(sciblk)},
+{"scicosexit",(ScicosF) scicosexit},
+{"selblk",(ScicosF) F2C(selblk)},
+{"selector_m",(ScicosF) selector_m},
+{"selector",(ScicosF) selector},
+{"shift_16_LA",(ScicosF) shift_16_LA},
+{"shift_16_LC",(ScicosF) shift_16_LC},
+{"shift_16_RA",(ScicosF) shift_16_RA},
+{"shift_16_RC",(ScicosF) shift_16_RC},
+{"shift_32_LA",(ScicosF) shift_32_LA},
+{"shift_32_LC",(ScicosF) shift_32_LC},
+{"shift_32_RA",(ScicosF) shift_32_RA},
+{"shift_32_RC",(ScicosF) shift_32_RC},
+{"shift_8_LA",(ScicosF) shift_8_LA},
+{"shift_8_LC",(ScicosF) shift_8_LC},
+{"shift_8_RA",(ScicosF) shift_8_RA},
+{"shift_8_RC",(ScicosF) shift_8_RC},
+{"shift_u16_RA",(ScicosF) shift_u16_RA},
+{"shift_u32_RA",(ScicosF) shift_u32_RA},
+{"shift_u8_RA",(ScicosF) shift_u8_RA},
+{"signum",(ScicosF) signum},
+{"sinblk",(ScicosF) F2C(sinblk)},
+{"sin_blk",(ScicosF) sin_blk},
+{"sinh_blk",(ScicosF) sinh_blk},
+{"sqrblk",(ScicosF) F2C(sqrblk)},
+{"step_func",(ScicosF) step_func},
+{"submat",(ScicosF) submat},
+{"submatz",(ScicosF) submatz},
+{"sum2",(ScicosF) F2C(sum2)},
+{"sum3",(ScicosF) F2C(sum3)},
+{"summation_i16e",(ScicosF) summation_i16e},
+{"summation_i16n",(ScicosF) summation_i16n},
+{"summation_i16s",(ScicosF) summation_i16s},
+{"summation_i32e",(ScicosF) summation_i32e},
+{"summation_i32n",(ScicosF) summation_i32n},
+{"summation_i32s",(ScicosF) summation_i32s},
+{"summation_i8e",(ScicosF) summation_i8e},
+{"summation_i8n",(ScicosF) summation_i8n},
+{"summation_i8s",(ScicosF) summation_i8s},
+{"summation",(ScicosF) summation},
+{"summation_ui16e",(ScicosF) summation_ui16e},
+{"summation_ui16n",(ScicosF) summation_ui16n},
+{"summation_ui16s",(ScicosF) summation_ui16s},
+{"summation_ui32e",(ScicosF) summation_ui32e},
+{"summation_ui32n",(ScicosF) summation_ui32n},
+{"summation_ui32s",(ScicosF) summation_ui32s},
+{"summation_ui8e",(ScicosF) summation_ui8e},
+{"summation_ui8n",(ScicosF) summation_ui8n},
+{"summation_ui8s",(ScicosF) summation_ui8s},
+{"summation_z",(ScicosF) summation_z},
+{"sum",(ScicosF) sum},
+{"switch2_m",(ScicosF) switch2_m},
+{"switch2",(ScicosF) switch2},
+{"switchn",(ScicosF) switchn},
+{"tablex2d_c",(ScicosF) tablex2d_c},
+{"tanblk",(ScicosF) F2C(tanblk)},
+{"tan_blk",(ScicosF) tan_blk},
+{"tanh_blk",(ScicosF) tanh_blk},
+{"tcslti4",(ScicosF) tcslti4},
+{"tcslti",(ScicosF) F2C(tcslti)},
+{"tcsltj4",(ScicosF) tcsltj4},
+{"tcsltj",(ScicosF) F2C(tcsltj)},
+{"timblk",(ScicosF) F2C(timblk)},
+{"time_delay",(ScicosF) time_delay},
+{"tows_c",(ScicosF) tows_c},
+{"trash",(ScicosF) F2C(trash)},
+{"variable_delay",(ScicosF) variable_delay},
+{"whileiterator",(ScicosF) whileiterator},
+{"writeau",(ScicosF) writeau},
+{"writec",(ScicosF) writec},
+{"writef",(ScicosF) F2C(writef)},
+{"zcross2",(ScicosF) zcross2},
+{"zcross",(ScicosF) F2C(zcross)},
+{(char *) 0, (ScicosF) 0}};
+ 
+int ntabsim= 369 ;
+#endif 
+/***********************************/
diff --git a/modules/scicos_blocks/includes/blocks.h.vc b/modules/scicos_blocks/includes/blocks.h.vc
new file mode 100755
index 000000000..29e2929c0
--- /dev/null
+++ b/modules/scicos_blocks/includes/blocks.h.vc
@@ -0,0 +1,778 @@
+
+/*  Scicos
+*
+*  Copyright (C) INRIA - METALAU Project <scicos@inria.fr>
+*  Copyright (C) DIGITEO - 2010-2011
+*
+* 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.
+*
+* This program 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 this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*
+* See the file ./license.txt
+*/
+#ifndef __SCICOS_BLOCKS_H__
+#define __SCICOS_BLOCKS_H__
+
+#include "machine.h"
+#include "dynlib_scicos_blocks.h"
+#include "scicos.h"
+
+/******* Please do not edit *************/
+
+SCICOS_BLOCKS_IMPEXP void C2F(zcross)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(writef)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(trash)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(timblk)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(tcsltj)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(tcslti)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(tanblk)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(sum3)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(sum2)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(sqrblk)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(sinblk)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(selblk)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(sciblk)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(sawtth)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(samphold)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(rndblk)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(readf)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(qztrn)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(qzrnd)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(qzflr)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(qzcel)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(powblk)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(pload)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(mux)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(minblk)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(mfclck)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(memo)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(maxblk)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(lusat)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(lsplit)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(lookup)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(logblk)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(iocopy)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(invblk)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(intrpl)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(intrp2)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(intpol)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(intplt)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(integr)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(ifthel)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(hltblk)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(gensqr)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(gensin)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(fsv)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(forblk)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(expblk)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(evtdly)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(eselect)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(dsslti)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(dollar)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(dlradp)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(diffblk)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(demux)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(delayv)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(delay)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(cstblk)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void C2F(csslti)(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void zcross2(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void writec(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void writeau(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void whileiterator(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void variable_delay(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void tows_c(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void time_delay(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void tcsltj4(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void tcslti4(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void tanh_blk(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void tan_blk(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void tablex2d_c(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void switchn(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void switch2_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void switch2(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_z(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_ui8s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_ui8n(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_ui8e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_ui32s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_ui32n(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_ui32e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_ui16s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_ui16n(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_ui16e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_i8s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_i8n(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_i8e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_i32s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_i32n(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_i32e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_i16s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_i16n(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation_i16e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void summation(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void sum(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void submatz(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void submat(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void step_func(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void sinh_blk(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void sin_blk(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void signum(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void shift_u8_RA(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void shift_u32_RA(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void shift_u16_RA(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void shift_8_RC(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void shift_8_RA(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void shift_8_LC(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void shift_8_LA(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void shift_32_RC(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void shift_32_RA(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void shift_32_LC(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void shift_32_LA(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void shift_16_RC(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void shift_16_RA(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void shift_16_LC(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void shift_16_LA(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void selector_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void selector(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void scicosexit(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void scalar2vector(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void satur(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void samphold4_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void samphold4(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void rootz_coef(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void root_coef(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void rndblkz_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void rndblk_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void ricc_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void relay(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void relationalop(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void relational_op_ui8(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void relational_op_ui32(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void relational_op_ui16(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void relational_op_i8(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void relational_op_i32(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void relational_op_i16(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void relational_op(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void readc(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void readau(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void ratelimiter(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void ramp(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void product(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void prod(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void plusblk(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void multiplex(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mswitch(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void modulo_count(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void minmax(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matztran_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matzmul_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matzmul2_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_vpv(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_vps(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_svd(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_suml(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_sumc(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_sum(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_sqrt(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_sing(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_reshape(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_reimc(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_reim(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_pinv(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_lu(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_inv(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_expm(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_div(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_diag(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_det(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_conj(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_catv(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_cath(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_bksl(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_absc(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matz_abs(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mattran_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_ui8s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_ui8n(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_ui8e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_ui32s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_ui32n(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_ui32e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_ui16s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_ui16n(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_ui16e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_i8s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_i8n(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_i8e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_i32s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_i32n(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_i32e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_i16s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_i16n(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul_i16e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul2_s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul2_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matmul2_e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mathermit_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matbyscal_s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matbyscal_e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void matbyscal(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_vpv(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_vps(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_svd(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_suml(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_sumc(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_sum(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_sqrt(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_sing(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_reshape(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_pinv(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_lu(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_inv(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_expm(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_div(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_diag(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_det(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_catv(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_cath(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void mat_bksl(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void m_frequ(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void lookup_c(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void lookup2d(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void logicalop_ui8(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void logicalop_ui32(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void logicalop_ui16(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void logicalop_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void logicalop_i8(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void logicalop_i32(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void logicalop_i16(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void logicalop(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void logic(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void invblk4(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void integralz_func(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void integral_func(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void hystheresis(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk_ui8s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk_ui8n(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk_ui8e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk_ui32s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk_ui32n(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk_ui32e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk_ui16s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk_ui16n(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk_ui16e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk_i8s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk_i8n(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk_i8e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk_i32s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk_i32n(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk_i32e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk_i16s(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk_i16n(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk_i16e(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gainblk(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void gain(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void fromws_c(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void foriterator(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void exttriuz(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void exttriu(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void exttrilz(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void exttril(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extractz(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extractor(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_u8_UH1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_u8_RB1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_u8_MSB1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_u32_UH1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_u32_RB1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_u32_MSB1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_u16_UH1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_u16_RB1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_u16_MSB1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_8_UH1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_8_UH0(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_8_RB1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_8_RB0(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_8_MSB1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_8_MSB0(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_8_LSB(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_8_LH(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_32_UH1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_32_UH0(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_32_RB1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_32_RB0(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_32_MSB1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_32_MSB0(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_32_LSB(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_32_LH(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_16_UH1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_16_UH0(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_16_RB1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_16_RB0(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_16_MSB1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_16_MSB0(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_16_LSB(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract_bit_16_LH(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extract(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extdiagz(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void extdiag(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void expblk_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void evtvardly(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void evtdly4(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void evaluate_expr(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void edgetrig(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void dsslti4(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void dollar4_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void dollar4(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void dmmul1(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void dmmul(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void diffblk_c(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void deriv(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void delay4_ui8(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void delay4_ui32(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void delay4_ui16(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void delay4_i8(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void delay4_i32(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void delay4_i16(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void delay4(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void deadband(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void dband(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void curve_c(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cumsumz_r(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cumsumz_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cumsumz_c(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cumsum_r(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cumsum_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cumsum_c(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cstblk4_m(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cstblk4(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void csslti4(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cscopxy3d(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cscopxy(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cscope(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void counter(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cosh_blk(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cosblk(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cos_blk(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void convert(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void constraint_c(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cmscope(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cmatview(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cmat3d(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cfscope(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cevscpe(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void cdummy(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void canimxy3d(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void canimxy(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void bouncexy(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void bounce_ball(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void bit_set_8(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void bit_set_32(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void bit_set_16(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void bit_clear_8(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void bit_clear_32(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void bit_clear_16(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void bidon(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void backlash(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void automat(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void atanh_blk(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void atan_blk(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void assignment(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void asinh_blk(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void asin_blk(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void andlog(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void acosh_blk(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void acos_blk(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void absolute_value(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void absblk(ARGS_scicos);
+SCICOS_BLOCKS_IMPEXP void affich2(ARGS_scicos);
+
+#define SIZE_TAB_BLOCK_LIST 370
+int ntabsim = SIZE_TAB_BLOCK_LIST;
+
+OpTab tabsim[SIZE_TAB_BLOCK_LIST] = {
+{"zcross",(ScicosF) C2F(zcross)},
+{"writef",(ScicosF) C2F(writef)},
+{"trash",(ScicosF) C2F(trash)},
+{"timblk",(ScicosF) C2F(timblk)},
+{"tcsltj",(ScicosF) C2F(tcsltj)},
+{"tcslti",(ScicosF) C2F(tcslti)},
+{"tanblk",(ScicosF) C2F(tanblk)},
+{"sum3",(ScicosF) C2F(sum3)},
+{"sum2",(ScicosF) C2F(sum2)},
+{"sqrblk",(ScicosF) C2F(sqrblk)},
+{"sinblk",(ScicosF) C2F(sinblk)},
+{"selblk",(ScicosF) C2F(selblk)},
+{"sciblk",(ScicosF) C2F(sciblk)},
+{"sawtth",(ScicosF) C2F(sawtth)},
+{"samphold",(ScicosF) C2F(samphold)},
+{"rndblk",(ScicosF) C2F(rndblk)},
+{"readf",(ScicosF) C2F(readf)},
+{"qztrn",(ScicosF) C2F(qztrn)},
+{"qzrnd",(ScicosF) C2F(qzrnd)},
+{"qzflr",(ScicosF) C2F(qzflr)},
+{"qzcel",(ScicosF) C2F(qzcel)},
+{"powblk",(ScicosF) C2F(powblk)},
+{"pload",(ScicosF) C2F(pload)},
+{"mux",(ScicosF) C2F(mux)},
+{"minblk",(ScicosF) C2F(minblk)},
+{"mfclck",(ScicosF) C2F(mfclck)},
+{"memo",(ScicosF) C2F(memo)},
+{"maxblk",(ScicosF) C2F(maxblk)},
+{"lusat",(ScicosF) C2F(lusat)},
+{"lsplit",(ScicosF) C2F(lsplit)},
+{"lookup",(ScicosF) C2F(lookup)},
+{"logblk",(ScicosF) C2F(logblk)},
+{"iocopy",(ScicosF) C2F(iocopy)},
+{"invblk",(ScicosF) C2F(invblk)},
+{"intrpl",(ScicosF) C2F(intrpl)},
+{"intrp2",(ScicosF) C2F(intrp2)},
+{"intpol",(ScicosF) C2F(intpol)},
+{"intplt",(ScicosF) C2F(intplt)},
+{"integr",(ScicosF) C2F(integr)},
+{"ifthel",(ScicosF) C2F(ifthel)},
+{"hltblk",(ScicosF) C2F(hltblk)},
+{"gensqr",(ScicosF) C2F(gensqr)},
+{"gensin",(ScicosF) C2F(gensin)},
+{"fsv",(ScicosF) C2F(fsv)},
+{"forblk",(ScicosF) C2F(forblk)},
+{"expblk",(ScicosF) C2F(expblk)},
+{"evtdly",(ScicosF) C2F(evtdly)},
+{"eselect",(ScicosF) C2F(eselect)},
+{"dsslti",(ScicosF) C2F(dsslti)},
+{"dollar",(ScicosF) C2F(dollar)},
+{"dlradp",(ScicosF) C2F(dlradp)},
+{"diffblk",(ScicosF) C2F(diffblk)},
+{"demux",(ScicosF) C2F(demux)},
+{"delayv",(ScicosF) C2F(delayv)},
+{"delay",(ScicosF) C2F(delay)},
+{"cstblk",(ScicosF) C2F(cstblk)},
+{"csslti",(ScicosF) C2F(csslti)},
+{"zcross2",(ScicosF) zcross2},
+{"writec",(ScicosF) writec},
+{"writeau",(ScicosF) writeau},
+{"whileiterator",(ScicosF) whileiterator},
+{"variable_delay",(ScicosF) variable_delay},
+{"tows_c",(ScicosF) tows_c},
+{"time_delay",(ScicosF) time_delay},
+{"tcsltj4",(ScicosF) tcsltj4},
+{"tcslti4",(ScicosF) tcslti4},
+{"tanh_blk",(ScicosF) tanh_blk},
+{"tan_blk",(ScicosF) tan_blk},
+{"tablex2d_c",(ScicosF) tablex2d_c},
+{"switchn",(ScicosF) switchn},
+{"switch2_m",(ScicosF) switch2_m},
+{"switch2",(ScicosF) switch2},
+{"summation_z",(ScicosF) summation_z},
+{"summation_ui8s",(ScicosF) summation_ui8s},
+{"summation_ui8n",(ScicosF) summation_ui8n},
+{"summation_ui8e",(ScicosF) summation_ui8e},
+{"summation_ui32s",(ScicosF) summation_ui32s},
+{"summation_ui32n",(ScicosF) summation_ui32n},
+{"summation_ui32e",(ScicosF) summation_ui32e},
+{"summation_ui16s",(ScicosF) summation_ui16s},
+{"summation_ui16n",(ScicosF) summation_ui16n},
+{"summation_ui16e",(ScicosF) summation_ui16e},
+{"summation_i8s",(ScicosF) summation_i8s},
+{"summation_i8n",(ScicosF) summation_i8n},
+{"summation_i8e",(ScicosF) summation_i8e},
+{"summation_i32s",(ScicosF) summation_i32s},
+{"summation_i32n",(ScicosF) summation_i32n},
+{"summation_i32e",(ScicosF) summation_i32e},
+{"summation_i16s",(ScicosF) summation_i16s},
+{"summation_i16n",(ScicosF) summation_i16n},
+{"summation_i16e",(ScicosF) summation_i16e},
+{"summation",(ScicosF) summation},
+{"sum",(ScicosF) sum},
+{"submatz",(ScicosF) submatz},
+{"submat",(ScicosF) submat},
+{"step_func",(ScicosF) step_func},
+{"sinh_blk",(ScicosF) sinh_blk},
+{"sin_blk",(ScicosF) sin_blk},
+{"signum",(ScicosF) signum},
+{"shift_u8_RA",(ScicosF) shift_u8_RA},
+{"shift_u32_RA",(ScicosF) shift_u32_RA},
+{"shift_u16_RA",(ScicosF) shift_u16_RA},
+{"shift_8_RC",(ScicosF) shift_8_RC},
+{"shift_8_RA",(ScicosF) shift_8_RA},
+{"shift_8_LC",(ScicosF) shift_8_LC},
+{"shift_8_LA",(ScicosF) shift_8_LA},
+{"shift_32_RC",(ScicosF) shift_32_RC},
+{"shift_32_RA",(ScicosF) shift_32_RA},
+{"shift_32_LC",(ScicosF) shift_32_LC},
+{"shift_32_LA",(ScicosF) shift_32_LA},
+{"shift_16_RC",(ScicosF) shift_16_RC},
+{"shift_16_RA",(ScicosF) shift_16_RA},
+{"shift_16_LC",(ScicosF) shift_16_LC},
+{"shift_16_LA",(ScicosF) shift_16_LA},
+{"selector_m",(ScicosF) selector_m},
+{"selector",(ScicosF) selector},
+{"scicosexit",(ScicosF) scicosexit},
+{"scalar2vector",(ScicosF) scalar2vector},
+{"satur",(ScicosF) satur},
+{"samphold4_m",(ScicosF) samphold4_m},
+{"samphold4",(ScicosF) samphold4},
+{"rootz_coef",(ScicosF) rootz_coef},
+{"root_coef",(ScicosF) root_coef},
+{"rndblkz_m",(ScicosF) rndblkz_m},
+{"rndblk_m",(ScicosF) rndblk_m},
+{"ricc_m",(ScicosF) ricc_m},
+{"relay",(ScicosF) relay},
+{"relationalop",(ScicosF) relationalop},
+{"relational_op_ui8",(ScicosF) relational_op_ui8},
+{"relational_op_ui32",(ScicosF) relational_op_ui32},
+{"relational_op_ui16",(ScicosF) relational_op_ui16},
+{"relational_op_i8",(ScicosF) relational_op_i8},
+{"relational_op_i32",(ScicosF) relational_op_i32},
+{"relational_op_i16",(ScicosF) relational_op_i16},
+{"relational_op",(ScicosF) relational_op},
+{"readc",(ScicosF) readc},
+{"readau",(ScicosF) readau},
+{"ratelimiter",(ScicosF) ratelimiter},
+{"ramp",(ScicosF) ramp},
+{"product",(ScicosF) product},
+{"prod",(ScicosF) prod},
+{"plusblk",(ScicosF) plusblk},
+{"multiplex",(ScicosF) multiplex},
+{"mswitch",(ScicosF) mswitch},
+{"modulo_count",(ScicosF) modulo_count},
+{"minmax",(ScicosF) minmax},
+{"matztran_m",(ScicosF) matztran_m},
+{"matzmul_m",(ScicosF) matzmul_m},
+{"matzmul2_m",(ScicosF) matzmul2_m},
+{"matz_vpv",(ScicosF) matz_vpv},
+{"matz_vps",(ScicosF) matz_vps},
+{"matz_svd",(ScicosF) matz_svd},
+{"matz_suml",(ScicosF) matz_suml},
+{"matz_sumc",(ScicosF) matz_sumc},
+{"matz_sum",(ScicosF) matz_sum},
+{"matz_sqrt",(ScicosF) matz_sqrt},
+{"matz_sing",(ScicosF) matz_sing},
+{"matz_reshape",(ScicosF) matz_reshape},
+{"matz_reimc",(ScicosF) matz_reimc},
+{"matz_reim",(ScicosF) matz_reim},
+{"matz_pinv",(ScicosF) matz_pinv},
+{"matz_lu",(ScicosF) matz_lu},
+{"matz_inv",(ScicosF) matz_inv},
+{"matz_expm",(ScicosF) matz_expm},
+{"matz_div",(ScicosF) matz_div},
+{"matz_diag",(ScicosF) matz_diag},
+{"matz_det",(ScicosF) matz_det},
+{"matz_conj",(ScicosF) matz_conj},
+{"matz_catv",(ScicosF) matz_catv},
+{"matz_cath",(ScicosF) matz_cath},
+{"matz_bksl",(ScicosF) matz_bksl},
+{"matz_absc",(ScicosF) matz_absc},
+{"matz_abs",(ScicosF) matz_abs},
+{"mattran_m",(ScicosF) mattran_m},
+{"matmul_ui8s",(ScicosF) matmul_ui8s},
+{"matmul_ui8n",(ScicosF) matmul_ui8n},
+{"matmul_ui8e",(ScicosF) matmul_ui8e},
+{"matmul_ui32s",(ScicosF) matmul_ui32s},
+{"matmul_ui32n",(ScicosF) matmul_ui32n},
+{"matmul_ui32e",(ScicosF) matmul_ui32e},
+{"matmul_ui16s",(ScicosF) matmul_ui16s},
+{"matmul_ui16n",(ScicosF) matmul_ui16n},
+{"matmul_ui16e",(ScicosF) matmul_ui16e},
+{"matmul_m",(ScicosF) matmul_m},
+{"matmul_i8s",(ScicosF) matmul_i8s},
+{"matmul_i8n",(ScicosF) matmul_i8n},
+{"matmul_i8e",(ScicosF) matmul_i8e},
+{"matmul_i32s",(ScicosF) matmul_i32s},
+{"matmul_i32n",(ScicosF) matmul_i32n},
+{"matmul_i32e",(ScicosF) matmul_i32e},
+{"matmul_i16s",(ScicosF) matmul_i16s},
+{"matmul_i16n",(ScicosF) matmul_i16n},
+{"matmul_i16e",(ScicosF) matmul_i16e},
+{"matmul2_s",(ScicosF) matmul2_s},
+{"matmul2_m",(ScicosF) matmul2_m},
+{"matmul2_e",(ScicosF) matmul2_e},
+{"mathermit_m",(ScicosF) mathermit_m},
+{"matbyscal_s",(ScicosF) matbyscal_s},
+{"matbyscal_e",(ScicosF) matbyscal_e},
+{"matbyscal",(ScicosF) matbyscal},
+{"mat_vpv",(ScicosF) mat_vpv},
+{"mat_vps",(ScicosF) mat_vps},
+{"mat_svd",(ScicosF) mat_svd},
+{"mat_suml",(ScicosF) mat_suml},
+{"mat_sumc",(ScicosF) mat_sumc},
+{"mat_sum",(ScicosF) mat_sum},
+{"mat_sqrt",(ScicosF) mat_sqrt},
+{"mat_sing",(ScicosF) mat_sing},
+{"mat_reshape",(ScicosF) mat_reshape},
+{"mat_pinv",(ScicosF) mat_pinv},
+{"mat_lu",(ScicosF) mat_lu},
+{"mat_inv",(ScicosF) mat_inv},
+{"mat_expm",(ScicosF) mat_expm},
+{"mat_div",(ScicosF) mat_div},
+{"mat_diag",(ScicosF) mat_diag},
+{"mat_det",(ScicosF) mat_det},
+{"mat_catv",(ScicosF) mat_catv},
+{"mat_cath",(ScicosF) mat_cath},
+{"mat_bksl",(ScicosF) mat_bksl},
+{"m_frequ",(ScicosF) m_frequ},
+{"lookup_c",(ScicosF) lookup_c},
+{"lookup2d",(ScicosF) lookup2d},
+{"logicalop_ui8",(ScicosF) logicalop_ui8},
+{"logicalop_ui32",(ScicosF) logicalop_ui32},
+{"logicalop_ui16",(ScicosF) logicalop_ui16},
+{"logicalop_m",(ScicosF) logicalop_m},
+{"logicalop_i8",(ScicosF) logicalop_i8},
+{"logicalop_i32",(ScicosF) logicalop_i32},
+{"logicalop_i16",(ScicosF) logicalop_i16},
+{"logicalop",(ScicosF) logicalop},
+{"logic",(ScicosF) logic},
+{"invblk4",(ScicosF) invblk4},
+{"integralz_func",(ScicosF) integralz_func},
+{"integral_func",(ScicosF) integral_func},
+{"hystheresis",(ScicosF) hystheresis},
+{"gainblk_ui8s",(ScicosF) gainblk_ui8s},
+{"gainblk_ui8n",(ScicosF) gainblk_ui8n},
+{"gainblk_ui8e",(ScicosF) gainblk_ui8e},
+{"gainblk_ui32s",(ScicosF) gainblk_ui32s},
+{"gainblk_ui32n",(ScicosF) gainblk_ui32n},
+{"gainblk_ui32e",(ScicosF) gainblk_ui32e},
+{"gainblk_ui16s",(ScicosF) gainblk_ui16s},
+{"gainblk_ui16n",(ScicosF) gainblk_ui16n},
+{"gainblk_ui16e",(ScicosF) gainblk_ui16e},
+{"gainblk_i8s",(ScicosF) gainblk_i8s},
+{"gainblk_i8n",(ScicosF) gainblk_i8n},
+{"gainblk_i8e",(ScicosF) gainblk_i8e},
+{"gainblk_i32s",(ScicosF) gainblk_i32s},
+{"gainblk_i32n",(ScicosF) gainblk_i32n},
+{"gainblk_i32e",(ScicosF) gainblk_i32e},
+{"gainblk_i16s",(ScicosF) gainblk_i16s},
+{"gainblk_i16n",(ScicosF) gainblk_i16n},
+{"gainblk_i16e",(ScicosF) gainblk_i16e},
+{"gainblk",(ScicosF) gainblk},
+{"gain",(ScicosF) gain},
+{"fromws_c",(ScicosF) fromws_c},
+{"foriterator",(ScicosF) foriterator},
+{"exttriuz",(ScicosF) exttriuz},
+{"exttriu",(ScicosF) exttriu},
+{"exttrilz",(ScicosF) exttrilz},
+{"exttril",(ScicosF) exttril},
+{"extractz",(ScicosF) extractz},
+{"extractor",(ScicosF) extractor},
+{"extract_bit_u8_UH1",(ScicosF) extract_bit_u8_UH1},
+{"extract_bit_u8_RB1",(ScicosF) extract_bit_u8_RB1},
+{"extract_bit_u8_MSB1",(ScicosF) extract_bit_u8_MSB1},
+{"extract_bit_u32_UH1",(ScicosF) extract_bit_u32_UH1},
+{"extract_bit_u32_RB1",(ScicosF) extract_bit_u32_RB1},
+{"extract_bit_u32_MSB1",(ScicosF) extract_bit_u32_MSB1},
+{"extract_bit_u16_UH1",(ScicosF) extract_bit_u16_UH1},
+{"extract_bit_u16_RB1",(ScicosF) extract_bit_u16_RB1},
+{"extract_bit_u16_MSB1",(ScicosF) extract_bit_u16_MSB1},
+{"extract_bit_8_UH1",(ScicosF) extract_bit_8_UH1},
+{"extract_bit_8_UH0",(ScicosF) extract_bit_8_UH0},
+{"extract_bit_8_RB1",(ScicosF) extract_bit_8_RB1},
+{"extract_bit_8_RB0",(ScicosF) extract_bit_8_RB0},
+{"extract_bit_8_MSB1",(ScicosF) extract_bit_8_MSB1},
+{"extract_bit_8_MSB0",(ScicosF) extract_bit_8_MSB0},
+{"extract_bit_8_LSB",(ScicosF) extract_bit_8_LSB},
+{"extract_bit_8_LH",(ScicosF) extract_bit_8_LH},
+{"extract_bit_32_UH1",(ScicosF) extract_bit_32_UH1},
+{"extract_bit_32_UH0",(ScicosF) extract_bit_32_UH0},
+{"extract_bit_32_RB1",(ScicosF) extract_bit_32_RB1},
+{"extract_bit_32_RB0",(ScicosF) extract_bit_32_RB0},
+{"extract_bit_32_MSB1",(ScicosF) extract_bit_32_MSB1},
+{"extract_bit_32_MSB0",(ScicosF) extract_bit_32_MSB0},
+{"extract_bit_32_LSB",(ScicosF) extract_bit_32_LSB},
+{"extract_bit_32_LH",(ScicosF) extract_bit_32_LH},
+{"extract_bit_16_UH1",(ScicosF) extract_bit_16_UH1},
+{"extract_bit_16_UH0",(ScicosF) extract_bit_16_UH0},
+{"extract_bit_16_RB1",(ScicosF) extract_bit_16_RB1},
+{"extract_bit_16_RB0",(ScicosF) extract_bit_16_RB0},
+{"extract_bit_16_MSB1",(ScicosF) extract_bit_16_MSB1},
+{"extract_bit_16_MSB0",(ScicosF) extract_bit_16_MSB0},
+{"extract_bit_16_LSB",(ScicosF) extract_bit_16_LSB},
+{"extract_bit_16_LH",(ScicosF) extract_bit_16_LH},
+{"extract",(ScicosF) extract},
+{"extdiagz",(ScicosF) extdiagz},
+{"extdiag",(ScicosF) extdiag},
+{"expblk_m",(ScicosF) expblk_m},
+{"evtvardly",(ScicosF) evtvardly},
+{"evtdly4",(ScicosF) evtdly4},
+{"evaluate_expr",(ScicosF) evaluate_expr},
+{"edgetrig",(ScicosF) edgetrig},
+{"dsslti4",(ScicosF) dsslti4},
+{"dollar4_m",(ScicosF) dollar4_m},
+{"dollar4",(ScicosF) dollar4},
+{"dmmul1",(ScicosF) dmmul1},
+{"dmmul",(ScicosF) dmmul},
+{"diffblk_c",(ScicosF) diffblk_c},
+{"deriv",(ScicosF) deriv},
+{"delay4_ui8",(ScicosF) delay4_ui8},
+{"delay4_ui32",(ScicosF) delay4_ui32},
+{"delay4_ui16",(ScicosF) delay4_ui16},
+{"delay4_i8",(ScicosF) delay4_i8},
+{"delay4_i32",(ScicosF) delay4_i32},
+{"delay4_i16",(ScicosF) delay4_i16},
+{"delay4",(ScicosF) delay4},
+{"deadband",(ScicosF) deadband},
+{"dband",(ScicosF) dband},
+{"curve_c",(ScicosF) curve_c},
+{"cumsumz_r",(ScicosF) cumsumz_r},
+{"cumsumz_m",(ScicosF) cumsumz_m},
+{"cumsumz_c",(ScicosF) cumsumz_c},
+{"cumsum_r",(ScicosF) cumsum_r},
+{"cumsum_m",(ScicosF) cumsum_m},
+{"cumsum_c",(ScicosF) cumsum_c},
+{"cstblk4_m",(ScicosF) cstblk4_m},
+{"cstblk4",(ScicosF) cstblk4},
+{"csslti4",(ScicosF) csslti4},
+{"cscopxy3d",(ScicosF) cscopxy3d},
+{"cscopxy",(ScicosF) cscopxy},
+{"cscope",(ScicosF) cscope},
+{"counter",(ScicosF) counter},
+{"cosh_blk",(ScicosF) cosh_blk},
+{"cosblk",(ScicosF) cosblk},
+{"cos_blk",(ScicosF) cos_blk},
+{"convert",(ScicosF) convert},
+{"constraint_c",(ScicosF) constraint_c},
+{"cmscope",(ScicosF) cmscope},
+{"cmatview",(ScicosF) cmatview},
+{"cmat3d",(ScicosF) cmat3d},
+{"cfscope",(ScicosF) cfscope},
+{"cevscpe",(ScicosF) cevscpe},
+{"cdummy",(ScicosF) cdummy},
+{"canimxy3d",(ScicosF) canimxy3d},
+{"canimxy",(ScicosF) canimxy},
+{"bouncexy",(ScicosF) bouncexy},
+{"bounce_ball",(ScicosF) bounce_ball},
+{"bit_set_8",(ScicosF) bit_set_8},
+{"bit_set_32",(ScicosF) bit_set_32},
+{"bit_set_16",(ScicosF) bit_set_16},
+{"bit_clear_8",(ScicosF) bit_clear_8},
+{"bit_clear_32",(ScicosF) bit_clear_32},
+{"bit_clear_16",(ScicosF) bit_clear_16},
+{"bidon",(ScicosF) bidon},
+{"backlash",(ScicosF) backlash},
+{"automat",(ScicosF) automat},
+{"atanh_blk",(ScicosF) atanh_blk},
+{"atan_blk",(ScicosF) atan_blk},
+{"assignment",(ScicosF) assignment},
+{"asinh_blk",(ScicosF) asinh_blk},
+{"asin_blk",(ScicosF) asin_blk},
+{"andlog",(ScicosF) andlog},
+{"acosh_blk",(ScicosF) acosh_blk},
+{"acos_blk",(ScicosF) acos_blk},
+{"absolute_value",(ScicosF) absolute_value},
+{"absblk",(ScicosF) absblk},
+{"affich2",(ScicosF) affich2},
+{(char *) 0, (ScicosF) 0}};
+#endif
+/****************************************/
+
diff --git a/modules/scicos_blocks/includes/dynlib_scicos_blocks.h b/modules/scicos_blocks/includes/dynlib_scicos_blocks.h
new file mode 100755
index 000000000..9a95b3067
--- /dev/null
+++ b/modules/scicos_blocks/includes/dynlib_scicos_blocks.h
@@ -0,0 +1,28 @@
+/*
+* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+* Copyright (C) DIGITEO - 2009 - Allan CORNET
+*
+* This file must be used under the terms of the CeCILL.
+* This source file is licensed as described in the file COPYING, which
+* you should have received as part of this distribution.  The terms
+* are also available at
+* http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
+*
+*/
+
+/*--------------------------------------------------------------------------*/
+#ifndef __DYNLIB_SCICOS_BLOCKS_H__
+#define __DYNLIB_SCICOS_BLOCKS_H__
+
+#ifdef _MSC_VER
+#ifdef SCICOS_BLOCKS_EXPORTS
+#define SCICOS_BLOCKS_IMPEXP __declspec(dllexport)
+#else
+#define SCICOS_BLOCKS_IMPEXP __declspec(dllimport)
+#endif
+#else
+#define SCICOS_BLOCKS_IMPEXP
+#endif
+
+#endif /* __DYNLIB_SCICOS_BLOCKS_H__ */
+/*--------------------------------------------------------------------------*/
diff --git a/modules/scicos_blocks/includes/scicos_block.h b/modules/scicos_blocks/includes/scicos_block.h
new file mode 100755
index 000000000..d2ce92d3d
--- /dev/null
+++ b/modules/scicos_blocks/includes/scicos_block.h
@@ -0,0 +1,99 @@
+/*  Scicos
+*
+*  Copyright (C) INRIA - METALAU Project <scicos@inria.fr>
+*
+* 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.
+*
+* This program 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 this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*
+* See the file ./license.txt
+*/
+
+#ifndef __SCICOS_BLOCK_H__
+#define __SCICOS_BLOCK_H__
+
+#include <stdlib.h> /* min max */
+
+#ifndef NULL
+#define NULL 0
+#endif
+typedef void (*voidg)();
+
+typedef struct
+{
+    int nevprt;
+    voidg funpt ;
+    int type;
+    int scsptr;
+    int nz;
+    double *z;
+    int noz;
+    int *ozsz;
+    int *oztyp;
+    void **ozptr;
+    int nx;
+    double *x;
+    double *xd;
+    double *res;
+    int *xprop;
+    int nin;
+    int *insz;
+    double **inptr;
+    int nout;
+    int *outsz;
+    double **outptr;
+    int nevout;
+    double *evout;
+    int nrpar;
+    double *rpar;
+    int nipar;
+    int *ipar;
+    int nopar;
+    int *oparsz;
+    int *opartyp;
+    void **oparptr;
+    int ng;
+    double *g;
+    int ztyp;
+    int *jroot;
+    char *label;
+    void **work;
+    int nmode;
+    int *mode;
+    char *uid;
+} scicos_block;
+
+
+void do_cold_restart();
+int get_phase_simulation();
+double get_scicos_time();
+int get_block_number();
+void set_block_error(int);
+void set_pointer_xproperty(int* pointer);
+// double Get_Jacobian_cj(void);
+// double Get_Jacobian_ci(void);
+double Get_Jacobian_parameter(void);
+double Get_Scicos_SQUR(void);
+void Set_Jacobian_flag(int flag);
+
+int Convert_number (char *, double *);
+void homotopy(double *);
+int hfjac_(double *, double *, int *);
+int rhojac_(double *, double *, double *, double *, int *, double *, int *);
+int rho_( double *, double *, double *, double *, double *, int *);
+int fx_( double *, double *);
+int read_xml_initial_states(int nvar, const char * xmlfile, char **ids, double *svars);
+int write_xml_states(int, const char *, char **, double *);
+
+#endif /* __SCICOS_BLOCK_H__ */
+
diff --git a/modules/scicos_blocks/includes/scicos_block4.h b/modules/scicos_blocks/includes/scicos_block4.h
new file mode 100755
index 000000000..5ab0b017d
--- /dev/null
+++ b/modules/scicos_blocks/includes/scicos_block4.h
@@ -0,0 +1,584 @@
+/*  Scicos
+*
+*  Copyright (C) INRIA - METALAU Project <scicos@inria.fr>
+*
+* 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.
+*
+* This program 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 this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*
+* See the file ./license.txt
+*/
+
+#ifndef __SCICOS_BLOCK4_H__
+#define __SCICOS_BLOCK4_H__
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#include <math.h>
+#include <assert.h>
+#include <stdlib.h>
+
+#ifdef _MSC_VER
+typedef void (*voidg) ();
+#else
+typedef void (*voidg) (void);
+#endif
+
+/* scicos_block structure definition
+* WARNING: take care that this sructure is
+* not the same as the one in scicos_block.h
+* i.e same name but inptr and outptr are void **
+*/
+typedef struct
+{
+    int nevprt;
+    voidg funpt;
+    int type;
+    int scsptr;
+    int nz;
+    double *z;
+    int noz;
+    int *ozsz;
+    int *oztyp;
+    void **ozptr;
+    int nx;
+    double *x;
+    double *xd;
+    double *res;
+    int *xprop;
+    int nin;
+    int *insz;
+    void **inptr;
+    int nout;
+    int *outsz;
+    void **outptr;
+    int nevout;
+    double *evout;
+    int nrpar;
+    double *rpar;
+    int nipar;
+    int *ipar;
+    int nopar;
+    int *oparsz;
+    int *opartyp;
+    void **oparptr;
+    int ng;
+    double *g;
+    int ztyp;
+    int *jroot;
+    char *label;
+    void **work;
+    int nmode;
+    int *mode;
+    char *uid;
+} scicos_block;
+
+/** define scicos flag number */
+typedef enum
+{
+    /* Should not be used directly, set through the API. */
+    CosError = -5,
+
+    /* Valid simulation states */
+    DerivativeState = 0,
+    OutputUpdate = 1,
+    StateUpdate = 2,
+    OutputEventTiming = 3,
+    Initialization = 4,
+    Ending = 5,
+    ReInitialization = 6,
+    ContinousPropertiesUpdate = 7,
+    ZeroCrossing = 9,
+    Jacobian = 10
+} scicos_flag;
+
+/* utility function for block declaration */
+int get_block_error(void);
+int *get_pointer_xproperty(void);
+int get_npointer_xproperty(void);
+double Get_Jacobian_cj(void);
+double Get_Jacobian_ci(void);
+double Get_Scicos_SQUR(void);
+void Set_Jacobian_flag(int flag);
+
+int Convert_number(char *, double *);
+void homotopy(double *);
+int hfjac_(double *, double *, int *);
+int rhojac_(double *, double *, double *, double *, int *, double *, int *);
+int rho_(double *, double *, double *, double *, double *, int *);
+int fx_(double *, double *);
+int read_xml_initial_states(int nvar, const char *xmlfile, char **ids, double *svars);
+int write_xml_states(int, const char *, char **, double *);
+
+/** Define scicos simulator data type number (_N) */
+typedef enum
+{
+    SCSREAL_N = 10,
+    SCSCOMPLEX_N = 11,
+    SCSINT_N = 80,
+    SCSINT8_N = 81,
+    SCSINT16_N = 82,
+    SCSINT32_N = 84,
+    SCSUINT_N = 800,
+    SCSUINT8_N = 811,
+    SCSUINT16_N = 812,
+    SCSUINT32_N = 814,
+    SCSUNKNOW_N = -1
+} scicos_datatype_number;
+
+/* Define scicos simulator data type C operators (_COP) */
+#define SCSREAL_COP double
+#define SCSCOMPLEX_COP double
+#define SCSINT_COP int
+#define SCSINT8_COP char
+#define SCSINT16_COP short
+#define SCSINT32_COP int
+#define SCSUINT_COP unsigned int
+#define SCSUINT8_COP unsigned char
+#define SCSUINT16_COP unsigned short
+#define SCSUINT32_COP unsigned int
+#define SCSUNKNOW_COP double
+
+/** \name Getters
+ *  These macros should be used to ease programming and debugging of new blocks.
+ */
+///@{
+
+/**
+\brief Get number of regular input port.
+*/
+#define GetNin(blk) (blk->nin)
+
+/**
+\brief Get regular input port pointer of port number x.
+*/
+#define GetInPortPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), blk->inptr[(x)-1])
+
+/**
+\brief Get number of regular output port.
+*/
+#define GetNout(blk) (blk->nout)
+
+/**
+\brief Get regular output port pointer of port number x.
+*/
+#define GetOutPortPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), blk->outptr[x-1])
+
+/**
+\brief Get number of rows (first dimension) of regular input port number x.
+*/
+#define GetInPortRows(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), blk->insz[x-1])
+
+/**
+\brief Get number of columns (second dimension) of regular input port number x.
+*/
+#define GetInPortCols(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), blk->insz[blk->nin+(x-1)])
+
+/**
+\brief Get regular input port size number x.
+*   GetInPortSize(blk,x,1) : get first dimension of input port number x
+*   GetInPortSize(blk,x,2) : get second dimension of input port number x
+*/
+#define GetInPortSize(blk,x,y) (assert((x)>0), assert((x)<=(blk->nin)), \
+	assert((y)>0), assert((y)<=2), blk->insz[(y-1)*blk->nin+(x-1)])
+
+/**
+\brief Get type of regular input port number x.
+*/
+#define GetInType(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), \
+	blk->insz[2*(blk->nin)+(x-1)])
+
+/**
+\brief Get number of rows (first dimension) of regular output port number x.
+*/
+#define GetOutPortRows(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), blk->outsz[x-1])
+
+/**
+\brief Get number of columns (second dimension) of regular output port number x.
+*/
+#define GetOutPortCols(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), blk->outsz[blk->nout+(x-1)])
+
+/**
+\brief Get regular output port size number x.
+*   GetOutPortSize(blk,x,1) : get first dimension of output port number x
+*   GetOutPortSize(blk,x,2) : get second dimension of output port number x
+*/
+#define GetOutPortSize(blk,x,y) (assert((x)>0), assert((x)<=(blk->nout)), \
+    assert((y)>0), assert((y)<=2), blk->outsz[(y-1)*blk->nout+(x-1)])
+
+/**
+\brief Get type of regular output port number x.
+*/
+#define GetOutType(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), \
+	blk->outsz[2*(blk->nout)+(x-1)])
+
+/**
+\brief Get pointer of real part of regular input port number x.
+*/
+#define GetRealInPortPtrs(blk,x) (SCSREAL_COP *) GetInPortPtrs(blk,x)
+
+/**
+\brief Get pointer of imaginary part of regular input port number x.
+*/
+#define GetImagInPortPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), \
+	(SCSREAL_COP *) ((SCSREAL_COP *)blk->inptr[x-1]+ \
+	((blk->insz[(x-1)])*(blk->insz[blk->nin+(x-1)]))))
+
+/**
+\brief Get pointer of real part of regular output port number x.
+*/
+#define GetRealOutPortPtrs(blk,x) (SCSREAL_COP *) GetOutPortPtrs(blk,x)
+
+/**
+\brief Get pointer of imaginary part of regular output port number x.
+*/
+#define GetImagOutPortPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), \
+	(SCSREAL_COP *) ((SCSREAL_COP *)blk->outptr[x-1]+ \
+	((blk->outsz[(x-1)])*(blk->outsz[blk->nout+(x-1)]))))
+
+/**
+\brief Get pointer of int8 typed regular input port number x.
+*/
+#define Getint8InPortPtrs(blk,x) (SCSINT8_COP *) GetInPortPtrs(blk,x)
+
+/**
+\brief Get pointer of int16 typed regular input port number x.
+*/
+#define Getint16InPortPtrs(blk,x) (SCSINT16_COP *) GetInPortPtrs(blk,x)
+
+/**
+\brief Get pointer of int32 typed regular input port number x.
+*/
+#define Getint32InPortPtrs(blk,x) (SCSINT32_COP *) GetInPortPtrs(blk,x)
+
+/**
+\brief Get pointer of uint8 typed regular input port number x.
+*/
+#define Getuint8InPortPtrs(blk,x) (SCSUINT8_COP *) GetInPortPtrs(blk,x)
+
+/**
+\brief Get pointer of uint16 typed regular input port number x.
+*/
+#define Getuint16InPortPtrs(blk,x) (SCSUINT16_COP *) GetInPortPtrs(blk,x)
+
+/**
+\brief Get pointer of uint32 typed regular input port number x.
+*/
+#define Getuint32InPortPtrs(blk,x) (SCSUINT32_COP *) GetInPortPtrs(blk,x)
+
+/**
+\brief Get pointer of int8 typed regular output port number x.
+*/
+#define Getint8OutPortPtrs(blk,x) (SCSINT8_COP *) GetOutPortPtrs(blk,x)
+
+/**
+\brief Get pointer of int16 typed regular output port number x.
+*/
+#define Getint16OutPortPtrs(blk,x) (SCSINT16_COP *) GetOutPortPtrs(blk,x)
+
+/**
+\brief Get pointer of int32 typed regular output port number x.
+*/
+#define Getint32OutPortPtrs(blk,x) (SCSINT32_COP *) GetOutPortPtrs(blk,x)
+
+/**
+\brief Get pointer of uint8 typed regular output port number x.
+*/
+#define Getuint8OutPortPtrs(blk,x) (SCSUINT8_COP *) GetOutPortPtrs(blk,x)
+
+/**
+\brief Get pointer of uint16 typed regular output port number x.
+*/
+#define Getuint16OutPortPtrs(blk,x) (SCSUINT16_COP *) GetOutPortPtrs(blk,x)
+
+/**
+\brief Get pointer of uint32 typed regular output port number x.
+*/
+#define Getuint32OutPortPtrs(blk,x) (SCSUINT32_COP *) GetOutPortPtrs(blk,x)
+
+/**
+\brief Get number of integer parameters.
+*/
+#define GetNipar(blk) (blk->nipar)
+
+/**
+\brief Get pointer of the integer parameters register
+*/
+#define GetIparPtrs(blk) (blk->ipar)
+
+/**
+\brief Get number of real parameters.
+*/
+#define GetNrpar(blk) (blk->nrpar)
+
+/**
+\brief Get pointer of the real parameters register.
+*/
+#define GetRparPtrs(blk) (blk->rpar)
+
+/**
+\brief Get the pointer of the Work array.
+*/
+#define GetWorkPtrs(blk) (*(blk->work))
+
+/**
+\brief Get number of continuous state.
+*/
+#define GetNstate(blk) (blk->nx)
+
+/**
+\brief Get pointer of the continuous state register.
+*/
+#define GetState(blk) (blk->x)
+
+/**
+\brief Get pointer of the derivative continuous state register.
+*/
+#define GetDerState(blk) (blk->xd)
+
+/**
+\brief Get pointer of the residual continuous state register.
+*/
+#define GetResState(blk) (blk->res)
+
+/**
+\brief Get pointer of continuous state properties register.
+*/
+#define GetXpropPtrs(blk) (blk->xprop)
+
+/**
+\brief Get number of discrete state.
+*/
+#define GetNdstate(blk) (blk->nz)
+
+/**
+\brief Get pointer of the discrete state register.
+*/
+#define GetDstate(blk) (blk->z)
+
+/**
+\brief Get the input event number.
+*/
+#define GetNevIn(blk) (blk->nevprt)
+
+/**
+\brief Get number of event output port.
+*/
+#define GetNevOut(blk) (blk->nevout)
+
+/**
+\brief Get pointer of event output register.
+*/
+#define GetNevOutPtrs(blk) (blk->evout)
+
+/**
+\brief Get number of object parameters.
+*/
+#define GetNopar(blk) (blk->nopar)
+
+/**
+\brief Get type of object parameters number x.
+*/
+#define GetOparType(blk,x) (assert(x>0), assert(x<=blk->nopar), blk->opartyp[x-1])
+
+/**
+\brief Get size of object parameters number x.
+*   GetOparSize(blk,x,1) : get first dimension of opar
+*   GetOparSize(blk,x,2) : get second dimension of opar
+*/
+#define GetOparSize(blk,x,y) (assert((x)>0), assert(x<=blk->nopar), \
+    assert((y)>0), assert((y)<=2), blk->oparsz[(y-1)*blk->nopar+(x-1)])
+
+/**
+\brief Get pointer of object parameters number x.
+*/
+#define GetOparPtrs(blk,x) (assert((x)>0), assert((x)<=(blk)->nopar), (blk)->oparptr[(x)-1])
+
+/**
+\brief Get pointer of real object parameters number x.
+*/
+#define GetRealOparPtrs(blk,x) (SCSREAL_COP *) GetOparPtrs(blk,x)
+
+/**
+\brief Get pointer of imaginary part of object parameters number x.
+*/
+#define GetImagOparPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nopar)), \
+	(SCSREAL_COP *) ((SCSREAL_COP *)blk->oparptr[x-1]+ \
+	((blk->oparsz[x-1])*(blk->oparsz[blk->nopar+(x-1)])))
+
+/**
+\brief Get pointer of int8 typed object parameters number x.
+*/
+#define Getint8OparPtrs(blk,x) (SCSINT8_COP *) GetOparPtrs(blk,x)
+
+/**
+\brief Get pointer of int16 typed object parameters number x.
+*/
+#define Getint16OparPtrs(blk,x) (SCSINT16_COP *) GetOparPtrs(blk,x)
+
+/**
+\brief Get pointer of int32 typed object parameters number x.
+*/
+#define Getint32OparPtrs(blk,x) (SCSINT32_COP *) GetOparPtrs(blk,x)
+
+/**
+\brief Get pointer of uint8 typed object parameters number x.
+*/
+#define Getuint8OparPtrs(blk,x) (SCSUINT8_COP *) GetOparPtrs(blk,x)
+
+/**
+\brief Get pointer of uint16 typed object parameters number x.
+*/
+#define Getuint16OparPtrs(blk,x) (SCSUINT16_COP *) GetOparPtrs(blk,x)
+
+/**
+\brief Get pointer of uint32 typed object parameters number x.
+*/
+#define Getuint32OparPtrs(blk,x) (SCSUINT32_COP *) GetOparPtrs(blk,x)
+
+/**
+\brief Get number of object state.
+*/
+#define GetNoz(blk) (blk->noz)
+
+/**
+\brief Get type of object state number x.
+*/
+#define GetOzType(blk,x) (assert((x)>0), assert((x)<=(blk)->noz), (blk)->oztyp[(x)-1])
+
+/**
+\brief Get size of object state number x.
+*   GetOzSize(blk,x,1) : get first dimension of oz
+*   GetOzSize(blk,x,2) : get second dimension of oz
+*/
+#define GetOzSize(blk,x,y) (assert((x)>0), assert((x)<=(blk)->noz), \
+	assert((y)>0), assert((y)<=2), (blk)->ozsz[((y)-1)*(blk)->noz+((x)-1)])
+
+/**
+\brief Get pointer of object state number x.
+*/
+#define GetOzPtrs(blk,x) (assert((x)>0), assert((x)<=(blk)->noz), (blk)->ozptr[(x)-1])
+
+/**
+\brief Get pointer of real object state number x.
+*/
+#define GetRealOzPtrs(blk,x) (SCSREAL_COP *) GetOzPtrs(blk,x)
+
+/**
+\brief Get pointer of imaginary part of object state number x.
+*/
+#define GetImagOzPtrs(blk,x) (assert((x)>0), assert((x)<=(blk)->noz), \
+	(SCSREAL_COP *) ((SCSREAL_COP *)blk->ozptr[x-1]+ \
+	((blk->ozsz[x-1])*(blk->ozsz[blk->noz+(x-1)])))
+
+/**
+\brief Get pointer of int8 typed object state number x.
+*/
+#define Getint8OzPtrs(blk,x) (SCSINT8_COP *) GetOzPtrs(blk,x)
+
+/**
+\brief Get pointer of int16 typed object state number x.
+*/
+#define Getint16OzPtrs(blk,x) (SCSINT16_COP *) GetOzPtrs(blk,x)
+
+/**
+\brief Get pointer of int32 typed object state number x.
+*/
+#define Getint32OzPtrs(blk,x) (SCSINT32_COP *) GetOzPtrs(blk,x)
+
+/**
+\brief Get pointer of uint8 typed object state number x.
+*/
+#define Getuint8OzPtrs(blk,x) (SCSUINT8_COP *) GetOzPtrs(blk,x)
+
+/**
+\brief Get pointer of uint16 typed object state number x.
+*/
+#define Getuint16OzPtrs(blk,x) (SCSUINT16_COP *) GetOzPtrs(blk,x)
+
+/**
+\brief Get pointer of uint32 typed object state number x.
+*/
+#define Getuint32OzPtrs(blk,x) (SCSUINT32_COP *) GetOzPtrs(blk,x)
+
+/**
+\brief Get the sizeof of the object state number x.
+*/
+#define GetSizeOfOz(blk,x)    ((GetOzType(blk,x)==SCSREAL_N) ? (sizeof(SCSREAL_COP)) : \
+	(GetOzType(blk,x)==SCSCOMPLEX_N) ? (2*sizeof(SCSCOMPLEX_COP)) : \
+	((GetOzType(blk,x)==SCSINT8_N)|(GetOzType(blk,x)==SCSUINT8_N)) ? (sizeof(SCSINT8_COP)) : \
+	((GetOzType(blk,x)==SCSINT16_N)|(GetOzType(blk,x)==SCSUINT16_N)) ? (sizeof(SCSINT16_COP)) : \
+	((GetOzType(blk,x)==SCSINT32_N)|(GetOzType(blk,x)==SCSUINT32_N)) ? (sizeof(SCSINT32_COP)) : 0)
+
+/**
+\brief Get the sizeof of the object parameters number x.
+*/
+#define GetSizeOfOpar(blk,x)  ((GetOparType(blk,x)==SCSREAL_N) ? (sizeof(SCSREAL_COP)) : \
+	(GetOparType(blk,x)==SCSCOMPLEX_N) ? (2*sizeof(SCSCOMPLEX_COP)) : \
+	((GetOparType(blk,x)==SCSINT8_N)|(GetOparType(blk,x)==SCSUINT8_N)) ? (sizeof(SCSINT8_COP)) : \
+	((GetOparType(blk,x)==SCSINT16_N)|(GetOparType(blk,x)==SCSUINT16_N)) ? (sizeof(SCSINT16_COP)) : \
+	((GetOparType(blk,x)==SCSINT32_N)|(GetOparType(blk,x)==SCSUINT32_N)) ? (sizeof(SCSINT32_COP)) : 0)
+
+/**
+\brief Get the sizeof of the regular output port number x.
+*/
+#define GetSizeOfOut(blk,x)  ((GetOutType(blk,x)==SCSREAL_N) ? (sizeof(SCSREAL_COP)) : \
+	(GetOutType(blk,x)==SCSCOMPLEX_N) ? (2*sizeof(SCSCOMPLEX_COP)) : \
+	((GetOutType(blk,x)==SCSINT8_N)|(GetOutType(blk,x)==SCSUINT8_N)) ? (sizeof(SCSINT8_COP)) : \
+	((GetOutType(blk,x)==SCSINT16_N)|(GetOutType(blk,x)==SCSUINT16_N)) ? (sizeof(SCSINT16_COP)) : \
+	((GetOutType(blk,x)==SCSINT32_N)|(GetOutType(blk,x)==SCSUINT32_N)) ? (sizeof(SCSINT32_COP)) : 0)
+/**
+\brief Get the sizeof of the regular input port number x.
+*/
+#define GetSizeOfIn(blk,x)  ((GetInType(blk,x)==SCSREAL_N) ? (sizeof(SCSREAL_COP)) : \
+	(GetInType(blk,x)==SCSCOMPLEX_N) ? (2*sizeof(SCSCOMPLEX_COP)) : \
+	((GetInType(blk,x)==SCSINT8_N)|(GetInType(blk,x)==SCSUINT8_N)) ? (sizeof(SCSINT8_COP)) : \
+	((GetInType(blk,x)==SCSINT16_N)|(GetInType(blk,x)==SCSUINT16_N)) ? (sizeof(SCSINT16_COP)) : \
+	((GetInType(blk,x)==SCSINT32_N)|(GetInType(blk,x)==SCSUINT32_N)) ? (sizeof(SCSINT32_COP)) : 0)
+
+/**
+\brief Get number of zero crossing surface.
+*/
+#define GetNg(blk) (blk->ng)
+
+/**
+\brief Get pointer of the zero crossing register.
+*/
+#define GetGPtrs(blk) (blk->g)
+
+/**
+\brief Get pointer of the direction of the zero crossing register.
+*/
+#define GetJrootPtrs(blk) (blk->jroot)
+
+/**
+\brief Get number of modes.
+*/
+#define GetNmode(blk) (blk->nmode)
+
+/**
+\brief Get pointer of the mode register.
+*/
+#define GetModePtrs(blk) (blk->mode)
+
+/**
+\brief Get pointer of the block label
+*/
+#define GetLabelPtrs(blk) (blk->label)
+
+///@}
+
+#endif /* __SCICOS_BLOCK_H__ */
+