fix warnings on Windows and add headers required in binary version
[scilab.git] / scilab / modules / scicos / sci_gateway / c / sci_scicosim.c
1 /*  Scicos
2 *
3 *  Copyright (C) INRIA - Allan CORNET
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 *
19 * See the file ./license.txt
20 */
21
22 /*--------------------------------------------------------------------------*/
23 #include <stdio.h>
24 #include "gw_scicos.h"
25 #include "stack-c.h"
26 #include "il_state.h"
27 #include "il_sim.h"
28 #include "Scierror.h"
29 #include "cvstr.h"
30 #include "scicos-def.h"
31 #include "scicos.h"
32 #include "import.h"
33 #include "localization.h"
34 #include "MALLOC.h"
35 /*--------------------------------------------------------------------------*/
36 /* intsicosimc scicosim interface routine.
37 *
38 * [state,t] = scicosim(state,tcur,tf,sim,str,tol)
39 *
40 * rhs 1 state : Tlist
41 *        - 1  : state(1)     : !xcs  x  z  oz iz  tevts  evtspt  pointi  outtb  !
42 *        - 2  : state.x      : column vector of real
43 *        - 3  : state.z      : column vector of real
44 *        - 4  : state.oz     : list of scilab object
45 *        - 5  : state.iz     : column vector of real (empty object with flag "finish")
46 *        - 6  : state.tevts  : column vector of real
47 *        - 7  : state.evtspt : column vector of real
48 *        - 8  : state.pointi : real scalar
49 *        - 9  : state.outtb  : list of scilab object
50 * rhs 2 tcur  : real scalar
51 * rhs 3 tf    : real scalar
52 * rhs 4 sim   : Tlist
53 *        - 1  : sim(1) : !scs    funs    xptr    zptr    ozptr   zcptr   inpptr
54 *                         outptr inplnk  outlnk  rpar    rpptr   ipar    ipptr
55 *                         opar   opptr   clkptr  ordptr  execlk  ordclk  cord
56 *                         oord   zord    critev  nb      ztyp    nblk    ndcblk
57 *                         subscr funtyp  iord    labels  modptr  !
58 *        - 2  : sim.funs   : list of strings and/or scilab function
59 *        - 3  : sim.xptr   : column vector of real
60 *        - 4  : sim.zptr   : column vector of real
61 *        - 5  : sim.ozptr  : column vector of real
62 *        - 6  : sim.zcptr  : column vector of real
63 *        - 7  : sim.inpptr : column vector of real
64 *        - 8  : sim.outptr : column vector of real
65 *        - 9  : sim.inplnk : column vector of real
66 *        - 10 : sim.outlnk : column vector of real
67 *        - 11 : sim.rpar   : column vector of real
68 *        - 12 : sim.rpptr  : column vector of real
69 *        - 13 : sim.ipar   : column vector of real
70 *        - 14 : sim.ipptr  : column vector of real
71 *        - 15 : sim.opar   : list of scilab object
72 *        - 16 : sim.opptr  : column vector of real
73 *        - 17 : sim.clkptr : column vector of real
74 *        - 18 : sim.ordptr : column vector of real
75 *        - 19 : sim.execlk : matrix of real
76 *        - 20 : sim.ordclk : matrix of real
77 *        - 21 : sim.cord   : matrix of real
78 *        - 22 : sim.oord   : matrix of real
79 *        - 23 : sim.zord   : column vector ? of real
80 *        - 24 : sim.critev : column vector of real
81 *        - 25 : sim.nb     : real scalar
82 *        - 26 : sim.ztyp   : column vector of real
83 *        - 27 : sim.nblk   : real scalar
84 *        - 28 : sim.ndcblk : real scalar
85 *        - 29 : sim.subscr : column vector of real
86 *        - 30 : sim.funtyp : column vector of real
87 *        - 31 : sim.iord   : column vector of real
88 *        - 32 : sim.labels : column vector of strings
89 *        - 33 : sim.modptr : column vector of real
90 *
91 * rhs 5 str   : string flag : 'start','run','finish','linear'
92 * rhs 6 tol   : real vector of size (7,1) minimum (4,1)
93 *               [atol rtol ttol [deltat realtimescale solver hmax]]'
94 *
95 * 16/03/06, A.Layec : Rewritten from original fortran
96 *                     source code intsscicos in intcos.f.
97 *
98 * 29/03/06, Alan    : Improvement in accordance to c_pass2
99 *                     (int32 parameters).
100 *
101 * 31/05/06, Alan    : Add global variable int *il_state_save
102 *                     and int *il_sim_save in intcscicos.h to store
103 *                     stack address of list %cpr.state and %cpr.sim
104 *                     (to use with get/setscicosvars).
105 *
106 * 14/06/06, Alan    : Save common intersci before calling scicos
107 *                     (to disable scilab crash with scifunc.f).
108 *
109 * 13/11/06, Alan    : Get back to double parameters for sim and state
110 *                     (for better compatibility with scilab-4.x families).
111 *                     Remove il_sim_save global variable.
112 *
113 * 15/12/06, Alan    : Warnings compilation removed.
114 *                     This can crash scilab/scicos.
115 *                     Please report.
116 *
117 * xx/02/07, Alan    : Add opar/odstate : scilab lists of arbitrary object
118 *                     parameters/states.
119 *
120 */
121 /*--------------------------------------------------------------------------*/
122 #define freeparam \
123         FREE(l_sim_iord);\
124         FREE(l_sim_funtyp);\
125         FREE(l_sim_subscr);\
126         FREE(l_sim_ndcblk);\
127         FREE(l_sim_nblk);\
128         FREE(l_sim_ztyp);\
129         FREE(l_sim_nb);\
130         FREE(l_sim_critev);\
131         FREE(l_sim_zord);\
132         FREE(l_sim_oord);\
133         FREE(l_sim_cord);\
134         FREE(l_sim_ordclk);\
135         FREE(l_sim_execlk);\
136         FREE(l_sim_ordptr);\
137         FREE(l_sim_clkptr);\
138         FREE(l_sim_rpptr);\
139         FREE(l_sim_ipar);\
140         FREE(l_sim_ipptr);\
141         FREE(l_sim_opptr);\
142         FREE(l_sim_outlnk);\
143         FREE(l_sim_inplnk);\
144         FREE(l_sim_outptr);\
145         FREE(l_sim_inpptr);\
146         FREE(l_sim_zcptr);\
147         FREE(l_sim_ozptr);\
148         FREE(l_sim_zptr);\
149         FREE(l_sim_xptr);\
150         FREE(l_sim_modptr);\
151         FREE(l_state_evtspt);\
152         FREE(l_pointi)
153 /*--------------------------------------------------------------------------*/
154 COSIM_struct C2F(cosim); /* declaration of cosim -valable partout- */
155 /*--------------------------------------------------------------------------*/
156 extern COSERR_struct coserr;    /* declaration of coserr -defined in scicos- */
157 extern int *listentry(int *header, int i); /* mexlib.h */
158 extern int C2F(funnum)(char *fname);
159 extern int C2F(namstr)();
160 /*--------------------------------------------------------------------------*/
161 /* variable defined in scicos.c */
162 extern CURBLK_struct C2F(curblk);
163 /*--------------------------------------------------------------------------*/
164 int sci_scicosim(char *fname,unsigned long fname_len)
165 {
166         /************************************
167         * variables and constants d?inition
168         ************************************/
169         static int id[nsiz];
170
171         /*declaration of static structure*/
172         static struct {int idb;} C2F(dbcos);   /*declaration of dbcos*/
173
174         typedef struct inter_s_
175         {
176                 int iwhere,nbrows,nbcols,itflag,ntypes,lad,ladc,lhsvar;
177         } intersci_state ;
178
179         typedef struct inter_l
180         {
181                 intersci_state *state ;
182                 int nbvars;
183         } intersci_list ;
184
185         intersci_list *loc = NULL;
186         intersci_state *new = NULL ;
187
188
189         /* declaration of outtb_elem */
190         outtb_el *outtb_elem = NULL;
191         static int nelem  = 0;
192
193         /*auxilary variables for dimension and address*/
194         static int m1 = 0;                  /*state*/
195         static int *il_state = NULL;
196         static int m1e2 = 0,n1e2 = 0;           /*state.x*/
197         static int *il_state_x = NULL;
198         static double *l_state_x = NULL;
199         static int m1e3 = 0,n1e3 = 0;           /*state.z*/
200         static int *il_state_z = NULL;
201         static double *l_state_z = NULL;
202         static int *il_state_oz = NULL;        /*state.oz*/
203         static int noz = 0;
204         static void **oz = NULL;
205         static int *ozsz = NULL;
206         static int *oztyp = NULL;
207         static int m1e5 = 0,n1e5 = 0;           /*state.iz*/
208         static int *il_state_iz = NULL;
209         static void **l_state_iz = NULL;
210         static int m1e6 = 0,n1e6 = 0;           /*state.tevts*/
211         static int *il_state_tevts = NULL;
212         static double *l_state_tevts = NULL;
213         static int m1e7 = 0,n1e7 = 0;           /*state.evtspt*/
214         static int *il_state_evtspt = NULL;
215         static int *l_state_evtspt = NULL;
216         static int m1e8 = 0,n1e8 = 0;           /*state.pointi*/
217         static int *il_pointi = NULL;
218         static int *l_pointi = NULL;
219         static int *il_state_outtb = NULL;     /*state.outtb*/
220         static int nlnk = 0;
221         static void **outtbptr = NULL;
222         static int *outtbsz = NULL;
223         static int *outtbtyp = NULL;
224
225         static int m2 = 0,n2 = 0;               /*tcur*/
226         static int *il_tcur = NULL;
227         static double *l_tcur = NULL;
228
229         static int m3 = 0,n3 = 0;               /*tf*/
230         static int *il_tf = NULL;
231         static double *l_tf = NULL;
232
233         static int m4 = 0,n4 = 0,l4 = 0,il4 = 0;        /*sim*/
234         static int *il_sim = NULL;
235         static int l4e2 = 0,il4e2 = 0;          /*sim.funs*/
236         static int *il_sim_fun = NULL;
237         static int nblk = 0;
238         static int m_xptr = 0,n_xptr = 0;       /*sim.xptr*/
239         static int *il_sim_xptr = NULL;
240         static int *l_sim_xptr = NULL;
241         static int m_zptr = 0,n_zptr = 0;       /*sim.zptr*/
242         static int *il_sim_zptr = NULL;
243         static int *l_sim_zptr = NULL;
244         static int m_ozptr = 0,n_ozptr = 0;     /*sim.ozptr*/
245         static int *il_sim_ozptr = NULL;
246         static int *l_sim_ozptr = NULL;
247
248         static int m_zcptr = 0,n_zcptr = 0;     /*sim.zcptr*/
249         static int *il_sim_zcptr = NULL;
250         static int *l_sim_zcptr = NULL;
251         static int m_inpptr = 0,n_inpptr = 0;   /*sim.inpptr*/
252         static int *il_sim_inpptr = NULL;
253         static int *l_sim_inpptr = NULL;
254         static int m_outptr = 0,n_outptr = 0;   /*sim.outptr*/
255         static int *il_sim_outptr = NULL;
256         static int *l_sim_outptr = NULL;
257         static int m_inplnk = 0,n_inplnk = 0;   /*sim.inplnk*/
258         static int *il_sim_inplnk = NULL;
259         static int *l_sim_inplnk = NULL;
260         static int m_outlnk = 0,n_outlnk = 0;   /*sim.outlnk*/
261         static int *il_sim_outlnk = NULL;
262         static int *l_sim_outlnk = NULL;
263         static int m_rpar = 0,n_rpar = 0;       /*sim.rpar*/
264         static int *il_sim_rpar = NULL;
265         static double *l_sim_rpar = NULL;
266         static int m_rpptr = 0,n_rpptr = 0;     /*sim.rpptr*/
267         static int *il_sim_rpptr = NULL;
268         static int *l_sim_rpptr = NULL;
269         static int m_ipar = 0,n_ipar = 0;       /*sim.ipar*/
270         static int *il_sim_ipar = NULL;
271         static int *l_sim_ipar = NULL;
272         static int m_ipptr = 0,n_ipptr = 0;     /*sim.ipptr*/
273         static int *il_sim_ipptr = NULL;
274         static int *l_sim_ipptr = NULL;
275         static int *il_sim_opar = NULL;        /*sim.opar*/
276         static int nopar = 0;
277         static void **opar = NULL;
278         static int *oparsz = NULL;
279         static int *opartyp = NULL;
280         static int m_opptr = 0,n_opptr = 0;     /*sim.opptr*/
281         static int *il_sim_opptr = NULL;
282         static int *l_sim_opptr = NULL;
283
284         static int m_clkptr = 0,n_clkptr = 0;   /*sim.clkptr*/
285         static int *il_sim_clkptr = NULL;
286         static int *l_sim_clkptr = NULL;
287         static int m_ordptr = 0,n_ordptr = 0;   /*sim.ordptr*/
288         static int *il_sim_ordptr = NULL;
289         static int *l_sim_ordptr = NULL;
290         static int m_execlk = 0,n_execlk = 0;   /*sim.execlk*/
291         static int *il_sim_execlk = NULL;
292         static int *l_sim_execlk = NULL;
293         static int m_ordclk = 0,n_ordclk = 0;   /*sim.ordclk*/
294         static int *il_sim_ordclk = NULL;
295         static int *l_sim_ordclk = NULL;
296         static int m_cord = 0,n_cord = 0;       /*sim.cord*/
297         static int *il_sim_cord = NULL;
298         static int *l_sim_cord = NULL;
299         static int m_oord = 0,n_oord = 0;       /*sim.oord*/
300         static int *il_sim_oord = NULL;
301         static int *l_sim_oord = NULL;
302         static int m_zord = 0,n_zord = 0;       /*sim.zord*/
303         static int *il_sim_zord = NULL;
304         static int *l_sim_zord = NULL;
305         static int m_critev = 0,n_critev = 0;   /*sim.critev*/
306         static int *il_sim_critev = NULL;
307         static int *l_sim_critev = NULL;
308         static int m_nb = 0,n_nb = 0;           /*sim.nb*/
309         static int *il_sim_nb = NULL;
310         static int *l_sim_nb = NULL;
311         static int m_ztyp = 0,n_ztyp = 0;       /*sim.ztyp*/
312         static int *il_sim_ztyp = NULL;
313         static int *l_sim_ztyp = NULL;
314         static int m_nblk = 0,n_nblk = 0;       /*sim.nblk*/
315         static int *il_sim_nblk = NULL;
316         static int *l_sim_nblk = NULL;
317         static int m_ndcblk = 0,n_ndcblk = 0;   /*sim.ndcblk*/
318         static int *il_sim_ndcblk = NULL;
319         static int *l_sim_ndcblk = NULL;
320         static int m_subscr = 0,n_subscr = 0;   /*sim.subscr*/
321         static int *il_sim_subscr = NULL;
322         static int *l_sim_subscr = NULL;
323         static int m_funtyp = 0,n_funtyp = 0;   /*sim.funtyp*/
324         static int *il_sim_funtyp = NULL;
325         static int *l_sim_funtyp = NULL;
326         static int m_iord = 0,n_iord = 0;       /*sim.iord*/
327         static int *il_sim_iord = NULL;
328         static int *l_sim_iord = NULL;
329         static int m_lab = 0,n_lab = 0;         /*sim.labels*/
330         static int *il_sim_lab = NULL;
331         static int *il_sim_labptr = NULL;
332         static int *l_sim_lab = NULL;
333         static int m_modptr = 0,n_modptr = 0;   /*sim.modptr*/
334         static int *il_sim_modptr = NULL;
335         static int *l_sim_modptr = NULL;
336
337         static int m5 = 0,n5 = 0;               /*str*/
338         static int *il_str = NULL;
339         static int *l_str = NULL;
340         static int flag;
341
342         static int m6 = 0,n6 = 0;               /*tol*/
343         static int *il_tol = NULL;
344         static double *l_tol = NULL;
345
346         /*auxilary variables*/
347         static double simpar[7];
348         static int solver = 0;
349         static int *lfunpt = NULL;     /*for function table*/
350         static int lf = 0,ilf = 0,ifun = 0; /*for function table*/
351         static int ierr = 0,istate = 0; /*error variable of scicos.c*/
352
353         /*local variable*/
354         int *subheader = NULL; /*pointer to get address of a subvariable in a list*/
355         int i = 0,j = 0,k = 0;        /*local counter variable*/
356         int sz_str = 0;     /*local variable to store size of string*/
357         int err_check = 0;  /*local variable for cross var. checking dimension*/
358
359         /*definition of min/max input/output argument*/
360         static int minlhs = 1, maxlhs = 2;
361         static int minrhs = 6, maxrhs = 6;
362
363         /*************************************
364         * Check number of inputs and outputs
365         *************************************/
366         CheckRhs(minrhs,maxrhs);
367         CheckLhs(minlhs,maxlhs);
368
369         /****************
370         * state (rhs 1)
371         ****************/
372         il_state = (int *) GetData(1);
373
374         /* make a copy of il_state in a global variabe */
375         set_il_state(il_state);
376
377         if(il_state[0]!=16) /*Check if state is a tlist*/
378         {
379                 Scierror(56,"%s : First argument must be a Tlist.\n",fname);
380                 C2F(iop).err=1;
381                 return 0;
382         }
383         m1 = il_state[1];
384
385         /*2 : state.x      */
386         il_state_x = (int *) (listentry(il_state,2));
387         l_state_x  = (double *) (il_state_x+4);
388         m1e2 = il_state_x[1];
389         n1e2 = il_state_x[2];
390
391         /*3 : state.z      */
392         il_state_z = (int *) (listentry(il_state,3));
393         l_state_z  = (double *) (il_state_z+4);
394         m1e3 = il_state_z[1];
395         n1e3 = il_state_z[2];
396
397         /*4 : state.oz     */
398         il_state_oz = (int *) (listentry(il_state,4));
399         if(il_state_oz[0]!=15) /*check if il_state_oz is a list*/
400         {
401                 Scierror(56, _("%s : oz element of state must be a list.\n"),fname);
402                 C2F(iop).err=4;
403                 return 0;
404         }
405         noz = il_state_oz[1];
406
407         /*5 : state.iz     */
408         il_state_iz = (int *) (listentry(il_state,5));
409         l_state_iz  = (void **) (il_state_iz+4);
410         m1e5 = il_state_iz[1];
411         n1e5 = il_state_iz[2];
412
413         /*6 : state.tevts  */
414         il_state_tevts = (int *) (listentry(il_state,6));
415         l_state_tevts  = (double *) (il_state_tevts+4);
416         m1e6 = il_state_tevts[1];
417         n1e6 = il_state_tevts[2];
418
419         /*7 : state.evtspt */
420         il_state_evtspt = (int *) (listentry(il_state,7));
421         m1e7 = il_state_evtspt[1];
422         n1e7 = il_state_evtspt[2];
423         if ((m1e7*n1e7)==0) l_state_evtspt=NULL;
424         else
425         {
426                 if ((l_state_evtspt=(int *) MALLOC((m1e7*n1e7)*sizeof(int))) ==NULL )
427                 {
428                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
429                         return 0;
430                 }
431                 else
432                 {
433                         for(i=0;i<(m1e7*n1e7);i++) l_state_evtspt[i]= (int) ((double *)(il_state_evtspt+4))[i];
434                 }
435         }
436
437         /*8 : state.pointi */
438         il_pointi = (int *) (listentry(il_state,8));
439         m1e8 = il_pointi[1];
440         n1e8 = il_pointi[2];
441         if ((l_pointi=(int *) MALLOC((m1e8*n1e8)*sizeof(int))) ==NULL )
442         {
443                 Scierror(999,_("%s: Memory allocation error.\n"),fname);
444                 FREE(l_state_evtspt);
445                 return 0;
446         }
447         else
448         {
449                 for(i=0;i<(m1e8*n1e8);i++) l_pointi[i]= (int) ((double *)(il_pointi+4))[i];
450         }
451
452         /*9 : state.outtb  */
453         il_state_outtb = (int *) (listentry(il_state,9));
454         if(il_state_outtb[0]!=15) /*check if il_state_outtb is a list*/
455         {
456                 Scierror(56, _("%s : outtb element of state must be a list.\n"),fname);
457                 FREE(l_state_evtspt); FREE(l_pointi);
458                 C2F(iop).err=4;
459                 return 0;
460         }
461         nlnk = il_state_outtb[1]; /*nlnk is the dimension of the list state_louttb*/
462
463         /***************
464         * tcur (rhs 2)
465         ***************/
466         il_tcur = (int *) GetData(2);
467         if(il_tcur[0]!=1) /*Check if tcur is a real or complex matrix*/
468         {
469                 Scierror(53, _("%s : Second argument must be a scalar.\n"),fname);
470                 FREE(l_state_evtspt); FREE(l_pointi);
471                 C2F(iop).err=2;
472                 return 0;
473         }
474         l_tcur = (double *) (il_tcur+4);
475         m2 = il_tcur[1];
476         n2 = il_tcur[2];
477         CheckScalar(2,m2,n2);
478         CheckDims(2,m2,n2,1,1);
479
480         /*************
481         * tf (rhs 3)
482         *************/
483         il_tf = (int *) GetData(3);
484         if(il_tf[0]!=1) /*Check if tf is a real or complex matrix*/
485         {
486                 Scierror(53, _("%s : Third argument must be a scalar.\n"),fname);
487                 FREE(l_state_evtspt); FREE(l_pointi);
488                 C2F(iop).err=3;
489                 return 0;
490         }
491         l_tf = (double *) (il_tf+4);
492         m3 = il_tf[1];
493         n3 = il_tf[2];
494         CheckScalar(3,m3,n3);
495         CheckDims(3,m3,n3,1,1);
496
497         /*************
498         * sim (rhs 4)
499         *************/
500         il_sim = (int *) GetData(4);
501
502
503         set_il_sim(il_sim);
504
505         if(il_sim[0]!=16)  /*Check if sim is a tlist*/
506         {
507                 Scierror(56, _("%s : Fourth argument must be a Tlist.\n"),fname);
508                 FREE(l_state_evtspt); FREE(l_pointi);
509                 C2F(iop).err=4;
510                 return 0;
511         }
512         m4 = il_sim[1];
513         n4 = il_sim[2];
514
515         /*2  : sim.funs*/
516         il_sim_fun = (int *) (listentry(il_sim,2));
517         if(il_sim_fun[0]!=15) /*check if sim.funs is a list*/
518         {
519                 Scierror(56, _("%s : Second element of sim must be a list.\n"),fname);
520                 FREE(l_state_evtspt); FREE(l_pointi);
521                 C2F(iop).err=4;
522                 return 0;
523         }
524         nblk = il_sim_fun[1]; /*nblk is the dimension of the list sim.funs*/
525
526         /*3  : sim.xptr   */
527         il_sim_xptr = (int *) (listentry(il_sim,3));
528         m_xptr = il_sim_xptr[1];
529         n_xptr = il_sim_xptr[2];
530         if (m_xptr*n_xptr==0) l_sim_xptr=NULL;
531         else
532         {
533                 if ((l_sim_xptr=(int *) MALLOC((m_xptr*n_xptr)*sizeof(int))) ==NULL )
534                 {
535                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
536                         FREE(l_state_evtspt); FREE(l_pointi);
537                         return 0;
538                 }
539                 else
540                 {
541                         for(i=0;i<(m_xptr*n_xptr);i++) l_sim_xptr[i]= (int) ((double *)(il_sim_xptr+4))[i];
542                 }
543         }
544
545         /*4  : sim.zptr   */
546         il_sim_zptr = (int *) (listentry(il_sim,4));
547         m_zptr = il_sim_zptr[1];
548         n_zptr = il_sim_zptr[2];
549         if (m_zptr*n_zptr==0) l_sim_zptr=NULL;
550         else
551         {
552                 if ((l_sim_zptr=(int *) MALLOC((m_zptr*n_zptr)*sizeof(int))) ==NULL )
553                 {
554                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
555                         FREE(l_sim_xptr);
556                         FREE(l_state_evtspt); FREE(l_pointi);
557                         return 0;
558                 }
559                 else
560                 {
561                         for(i=0;i<(m_zptr*n_zptr);i++) l_sim_zptr[i]= (int) ((double *)(il_sim_zptr+4))[i];
562                 }
563         }
564
565         /*5  : sim.ozptr   */
566         il_sim_ozptr = (int *) (listentry(il_sim,5));
567         m_ozptr = il_sim_ozptr[1];
568         n_ozptr = il_sim_ozptr[2];
569         if (m_ozptr*n_ozptr==0) l_sim_ozptr=NULL;
570         else
571         {
572                 if ((l_sim_ozptr=(int *) MALLOC((m_ozptr*n_ozptr)*sizeof(int))) ==NULL )
573                 {
574                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
575                         FREE(l_sim_zptr); FREE(l_sim_xptr);
576                         FREE(l_state_evtspt); FREE(l_pointi);
577                         return 0;
578                 }
579                 else
580                 {
581                         for(i=0;i<(m_ozptr*n_ozptr);i++) l_sim_ozptr[i]= (int) ((double *)(il_sim_ozptr+4))[i];
582                 }
583         }
584
585         /*6  : sim.zcptr  */
586         il_sim_zcptr = (int *) (listentry(il_sim,6));
587         m_zcptr = il_sim_zcptr[1];
588         n_zcptr = il_sim_zcptr[2];
589         if (m_zcptr*n_zcptr==0) l_sim_zcptr=NULL;
590         else
591         {
592                 if ((l_sim_zcptr=(int *) MALLOC((m_zcptr*n_zcptr)*sizeof(int))) ==NULL )
593                 {
594                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
595                         FREE(l_sim_ozptr); FREE(l_sim_zptr); FREE(l_sim_xptr);
596                         FREE(l_state_evtspt); FREE(l_pointi);
597                         return 0;
598                 }
599                 else
600                 {
601                         for(i=0;i<(m_zcptr*n_zcptr);i++) l_sim_zcptr[i]= (int) ((double *)(il_sim_zcptr+4))[i];
602                 }
603         }
604
605         /*7  : sim.inpptr */
606         il_sim_inpptr = (int *) (listentry(il_sim,7));
607         m_inpptr = il_sim_inpptr[1];
608         n_inpptr = il_sim_inpptr[2];
609         if (m_inpptr*n_inpptr==0) l_sim_inpptr=NULL;
610         else
611         {
612                 if ((l_sim_inpptr=(int *) MALLOC((m_inpptr*n_inpptr)*sizeof(int))) ==NULL )
613                 {
614                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
615                         FREE(l_sim_ozptr);
616                         FREE(l_sim_zcptr); FREE(l_sim_zptr); FREE(l_sim_xptr);
617                         FREE(l_state_evtspt); FREE(l_pointi);
618                         return 0;
619                 }
620                 else
621                 {
622                         for(i=0;i<(m_inpptr*n_inpptr);i++) l_sim_inpptr[i]= (int) ((double *)(il_sim_inpptr+4))[i];
623                 }
624         }
625
626         /*8  : sim.outptr */
627         il_sim_outptr = (int *) (listentry(il_sim,8));
628         m_outptr = il_sim_outptr[1];
629         n_outptr = il_sim_outptr[2];
630         if (m_outptr*n_outptr==0) l_sim_outptr=NULL;
631         else
632         {
633                 if ((l_sim_outptr=(int *) MALLOC((m_outptr*n_outptr)*sizeof(int))) ==NULL )
634                 {
635                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
636                         FREE(l_sim_inpptr);
637                         FREE(l_sim_ozptr);
638                         FREE(l_sim_zcptr); FREE(l_sim_zptr); FREE(l_sim_xptr);
639                         FREE(l_state_evtspt); FREE(l_pointi);
640                         return 0;
641                 }
642                 else
643                 {
644                         for(i=0;i<(m_outptr*n_outptr);i++) l_sim_outptr[i]= (int) ((double *)(il_sim_outptr+4))[i];
645                 }
646         }
647
648         /*9  : sim.inplnk */
649         il_sim_inplnk = (int *) (listentry(il_sim,9));
650         m_inplnk = il_sim_inplnk[1];
651         n_inplnk = il_sim_inplnk[2];
652         if (m_inplnk*n_inplnk==0) l_sim_inplnk=NULL;
653         else
654         {
655                 if ((l_sim_inplnk=(int *) MALLOC((m_inplnk*n_inplnk)*sizeof(int))) ==NULL )
656                 {
657                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
658                         FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
659                         FREE(l_sim_ozptr);
660                         FREE(l_sim_zptr); FREE(l_sim_xptr);
661                         FREE(l_state_evtspt); FREE(l_pointi);
662                         return 0;
663                 }
664                 else
665                 {
666                         for(i=0;i<(m_inplnk*n_inplnk);i++) l_sim_inplnk[i]= (int) ((double *)(il_sim_inplnk+4))[i];
667                 }
668         }
669
670         /*10  : sim.outlnk */
671         il_sim_outlnk = (int *) (listentry(il_sim,10));
672         m_outlnk = il_sim_outlnk[1];
673         n_outlnk = il_sim_outlnk[2];
674         if (m_outlnk*n_outlnk==0) l_sim_outlnk=NULL;
675         else
676         {
677                 if ((l_sim_outlnk=(int *) MALLOC((m_outlnk*n_outlnk)*sizeof(int))) ==NULL )
678                 {
679                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
680                         FREE(l_sim_inplnk);
681                         FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
682                         FREE(l_sim_ozptr);
683                         FREE(l_sim_zptr); FREE(l_sim_xptr);
684                         FREE(l_state_evtspt); FREE(l_pointi);
685                         return 0;
686                 }
687                 else
688                 {
689                         for(i=0;i<(m_outlnk*n_outlnk);i++) l_sim_outlnk[i]= (int) ((double *)(il_sim_outlnk+4))[i];
690                 }
691         }
692
693         /*11 : sim.rpar   */
694         il_sim_rpar = (int *) (listentry(il_sim,11));
695         m_rpar = il_sim_rpar[1];
696         n_rpar = il_sim_rpar[2];
697         if (m_rpar*n_rpar==0) l_sim_rpar=NULL;
698         else
699         {
700                 l_sim_rpar = (double *) (il_sim_rpar+4);
701         }
702
703         /*12 : sim.rpptr  */
704         il_sim_rpptr = (int *) (listentry(il_sim,12));
705         m_rpptr = il_sim_rpptr[1];
706         n_rpptr = il_sim_rpptr[2];
707         if (m_rpptr*n_rpptr==0) l_sim_rpptr=NULL;
708         else
709         {
710                 if ((l_sim_rpptr=(int *) MALLOC((m_rpptr*n_rpptr)*sizeof(int))) ==NULL )
711                 {
712                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
713                         FREE(l_sim_outlnk); FREE(l_sim_inplnk);
714                         FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
715                         FREE(l_sim_ozptr);
716                         FREE(l_sim_zptr); FREE(l_sim_xptr);
717                         FREE(l_state_evtspt); FREE(l_pointi);
718                         return 0;
719                 }
720                 else
721                 {
722                         for(i=0;i<(m_rpptr*n_rpptr);i++) l_sim_rpptr[i]= (int) ((double *)(il_sim_rpptr+4))[i];
723                 }
724         }
725
726         /*13 : sim.ipar   */
727         il_sim_ipar = (int *) (listentry(il_sim,13));
728         m_ipar = il_sim_ipar[1];
729         n_ipar = il_sim_ipar[2];
730         if (m_ipar*n_ipar==0) l_sim_ipar=NULL;
731         else
732         {
733                 if ((l_sim_ipar=(int *) MALLOC((m_ipar*n_ipar)*sizeof(int))) ==NULL )
734                 {
735                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
736                         FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
737                         FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
738                         FREE(l_sim_ozptr);
739                         FREE(l_sim_zptr); FREE(l_sim_xptr);
740                         FREE(l_state_evtspt); FREE(l_pointi);
741                         return 0;
742                 }
743                 else
744                 {
745                         for(i=0;i<(m_ipar*n_ipar);i++) l_sim_ipar[i]= (int) ((double *)(il_sim_ipar+4))[i];
746                 }
747         }
748
749         /*14 : sim.ipptr  */
750         il_sim_ipptr = (int *) (listentry(il_sim,14));
751         m_ipptr = il_sim_ipptr[1];
752         n_ipptr = il_sim_ipptr[2];
753         if (m_ipptr*n_ipptr==0) l_sim_ipptr=NULL;
754         else
755         {
756                 if ((l_sim_ipptr=(int *) MALLOC((m_ipptr*n_ipptr)*sizeof(int))) ==NULL )
757                 {
758                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
759                         FREE(l_sim_ipar);
760                         FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
761                         FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
762                         FREE(l_sim_ozptr);
763                         FREE(l_sim_zptr); FREE(l_sim_xptr);
764                         FREE(l_state_evtspt); FREE(l_pointi);
765                         return 0;
766                 }
767                 else
768                 {
769                         for(i=0;i<(m_ipptr*n_ipptr);i++) l_sim_ipptr[i]= (int) ((double *)(il_sim_ipptr+4))[i];
770                 }
771         }
772
773         /*15 : sim.opar   */
774         il_sim_opar = (int *) (listentry(il_sim,15));
775         if(il_sim_opar[0]!=15)  /*Check if sim.opar is a list*/
776         {
777                 Scierror(56, _("%s : sim.opar must be a list.\n"),fname);
778                 FREE(l_sim_ipptr); FREE(l_sim_ipar);
779                 FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
780                 FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
781                 FREE(l_sim_ozptr);
782                 FREE(l_sim_zptr); FREE(l_sim_xptr);
783                 FREE(l_state_evtspt); FREE(l_pointi);
784                 C2F(iop).err=4;
785                 return 0;
786         }
787         nopar = il_sim_opar[1];
788
789         /*16 : sim.opptr  */
790         il_sim_opptr = (int *) (listentry(il_sim,16));
791         m_opptr = il_sim_opptr[1];
792         n_opptr = il_sim_opptr[2];
793         if (m_opptr*n_opptr==0) l_sim_opptr=NULL;
794         else
795         {
796                 if ((l_sim_opptr=(int *) MALLOC((m_opptr*n_opptr)*sizeof(int))) ==NULL )
797                 {
798                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
799                         FREE(l_sim_ipptr); FREE(l_sim_ipar);
800                         FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
801                         FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
802                         FREE(l_sim_ozptr);
803                         FREE(l_sim_zptr); FREE(l_sim_xptr);
804                         FREE(l_state_evtspt); FREE(l_pointi);
805                         return 0;
806                 }
807                 else
808                 {
809                         for(i=0;i<(m_opptr*n_opptr);i++) l_sim_opptr[i]= (int) ((double *)(il_sim_opptr+4))[i];
810                 }
811         }
812
813         /*17 : sim.clkptr */
814         il_sim_clkptr = (int *) (listentry(il_sim,17));
815         m_clkptr = il_sim_clkptr[1];
816         n_clkptr = il_sim_clkptr[2];
817         if (m_clkptr*n_clkptr==0) l_sim_clkptr=NULL;
818         else
819         {
820                 if ((l_sim_clkptr=(int *) MALLOC((m_clkptr*n_clkptr)*sizeof(int))) ==NULL )
821                 {
822                         Scierror(999,  _("%s: Memory allocation error.\n"),fname);
823                         FREE(l_sim_clkptr);
824                         FREE(l_sim_opptr);
825                         FREE(l_sim_ipptr); FREE(l_sim_ipar);
826                         FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
827                         FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
828                         FREE(l_sim_ozptr);
829                         FREE(l_sim_zptr); FREE(l_sim_xptr);
830                         FREE(l_state_evtspt); FREE(l_pointi);
831                         return 0;
832                 }
833                 else
834                 {
835                         for(i=0;i<(m_clkptr*n_clkptr);i++) l_sim_clkptr[i]= (int) ((double *)(il_sim_clkptr+4))[i];
836                 }
837         }
838
839         /*18 : sim.ordptr */
840         il_sim_ordptr = (int *) (listentry(il_sim,18));
841         m_ordptr = il_sim_ordptr[1];
842         n_ordptr = il_sim_ordptr[2];
843         if ((l_sim_ordptr=(int *) MALLOC((m_ordptr*n_ordptr)*sizeof(int))) ==NULL )
844         {
845                 Scierror(999, _("%s: Memory allocation error.\n"),fname);
846                 FREE(l_sim_clkptr);
847                 FREE(l_sim_opptr);
848                 FREE(l_sim_ipptr); FREE(l_sim_ipar);
849                 FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
850                 FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
851                 FREE(l_sim_ozptr);
852                 FREE(l_sim_zptr); FREE(l_sim_xptr);
853                 FREE(l_state_evtspt); FREE(l_pointi);
854                 return 0;
855         }
856         else
857         {
858                 for(i=0;i<(m_ordptr*n_ordptr);i++) l_sim_ordptr[i]= (int) ((double *)(il_sim_ordptr+4))[i];
859         }
860
861         /*19 : sim.execlk */
862         il_sim_execlk = (int *) (listentry(il_sim,19));
863         m_execlk = il_sim_execlk[1];
864         n_execlk = il_sim_execlk[2];
865         if (m_execlk*n_execlk==0) l_sim_execlk=NULL;
866         else
867         {
868                 if ((l_sim_execlk=(int *) MALLOC((m_execlk*n_execlk)*sizeof(int))) ==NULL )
869                 {
870                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
871                         FREE(l_sim_ordptr); FREE(l_sim_clkptr);
872                         FREE(l_sim_opptr);
873                         FREE(l_sim_ipptr); FREE(l_sim_ipar);
874                         FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
875                         FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
876                         FREE(l_sim_ozptr);
877                         FREE(l_sim_zptr); FREE(l_sim_xptr);
878                         FREE(l_state_evtspt); FREE(l_pointi);
879                         return 0;
880                 }
881                 else
882                 {
883                         for(i=0;i<(m_execlk*n_execlk);i++) l_sim_execlk[i]= (int) ((double *)(il_sim_execlk+4))[i];
884                 }
885         }
886
887         /*20 : sim.ordclk */
888         il_sim_ordclk = (int *) (listentry(il_sim,20));
889         m_ordclk = il_sim_ordclk[1];
890         n_ordclk = il_sim_ordclk[2];
891         if (m_ordclk*n_ordclk==0) l_sim_ordclk=NULL;
892         else
893         {
894                 if ((l_sim_ordclk=(int *) MALLOC((m_ordclk*n_ordclk)*sizeof(int))) ==NULL )
895                 {
896                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
897                         FREE(l_sim_execlk); FREE(l_sim_ordptr); FREE(l_sim_clkptr);
898                         FREE(l_sim_opptr);
899                         FREE(l_sim_ipptr); FREE(l_sim_ipar);
900                         FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
901                         FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
902                         FREE(l_sim_ozptr);
903                         FREE(l_sim_zptr); FREE(l_sim_xptr);
904                         FREE(l_state_evtspt); FREE(l_pointi);
905                         return 0;
906                 }
907                 else
908                 {
909                         for(i=0;i<(m_ordclk*n_ordclk);i++) l_sim_ordclk[i]= (int) ((double *)(il_sim_ordclk+4))[i];
910                 }
911         }
912
913         /*21 : sim.cord   */
914         il_sim_cord = (int *) (listentry(il_sim,21));
915         m_cord = il_sim_cord[1];
916         n_cord = il_sim_cord[2];
917         if (m_cord*n_cord==0) l_sim_cord=NULL;
918         else
919         {
920                 if ((l_sim_cord=(int *) MALLOC((m_cord*n_cord)*sizeof(int))) ==NULL )
921                 {
922                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
923                         FREE(l_sim_ordclk); FREE(l_sim_execlk); FREE(l_sim_ordptr); FREE(l_sim_clkptr);
924                         FREE(l_sim_opptr);
925                         FREE(l_sim_ipptr); FREE(l_sim_ipar);
926                         FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
927                         FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
928                         FREE(l_sim_ozptr);
929                         FREE(l_sim_zptr); FREE(l_sim_xptr);
930                         FREE(l_state_evtspt); FREE(l_pointi);
931                         return 0;
932                 }
933                 else
934                 {
935                         for(i=0;i<(m_cord*n_cord);i++) l_sim_cord[i]= (int) ((double *)(il_sim_cord+4))[i];
936                 }
937         }
938
939         /*22 : sim.oord   */
940         il_sim_oord = (int *) (listentry(il_sim,22));
941         m_oord = il_sim_oord[1];
942         n_oord = il_sim_oord[2];
943         if (m_oord*n_oord==0) l_sim_oord=NULL;
944         else
945         {
946                 if ((l_sim_oord=(int *) MALLOC((m_oord*n_oord)*sizeof(int))) ==NULL )
947                 {
948                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
949                         FREE(l_sim_cord);
950                         FREE(l_sim_ordclk); FREE(l_sim_execlk); FREE(l_sim_ordptr); FREE(l_sim_clkptr);
951                         FREE(l_sim_opptr);
952                         FREE(l_sim_ipptr); FREE(l_sim_ipar);
953                         FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
954                         FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
955                         FREE(l_sim_ozptr);
956                         FREE(l_sim_zptr); FREE(l_sim_xptr);
957                         FREE(l_state_evtspt); FREE(l_pointi);
958                         return 0;
959                 }
960                 else
961                 {
962                         for(i=0;i<(m_oord*n_oord);i++) l_sim_oord[i]= (int) ((double *)(il_sim_oord+4))[i];
963                 }
964         }
965
966         /*23 : sim.zord   */
967         il_sim_zord = (int *) (listentry(il_sim,23));
968         m_zord = il_sim_zord[1];
969         n_zord = il_sim_zord[2];
970         if (m_zord*n_zord==0) l_sim_zord=NULL;
971         else
972         {
973                 if ((l_sim_zord=(int *) MALLOC((m_zord*n_zord)*sizeof(int))) ==NULL )
974                 {
975                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
976                         FREE(l_sim_oord); FREE(l_sim_cord);
977                         FREE(l_sim_ordclk); FREE(l_sim_execlk); FREE(l_sim_ordptr); FREE(l_sim_clkptr);
978                         FREE(l_sim_opptr);
979                         FREE(l_sim_ipptr); FREE(l_sim_ipar);
980                         FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
981                         FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
982                         FREE(l_sim_ozptr);
983                         FREE(l_sim_zptr); FREE(l_sim_xptr);
984                         FREE(l_state_evtspt); FREE(l_pointi);
985                         return 0;
986                 }
987                 else
988                 {
989                         for(i=0;i<(m_zord*n_zord);i++) l_sim_zord[i]= (int) ((double *)(il_sim_zord+4))[i];
990                 }
991         }
992
993         /*24 : sim.critev */
994         il_sim_critev = (int *) (listentry(il_sim,24));
995         m_critev = il_sim_critev[1];
996         n_critev = il_sim_critev[2];
997         if (m_critev*n_critev==0) l_sim_critev=NULL;
998         else
999         {
1000                 if ((l_sim_critev=(int *) MALLOC((m_critev*n_critev)*sizeof(int))) ==NULL )
1001                 {
1002                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
1003                         FREE(l_sim_zord); FREE(l_sim_oord); FREE(l_sim_cord);
1004                         FREE(l_sim_ordclk); FREE(l_sim_execlk); FREE(l_sim_ordptr); FREE(l_sim_clkptr);
1005                         FREE(l_sim_opptr);
1006                         FREE(l_sim_ipptr); FREE(l_sim_ipar);
1007                         FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
1008                         FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
1009                         FREE(l_sim_ozptr);
1010                         FREE(l_sim_zptr); FREE(l_sim_xptr);
1011                         FREE(l_state_evtspt); FREE(l_pointi);
1012                         return 0;
1013                 }
1014                 else
1015                 {
1016                         for(i=0;i<(m_critev*n_critev);i++) l_sim_critev[i]= (int) ((double *)(il_sim_critev+4))[i];
1017                 }
1018         }
1019
1020         /*25 : sim.nb     */
1021         il_sim_nb = (int *) (listentry(il_sim,25));
1022         m_nb = il_sim_nb[1];
1023         n_nb = il_sim_nb[2];
1024         if ((l_sim_nb=(int *) MALLOC((m_nb*n_nb)*sizeof(int))) ==NULL )
1025         {
1026                 Scierror(999, _("%s: Memory allocation error.\n"),fname);
1027                 FREE(l_sim_critev);
1028                 FREE(l_sim_zord); FREE(l_sim_oord); FREE(l_sim_cord);
1029                 FREE(l_sim_ordclk); FREE(l_sim_execlk); FREE(l_sim_ordptr); FREE(l_sim_clkptr);
1030                 FREE(l_sim_opptr);
1031                 FREE(l_sim_ipptr); FREE(l_sim_ipar);
1032                 FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
1033                 FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
1034                 FREE(l_sim_ozptr);
1035                 FREE(l_sim_zptr); FREE(l_sim_xptr);
1036                 FREE(l_state_evtspt); FREE(l_pointi);
1037                 return 0;
1038         }
1039         else
1040         {
1041                 for(i=0;i<(m_nb*n_nb);i++) l_sim_nb[i]= (int) ((double *)(il_sim_nb+4))[i];
1042         }
1043         if (l_sim_nb[0]!=nblk) /*value of nb must be equal to nblk*/
1044         {
1045                 Scierror(42, _("%s : Incompatible sim.nb RHS parameter.\n"),fname);
1046                 return 0;
1047         }
1048
1049         /*26 : sim.ztyp   */
1050         il_sim_ztyp = (int *) (listentry(il_sim,26));
1051         m_ztyp = il_sim_ztyp[1];
1052         n_ztyp = il_sim_ztyp[2];
1053         if ((l_sim_ztyp=(int *) MALLOC((m_ztyp*n_ztyp)*sizeof(int))) ==NULL )
1054         {
1055                 Scierror(999, _("%s: Memory allocation error.\n"),fname);
1056                 FREE(l_sim_nb); FREE(l_sim_critev);
1057                 FREE(l_sim_zord); FREE(l_sim_oord); FREE(l_sim_cord);
1058                 FREE(l_sim_ordclk); FREE(l_sim_execlk); FREE(l_sim_ordptr); FREE(l_sim_clkptr);
1059                 FREE(l_sim_opptr);
1060                 FREE(l_sim_ipptr); FREE(l_sim_ipar);
1061                 FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
1062                 FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
1063                 FREE(l_sim_ozptr);
1064                 FREE(l_sim_zptr); FREE(l_sim_xptr);
1065                 FREE(l_state_evtspt); FREE(l_pointi);
1066                 return 0;
1067         }
1068         else
1069         {
1070                 for(i=0;i<(m_ztyp*n_ztyp);i++) l_sim_ztyp[i]= (int) ((double *)(il_sim_ztyp+4))[i];
1071         }
1072
1073         /*27 : sim.nblk   */
1074         il_sim_nblk = (int *) (listentry(il_sim,27));
1075         m_nblk = il_sim_nblk[1];
1076         n_nblk = il_sim_nblk[2];
1077         if ((l_sim_nblk=(int *) MALLOC((m_nblk*n_nblk)*sizeof(int))) ==NULL )
1078         {
1079                 Scierror(999, _("%s: Memory allocation error.\n"),fname);
1080                 FREE(l_sim_ztyp); FREE(l_sim_nb); FREE(l_sim_critev);
1081                 FREE(l_sim_zord); FREE(l_sim_oord); FREE(l_sim_cord);
1082                 FREE(l_sim_ordclk); FREE(l_sim_execlk); FREE(l_sim_ordptr); FREE(l_sim_clkptr);
1083                 FREE(l_sim_opptr);
1084                 FREE(l_sim_ipptr); FREE(l_sim_ipar);
1085                 FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
1086                 FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
1087                 FREE(l_sim_ozptr);
1088                 FREE(l_sim_zptr); FREE(l_sim_xptr);
1089                 FREE(l_state_evtspt); FREE(l_pointi);
1090                 return 0;
1091         }
1092         else
1093         {
1094                 for(i=0;i<(m_nblk*n_nblk);i++) l_sim_nblk[i]= (int) ((double *)(il_sim_ztyp+4))[i];
1095         }
1096
1097         /*28 : sim.ndcblk */
1098         il_sim_ndcblk = (int *) (listentry(il_sim,28));
1099         m_ndcblk = il_sim_ndcblk[1];
1100         n_ndcblk = il_sim_ndcblk[2];
1101         if ((l_sim_ndcblk=(int *) MALLOC((m_ndcblk*n_ndcblk)*sizeof(int))) ==NULL )
1102         {
1103                 Scierror(999,_("%s: Memory allocation error.\n"),fname);
1104                 FREE(l_sim_nblk); FREE(l_sim_ztyp); FREE(l_sim_nb); FREE(l_sim_critev);
1105                 FREE(l_sim_zord); FREE(l_sim_oord); FREE(l_sim_cord);
1106                 FREE(l_sim_ordclk); FREE(l_sim_execlk); FREE(l_sim_ordptr); FREE(l_sim_clkptr);
1107                 FREE(l_sim_opptr);
1108                 FREE(l_sim_ipptr); FREE(l_sim_ipar);
1109                 FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
1110                 FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
1111                 FREE(l_sim_ozptr);
1112                 FREE(l_sim_zptr); FREE(l_sim_xptr);
1113                 FREE(l_state_evtspt); FREE(l_pointi);
1114                 return 0;
1115         }
1116         else
1117         {
1118                 for(i=0;i<(m_ndcblk*n_ndcblk);i++) l_sim_ndcblk[i]= (int) ((double *)(il_sim_ndcblk+4))[i];
1119         }
1120
1121         /*29 : sim.subscr */
1122         il_sim_subscr = (int *) (listentry(il_sim,29));
1123         m_subscr = il_sim_subscr[1];
1124         n_subscr = il_sim_subscr[2];
1125         if (m_subscr*n_subscr==0) l_sim_subscr=NULL;
1126         else
1127         {
1128                 if ((l_sim_subscr=(int *) MALLOC((m_subscr*n_subscr)*sizeof(int))) ==NULL )
1129                 {
1130                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
1131                         FREE(l_sim_ndcblk);
1132                         FREE(l_sim_nblk); FREE(l_sim_ztyp); FREE(l_sim_nb); FREE(l_sim_critev);
1133                         FREE(l_sim_zord); FREE(l_sim_oord); FREE(l_sim_cord);
1134                         FREE(l_sim_ordclk); FREE(l_sim_execlk); FREE(l_sim_ordptr); FREE(l_sim_clkptr);
1135                         FREE(l_sim_opptr);
1136                         FREE(l_sim_ipptr); FREE(l_sim_ipar);
1137                         FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
1138                         FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
1139                         FREE(l_sim_ozptr);
1140                         FREE(l_sim_zptr); FREE(l_sim_xptr);
1141                         FREE(l_state_evtspt); FREE(l_pointi);
1142                         return 0;
1143                 }
1144                 else
1145                 {
1146                         for(i=0;i<(m_subscr*n_subscr);i++) l_sim_subscr[i]= (int) ((double *)(il_sim_subscr+4))[i];
1147                 }
1148         }
1149
1150         /*30 : sim.funtyp */
1151         il_sim_funtyp = (int *) (listentry(il_sim,30));
1152         m_funtyp = il_sim_funtyp[1];
1153         n_funtyp = il_sim_funtyp[2];
1154         if ((l_sim_funtyp=(int *) MALLOC((m_funtyp*n_funtyp)*sizeof(int))) ==NULL )
1155         {
1156                 Scierror(999, _("%s: Memory allocation error.\n"),fname);
1157                 FREE(l_sim_subscr); FREE(l_sim_ndcblk);
1158                 FREE(l_sim_nblk); FREE(l_sim_ztyp); FREE(l_sim_nb); FREE(l_sim_critev);
1159                 FREE(l_sim_zord); FREE(l_sim_oord); FREE(l_sim_cord);
1160                 FREE(l_sim_ordclk); FREE(l_sim_execlk); FREE(l_sim_ordptr); FREE(l_sim_clkptr);
1161                 FREE(l_sim_opptr);
1162                 FREE(l_sim_ipptr); FREE(l_sim_ipar);
1163                 FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
1164                 FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
1165                 FREE(l_sim_ozptr);
1166                 FREE(l_sim_zptr); FREE(l_sim_xptr);
1167                 FREE(l_state_evtspt); FREE(l_pointi);
1168                 return 0;
1169         }
1170         else
1171         {
1172                 for(i=0;i<(m_funtyp*n_funtyp);i++) l_sim_funtyp[i]= (int) ((double *)(il_sim_funtyp+4))[i];
1173         }
1174
1175         /*31 : sim.iord   */
1176         il_sim_iord = (int *) (listentry(il_sim,31));
1177         m_iord = il_sim_iord[1];
1178         n_iord = il_sim_iord[2];
1179         if (m_iord*n_iord==0) l_sim_iord=NULL;
1180         else
1181         {
1182                 if ((l_sim_iord=(int *) MALLOC((m_iord*n_iord)*sizeof(int))) ==NULL )
1183                 {
1184                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
1185                         FREE(l_sim_funtyp); FREE(l_sim_subscr); FREE(l_sim_ndcblk);
1186                         FREE(l_sim_nblk); FREE(l_sim_ztyp); FREE(l_sim_nb); FREE(l_sim_critev);
1187                         FREE(l_sim_zord); FREE(l_sim_oord); FREE(l_sim_cord);
1188                         FREE(l_sim_ordclk); FREE(l_sim_execlk); FREE(l_sim_ordptr); FREE(l_sim_clkptr);
1189                         FREE(l_sim_opptr);
1190                         FREE(l_sim_ipptr); FREE(l_sim_ipar);
1191                         FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
1192                         FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
1193                         FREE(l_sim_ozptr);
1194                         FREE(l_sim_zptr); FREE(l_sim_xptr);
1195                         FREE(l_state_evtspt); FREE(l_pointi);
1196                         return 0;
1197                 }
1198                 else
1199                 {
1200                         for(i=0;i<(m_iord*n_iord);i++) l_sim_iord[i]= (int) ((double *)(il_sim_iord+4))[i];
1201                 }
1202         }
1203
1204         /*32 : sim.labels */
1205         il_sim_lab = (int *) (listentry(il_sim,32));
1206         m_lab = il_sim_lab[1];
1207         n_lab = il_sim_lab[2];
1208         il_sim_labptr = &il_sim_lab[4];  /*get address-1 of first pointer in labels*/
1209         l_sim_lab = (int *) (il_sim_lab+m_lab+5); /*get address of first string in labels*/
1210
1211         /*33 : sim.modptr */
1212         il_sim_modptr = (int *) (listentry(il_sim,33));
1213         m_modptr = il_sim_modptr[1];
1214         n_modptr = il_sim_modptr[2];
1215         if ((l_sim_modptr=(int *) MALLOC((m_modptr*n_modptr)*sizeof(int))) ==NULL )
1216         {
1217                 Scierror(999, _("%s: Memory allocation error.\n"),fname);
1218                 FREE(l_sim_iord); FREE(l_sim_funtyp); FREE(l_sim_subscr); FREE(l_sim_ndcblk);
1219                 FREE(l_sim_nblk); FREE(l_sim_ztyp); FREE(l_sim_nb); FREE(l_sim_critev);
1220                 FREE(l_sim_zord); FREE(l_sim_oord); FREE(l_sim_cord);
1221                 FREE(l_sim_ordclk); FREE(l_sim_execlk); FREE(l_sim_ordptr); FREE(l_sim_clkptr);
1222                 FREE(l_sim_opptr);
1223                 FREE(l_sim_ipptr); FREE(l_sim_ipar);
1224                 FREE(l_sim_rpptr); FREE(l_sim_outlnk); FREE(l_sim_inplnk);
1225                 FREE(l_sim_outptr); FREE(l_sim_inpptr); FREE(l_sim_zcptr);
1226                 FREE(l_sim_ozptr);
1227                 FREE(l_sim_zptr); FREE(l_sim_xptr);
1228                 FREE(l_state_evtspt); FREE(l_pointi);
1229                 return 0;
1230         }
1231         else
1232         {
1233                 for(i=0;i<(m_modptr*n_modptr);i++) l_sim_modptr[i]= (int) ((double *)(il_sim_modptr+4))[i];
1234         }
1235
1236         /*************
1237         * str (rhs 5)
1238         *************/
1239         il_str = (int *) GetData(5);
1240         m5 = il_str[1];
1241         n5 = il_str[2];
1242         l_str = (int *) (il_str+6);
1243         CheckDims(5,m5,n5,m5,1);
1244
1245         sz_str=il_str[5]-1; /*store the length of str*/
1246         C2F(cha1).buf[0]=' ';
1247         C2F(cvstr)(&sz_str,&l_str[0],&C2F(cha1).buf[0],(j=1,&j),sz_str); /*codetoascii*/
1248         C2F(cha1).buf[sz_str]='\0';
1249         if (strcmp(C2F(cha1).buf,"start") == 0) flag=1;
1250         else if (strcmp(C2F(cha1).buf,"run") == 0) flag=2;
1251         else if (strcmp(C2F(cha1).buf,"finish") == 0) flag=3;
1252         else if (strcmp(C2F(cha1).buf,"linear") == 0) flag=4;
1253         else if (strcmp(C2F(cha1).buf,"Kinsol") == 0) flag=5;
1254         else
1255         {
1256                 Scierror(44,"%s : Fifth argument is incorrect.\n",fname);
1257                 freeparam;
1258                 C2F(iop).err=5;
1259                 return 0;
1260         }
1261
1262         /*************
1263         * tol (rhs 6)
1264         *************/
1265         il_tol = (int *) GetData(6);
1266         l_tol = (double *) (il_tol+4);
1267         m6 = il_tol[1];
1268         n6 = il_tol[2];
1269         m6 = m6*n6;
1270         if (m6<4) /*Check if tol has a minimun of four elements*/
1271         {
1272                 Scierror(89, _("%s : Sixth argument must have at least four elements.\n"),fname);
1273                 freeparam;
1274                 C2F(iop).err=6;
1275                 return 0;
1276         }
1277         else if(m6>7) /*Check if tol has a maximum of seven elements*/
1278         {
1279                 Scierror(89,_("%s : Sixth argument must have a maximum of seven elements.\n"),fname);
1280                 freeparam;
1281                 C2F(iop).err=6;
1282                 return 0;
1283         }
1284
1285         /******************
1286         * set simpar array
1287         ******************/
1288         if (m6==4) {for(i=0;i<4;i++) simpar[i]=l_tol[i];simpar[4]=0;simpar[5]=0;simpar[6]=0;}
1289         else if (m6==5) {for(i=0;i<5;i++) simpar[i]=l_tol[i];simpar[5]=0;simpar[6]=0;}
1290         else if (m6==6) {for(i=0;i<6;i++) simpar[i]=l_tol[i];simpar[6]=0;}
1291         else for(i=0;i<7;i++) simpar[i]=l_tol[i];
1292         solver=(int)simpar[5]; /*set solver variable*/
1293
1294         /******************************
1295         * cross variable size checking
1296         ******************************/
1297         err_check = 0;
1298         if (m1e6!=m1e7) err_check=1;             /*tevts vs evtspt*/
1299         else if (m_xptr!=m_zptr) err_check=2;    /*xptr vs zptr*/
1300         else if (m_xptr!=m_ozptr) err_check=3;   /*xptr vs ozptr*/
1301         else if (m_xptr!=m_zcptr) err_check=4;   /*xptr vs zcptr*/
1302         else if (m_xptr!=m_inpptr) err_check=5;  /*xptr vs inpptr*/
1303         else if (m_xptr!=m_outptr) err_check=6;  /*xptr vs outptr*/
1304         else if (m_xptr!=m_rpptr) err_check=7;   /*xptr vs rpptr*/
1305         else if (m_xptr!=m_ipptr) err_check=8;   /*xptr vs ipptr*/
1306         else if (m_xptr!=m_opptr) err_check=8;   /*xptr vs opptr*/
1307         else if (m_xptr!=m_clkptr) err_check=10; /*xptr vs clkptr*/
1308         else if ((n_ordclk!=2)&(m_ordclk!=0)) err_check=11; /*sim.ordclk*/
1309         else if ((n_cord!=2)&(m_cord!=0)) err_check=12;     /*sim.cord*/
1310         else if ((n_oord!=2)&(m_oord!=0)) err_check=13;     /*sim.oord*/
1311         else if ((n_zord!=2)&(m_zord!=0)) err_check=14;     /*sim.zord*/
1312         else if ((n_iord!=2)&(m_iord!=0)) err_check=15;     /*sim.iord*/
1313         if (err_check!=0)
1314         {
1315                 /* please write an error table here  */
1316                 Scierror(42,_("%s : error in cross variable size checking : %d\n"),\
1317                         fname,err_check);
1318                 freeparam;
1319                 return 0;
1320         }
1321
1322         /*******************************
1323         * set function table for blocks
1324         *******************************/
1325         il4 = iadr(*Lstk(Top-Rhs+4));  /*sim*/
1326         l4 = sadr(il4+m4+3);
1327         il4e2 = iadr(l4+*istk(il4+3)-1);
1328         l4e2 = sadr(il4e2+nblk+3);
1329         lf = l4e2;  /*first element of the list sim.funs*/
1330         /*define new variable lfunpt*/
1331         if ((lfunpt=(int *) MALLOC(nblk*sizeof(int))) ==NULL )
1332         {
1333                 Scierror(999, _("%s: Memory allocation error.\n"),fname);
1334                 freeparam;
1335                 return 0;
1336         }
1337
1338         /*for each block*/
1339         for (i=0;i<nblk;i++)
1340         {
1341                 ilf=iadr(lf); /*should be removed later*/
1342                 subheader=(int *)(listentry(il_sim_fun,i+1));
1343                 /*Block is defined by a scilab function*/
1344                 if ((subheader[0]==11)|(subheader[0]==13)) lfunpt[i]=-lf;
1345                 /*Block is defined by a function described by a characater strings*/
1346                 else if(subheader[0]==10)
1347                 {
1348                         sz_str=subheader[5]-1; /*store the length of function name*/
1349                         C2F(cha1).buf[0]=' ';
1350                         C2F(cvstr)(&sz_str,&subheader[6],&C2F(cha1).buf[0],(j=1,&j),sz_str); /*codetoascii*/
1351                         C2F(cha1).buf[sz_str]='\0';
1352                         ifun=C2F(funnum)(C2F(cha1).buf); /*search associated function number of function name*/
1353                         /*Block is defined by a C or Fortran function*/
1354                         if (ifun>0) lfunpt[i]=ifun;
1355                         /*Block is defined by a predefined scilab function*/
1356                         else 
1357                         {
1358                                 C2F(namstr)(id,&subheader[6],&sz_str,(j=0,&j));
1359                                 C2F(com).fin=0;
1360                                 C2F(funs)(id);
1361                                 if ((C2F(com).fun==-1)|(C2F(com).fun==-2)) lfunpt[i]=-*Lstk(C2F(com).fin);
1362                                 else
1363                                 {
1364                                         C2F(curblk).kfun=i+1;
1365                                         Scierror(888, _("%s : unknown block : %s\n"),fname,C2F(cha1).buf);
1366                                         FREE(lfunpt);
1367                                         freeparam;
1368                                         return 0;
1369                                 }
1370                         }
1371                 }
1372                 else
1373                 {
1374                         C2F(iop).err=4;
1375                         Scierror(44,_("%s : error\n"),fname);
1376                         FREE(lfunpt);
1377                         freeparam;
1378                         return 0;
1379                 }
1380                 lf=lf+*istk(il4e2+3+i)-*istk(il4e2+i+2);
1381         }
1382
1383         /**********************
1384         * set oz, ozsz, oztyp
1385         **********************/
1386         if (noz==0)
1387         {
1388                 oz=NULL;
1389                 ozsz=NULL;
1390                 oztyp=NULL;
1391         }
1392         else
1393         {
1394                 /*Allocation of oz*/
1395                 if ((oz=(void **) MALLOC((noz)*sizeof(void *))) ==NULL )
1396                 {
1397                         Scierror(999,_("%s: Memory allocation error.\n"),fname);
1398                         FREE(lfunpt);
1399                         freeparam;
1400                         return 0;
1401                 }
1402                 /*Allocation of ozsz*/
1403                 if ((ozsz=(int *) MALLOC(2*(noz)*sizeof(int))) ==NULL )
1404                 {
1405                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
1406                         FREE(oz);
1407                         FREE(lfunpt);
1408                         freeparam;
1409                         return 0;
1410                 }
1411                 /*Allocation of oztyp*/
1412                 if ((oztyp=(int *) MALLOC((noz)*sizeof(int))) ==NULL )
1413                 {
1414                         Scierror(999, _("%s: Memory allocation error.\n"),fname);
1415                         FREE(oz); FREE(ozsz);
1416                         FREE(lfunpt);
1417                         freeparam;
1418                         return 0;
1419                 }
1420
1421                 /*set vectors of oz*/
1422                 for(j=0;j<noz;j++)
1423                 {
1424                         subheader=(int *)(listentry(il_state_oz,j+1));
1425
1426                         switch (subheader[0]) /*store type and address*/
1427                         {
1428                                 /*matrix of double*/
1429                         case 1  : switch (subheader[3])
1430                                           {
1431                         case 0  : oztyp[j]=SCSREAL_N;  /*double real matrix*/
1432                                 ozsz[j]=subheader[1];
1433                                 ozsz[j+noz]=subheader[2];
1434                                 oz[j]=(SCSREAL_COP *)(subheader+4);
1435                                 break;
1436
1437                         case 1  : oztyp[j]=SCSCOMPLEX_N;  /*double complex matrix*/
1438                                 ozsz[j]=subheader[1];
1439                                 ozsz[j+noz]=subheader[2];
1440                                 oz[j]=(SCSCOMPLEX_COP *)(subheader+4);
1441                                 break;
1442
1443                         default : oztyp[j]=SCSUNKNOW_N;
1444                                 ozsz[j]=il_state_oz[3+j]-il_state_oz[2+j];
1445                                 ozsz[j+noz]=1;
1446                                 oz[j]=(SCSUNKNOW_COP *)subheader;
1447                                 break;
1448                                           }
1449                                           break;
1450
1451                                           /*matrix of integers*/
1452                         case 8  : switch (subheader[3])
1453                                           {
1454                         case 1  : oztyp[j]=SCSINT8_N;  /*int8*/
1455                                 ozsz[j]=subheader[1];
1456                                 ozsz[j+noz]=subheader[2];
1457                                 oz[j]=(SCSINT8_COP *)(subheader+4);
1458                                 break;
1459
1460                         case 2  : oztyp[j]=SCSINT16_N;  /*int16*/
1461                                 ozsz[j]=subheader[1];
1462                                 ozsz[j+noz]=subheader[2];
1463                                 oz[j]=(SCSINT16_COP *)(subheader+4);
1464                                 break;
1465
1466                         case 4  : oztyp[j]=SCSINT32_N;  /*int32*/
1467                                 ozsz[j]=subheader[1];
1468                                 ozsz[j+noz]=subheader[2];
1469                                 oz[j]=(SCSINT32_COP *)(subheader+4);
1470                                 break;
1471
1472                         case 11 : oztyp[j]=SCSUINT8_N; /*uint8*/
1473                                 ozsz[j]=subheader[1];
1474                                 ozsz[j+noz]=subheader[2];
1475                                 oz[j]=(SCSUINT8_COP *)(subheader+4);
1476                                 break;
1477
1478                         case 12 : oztyp[j]=SCSUINT16_N; /*uint16*/
1479                                 ozsz[j]=subheader[1];
1480                                 ozsz[j+noz]=subheader[2];
1481                                 oz[j]=(SCSUINT16_COP *)(subheader+4);
1482                                 break;
1483
1484                         case 14 : oztyp[j]=SCSUINT32_N; /*uint32*/
1485                                 ozsz[j]=subheader[1];
1486                                 ozsz[j+noz]=subheader[2];
1487                                 oz[j]=(SCSUINT32_COP *)(subheader+4);
1488                                 break;
1489
1490                         default : oztyp[j]=SCSUNKNOW_N;
1491                                 ozsz[j]=il_state_oz[3+j]-il_state_oz[2+j];
1492                                 ozsz[j+noz]=1;
1493                                 oz[j]=(SCSUNKNOW_COP *)subheader;
1494                                 break;
1495                                           }
1496                                           break;
1497
1498                         default : oztyp[j]=SCSUNKNOW_N;
1499                                 ozsz[j]=il_state_oz[3+j]-il_state_oz[2+j];
1500                                 ozsz[j+noz]=1;
1501                                 oz[j]=(SCSUNKNOW_COP *)subheader;
1502                                 break;
1503                         }
1504                 }
1505         }
1506
1507         /****************************
1508         * set opar, oparsz, opartyp
1509         ****************************/
1510         if (nopar==0)
1511         {
1512                 opar=NULL;
1513                 oparsz=NULL;
1514                 opartyp=NULL;
1515         }
1516         else
1517         {
1518                 /*Allocation of opar*/
1519                 if ((opar=(void **) MALLOC((nopar)*sizeof(void *))) ==NULL )
1520                 {
1521                         Scierror(999,_("%s: Memory allocation error.\n"),fname);
1522                         FREE(oz); FREE(ozsz); FREE(oztyp);
1523                         FREE(lfunpt);
1524                         freeparam;
1525                         return 0;
1526                 }
1527                 /*Allocation of oparsz*/
1528                 if ((oparsz=(int *) MALLOC(2*(nopar)*sizeof(int))) ==NULL )
1529                 {
1530                         Scierror(999,_("%s: Memory allocation error.\n"),fname);
1531                         FREE(opar);
1532                         FREE(oz); FREE(ozsz); FREE(oztyp);
1533                         FREE(lfunpt);
1534                         freeparam;
1535                         return 0;
1536                 }
1537                 /*Allocation of opartyp*/
1538                 if ((opartyp=(int *) MALLOC((nopar)*sizeof(int))) ==NULL )
1539                 {
1540                         Scierror(999,_("%s: Memory allocation error.\n"),fname);
1541                         FREE(opar); FREE(oparsz);
1542                         FREE(oz); FREE(ozsz); FREE(oztyp);
1543                         FREE(lfunpt);
1544                         freeparam;
1545                         return 0;
1546                 }
1547
1548                 /*set vectors of opar*/
1549                 for(j=0;j<nopar;j++)
1550                 {
1551                         subheader=(int *)(listentry(il_sim_opar,j+1));
1552
1553                         switch (subheader[0]) /*store type and address*/
1554                         {
1555                                 /*matrix of double*/
1556                         case 1  : switch (subheader[3])
1557                                           {
1558                         case 0  : opartyp[j]=SCSREAL_N;  /*double real matrix*/
1559                                 oparsz[j]=subheader[1];
1560                                 oparsz[j+nopar]=subheader[2];
1561                                 opar[j]=(SCSREAL_COP *)(subheader+4);
1562                                 break;
1563
1564                         case 1  : opartyp[j]=SCSCOMPLEX_N;  /*double complex matrix*/
1565                                 oparsz[j]=subheader[1];
1566                                 oparsz[j+nopar]=subheader[2];
1567                                 opar[j]=(SCSCOMPLEX_COP *)(subheader+4);
1568                                 break;
1569
1570                         default : opartyp[j]=SCSUNKNOW_N;
1571                                 oparsz[j]=il_sim_opar[3+j]-il_sim_opar[2+j];
1572                                 oparsz[j+nopar]=1;
1573                                 opar[j]=(SCSUNKNOW_COP *)subheader;
1574                                 break;
1575                                           }
1576                                           break;
1577
1578                                           /*matrix of integers*/
1579                         case 8  : switch (subheader[3])
1580                                           {
1581                         case 1  : opartyp[j]=SCSINT8_N;  /*int8*/
1582                                 oparsz[j]=subheader[1];
1583                                 oparsz[j+nopar]=subheader[2];
1584                                 opar[j]=(SCSINT8_COP *)(subheader+4);
1585                                 break;
1586
1587                         case 2  : opartyp[j]=SCSINT16_N;  /*int16*/
1588                                 oparsz[j]=subheader[1];
1589                                 oparsz[j+nopar]=subheader[2];
1590                                 opar[j]=(SCSINT16_COP *)(subheader+4);
1591                                 break;
1592
1593                         case 4  : opartyp[j]=SCSINT32_N;  /*int32*/
1594                                 oparsz[j]=subheader[1];
1595                                 oparsz[j+nopar]=subheader[2];
1596                                 opar[j]=(SCSINT32_COP *)(subheader+4);
1597                                 break;
1598
1599                         case 11 : opartyp[j]=SCSUINT8_N; /*uint8*/
1600                                 oparsz[j]=subheader[1];
1601                                 oparsz[j+nopar]=subheader[2];
1602                                 opar[j]=(SCSUINT8_COP *)(subheader+4);
1603                                 break;
1604
1605                         case 12 : opartyp[j]=SCSUINT16_N; /*uint16*/
1606                                 oparsz[j]=subheader[1];
1607                                 oparsz[j+nopar]=subheader[2];
1608                                 opar[j]=(SCSUINT16_COP *)(subheader+4);
1609                                 break;
1610
1611                         case 14 : opartyp[j]=SCSUINT32_N; /*uint32*/
1612                                 oparsz[j]=subheader[1];
1613                                 oparsz[j+nopar]=subheader[2];
1614                                 opar[j]=(SCSUINT32_COP *)(subheader+4);
1615                                 break;
1616
1617                         default : opartyp[j]=SCSUNKNOW_N;
1618                                 oparsz[j]=il_sim_opar[3+j]-il_sim_opar[2+j];
1619                                 oparsz[j+nopar]=1;
1620                                 opar[j]=(SCSUNKNOW_COP *)subheader;
1621                                 break;
1622                                           }
1623                                           break;
1624
1625                         default : opartyp[j]=SCSUNKNOW_N;
1626                                 oparsz[j]=il_sim_opar[3+j]-il_sim_opar[2+j];
1627                                 oparsz[j+nopar]=1;
1628                                 opar[j]=(SCSUNKNOW_COP *)subheader;
1629                                 break;
1630                         }
1631                 }
1632         }
1633
1634         /*******************************
1635         * set outtbptr,outtbsz,outtbtyp
1636         *******************************/
1637         if (nlnk==0)
1638         {
1639                 outtbptr=NULL;
1640                 outtbsz=NULL;
1641                 outtbtyp=NULL;
1642                 outtb_elem=NULL;
1643                 nelem=0;
1644         }
1645         else
1646         {
1647                 /*Allocation of outtbptr*/
1648                 if ((outtbptr=(void **) MALLOC(nlnk*sizeof(void *)))==NULL )
1649                 {
1650                         Scierror(999,_("%s: Memory allocation error.\n"),fname);
1651                         FREE(opar); FREE(oparsz); FREE(opartyp);
1652                         FREE(oz); FREE(ozsz); FREE(oztyp);
1653                         FREE(lfunpt);
1654                         freeparam;
1655                         return 0;
1656                 }
1657                 /*Allocation of outtbsz*/
1658                 if ((outtbsz=(int *) MALLOC(nlnk*2*sizeof(int)))==NULL )
1659                 {
1660                         Scierror(999,_("%s: Memory allocation error.\n"),fname);
1661                         FREE(outtbptr);
1662                         FREE(opar); FREE(oparsz); FREE(opartyp);
1663                         FREE(oz); FREE(ozsz); FREE(oztyp);
1664                         FREE(lfunpt);
1665                         freeparam;
1666                         return 0;
1667                 }
1668                 /*Allocation of outtbtyp*/
1669                 if ((outtbtyp=(int *) MALLOC(nlnk*sizeof(int)))==NULL )
1670                 {
1671                         Scierror(999,_("%s: Memory allocation error.\n"),fname);
1672                         FREE(outtbsz); FREE(outtbptr);
1673                         FREE(opar); FREE(oparsz); FREE(opartyp);
1674                         FREE(oz); FREE(ozsz); FREE(oztyp);
1675                         FREE(lfunpt);
1676                         freeparam;
1677                         return 0;
1678                 }
1679
1680                 /*initalize nelem*/
1681                 nelem=0;
1682
1683                 /*set vectors of outtb*/
1684                 for (j=0;j<nlnk;j++) /*for each link*/
1685                 {
1686                         subheader=(int *)(listentry(il_state_outtb,j+1)); /*get header of outtbl(j+1)*/
1687                         outtbsz[j]=subheader[1]; /*store dimensions*/
1688                         outtbsz[j+nlnk]=subheader[2];
1689
1690                         switch (subheader[0]) /*store type and address*/
1691                         {
1692                                 /*matrix of double*/
1693                         case 1  : switch (subheader[3])
1694                                           {
1695                         case 0  : outtbtyp[j]=SCSREAL_N;  /*double real matrix*/
1696                                 outtbptr[j]=(SCSREAL_COP *)(subheader+4);
1697                                 break;
1698
1699                         case 1  : outtbtyp[j]=SCSCOMPLEX_N;  /*double complex matrix*/
1700                                 outtbptr[j]=(SCSCOMPLEX_COP *)(subheader+4);
1701                                 break;
1702
1703                         default : Scierror(888,_("%s : error. Type %d of double scalar matrix not yet supported for outtb.\n"),\
1704                                                   fname,subheader[3]);
1705                                 FREE(outtbptr); FREE(outtbtyp); FREE(outtbsz);
1706                                 FREE(opar); FREE(oparsz); FREE(opartyp);
1707                                 FREE(oz); FREE(ozsz); FREE(oztyp);
1708                                 FREE(lfunpt);
1709                                 freeparam;
1710                                 FREE(outtb_elem);
1711                                 break;
1712                                           }
1713                                           break;
1714
1715                                           /*matrix of integers*/
1716                         case 8  : switch (subheader[3])
1717                                           {
1718                         case 1  : outtbtyp[j]=SCSINT8_N;  /*int8*/
1719                                 outtbptr[j]=(SCSINT8_COP *)(subheader+4);
1720                                 break;
1721
1722                         case 2  : outtbtyp[j]=SCSINT16_N;  /*int16*/
1723                                 outtbptr[j]=(SCSINT16_COP *)(subheader+4);
1724                                 break;
1725
1726                         case 4  : outtbtyp[j]=SCSINT32_N;  /*int32*/
1727                                 outtbptr[j]=(SCSINT32_COP *)(subheader+4);
1728                                 break;
1729
1730                         case 11 : outtbtyp[j]=SCSUINT8_N; /*uint8*/
1731                                 outtbptr[j]=(SCSUINT8_COP *)(subheader+4);
1732                                 break;
1733
1734                         case 12 : outtbtyp[j]=SCSUINT16_N; /*uint16*/
1735                                 outtbptr[j]=(SCSUINT16_COP *)(subheader+4);
1736                                 break;
1737
1738                         case 14 : outtbtyp[j]=SCSUINT32_N; /*uint32*/
1739                                 outtbptr[j]=(SCSUINT32_COP *)(subheader+4);
1740                                 break;
1741
1742                         default : Scierror(888,\
1743                                                   _("%s : error. Type %d of int scalar matrix not yet supported for outtb.\n"),\
1744                                                   fname,subheader[3]);
1745                                 FREE(outtbptr); FREE(outtbtyp); FREE(outtbsz);
1746                                 FREE(opar); FREE(oparsz); FREE(opartyp);
1747                                 FREE(oz); FREE(ozsz); FREE(oztyp);
1748                                 FREE(lfunpt);
1749                                 freeparam;
1750                                 FREE(outtb_elem);
1751                                 break;
1752                                           }
1753                                           break;
1754
1755                         default : Scierror(888,_("%s : error. Type %d not yet supported for outtb.\n"),fname,subheader[0]);
1756                                 FREE(outtbptr); FREE(outtbtyp); FREE(outtbsz);
1757                                 FREE(opar); FREE(oparsz); FREE(opartyp);
1758                                 FREE(oz); FREE(ozsz); FREE(oztyp);
1759                                 FREE(lfunpt);
1760                                 freeparam;
1761                                 FREE(outtb_elem);
1762                                 return 0;
1763                                 break;
1764                         }
1765
1766                         /* store lnk and pos in outtb_elem */
1767                         k=nelem;
1768                         nelem+=outtbsz[j]*outtbsz[j+nlnk];
1769                         if ((outtb_elem=(outtb_el *) REALLOC(outtb_elem,nelem*sizeof(outtb_el)))==NULL)
1770                         {
1771                                 Scierror(999,_("%s : No more free memory.\n"),fname);
1772                                 FREE(outtbptr); FREE(outtbtyp); FREE(outtbsz);
1773                                 FREE(opar); FREE(oparsz); FREE(opartyp);
1774                                 FREE(oz); FREE(ozsz); FREE(oztyp);
1775                                 FREE(lfunpt);
1776                                 freeparam;
1777                                 FREE(outtb_elem);
1778                                 return 0;
1779                         }
1780                         for (i=0;i<outtbsz[j]*outtbsz[j+nlnk];i++)
1781                         {
1782                                 outtb_elem[k+i].lnk=j;
1783                                 outtb_elem[k+i].pos=i;
1784                         }
1785                 }
1786         }
1787
1788         /********************************
1789         * save intersci common
1790         * see intersci_push in stack2.c
1791         ********************************/
1792         Nbvars = Rhs; /*because of the use of getdata*/
1793         new = MALLOC(Rhs*sizeof(intersci_state));
1794         if (new == NULL)
1795         {
1796                 Scierror(999,_("%s: Memory allocation error.\n"),fname);
1797                 FREE(outtbptr); FREE(outtbtyp); FREE(outtbsz);
1798                 FREE(opar); FREE(oparsz); FREE(opartyp);
1799                 FREE(oz); FREE(ozsz); FREE(oztyp);
1800                 FREE(lfunpt);
1801                 FREE(outtb_elem);
1802                 freeparam;
1803                 return 0;
1804         }
1805         loc = MALLOC(sizeof(intersci_list));
1806         if (loc == NULL)
1807         {
1808                 Scierror(999,_("%s: Memory allocation error.\n"),fname);
1809                 FREE(outtbptr); FREE(outtbtyp); FREE(outtbsz);
1810                 FREE(opar); FREE(oparsz); FREE(opartyp);
1811                 FREE(oz); FREE(ozsz); FREE(oztyp);
1812                 FREE(lfunpt);
1813                 FREE(outtb_elem);
1814                 FREE(new);
1815                 freeparam;
1816                 return 0;
1817         }
1818         loc->state = new; 
1819         loc->nbvars = Nbvars;
1820         for (i=0;i<Rhs;i++)
1821         {
1822                 loc->state[i].iwhere = C2F(intersci).iwhere[i];
1823                 loc->state[i].ntypes = C2F(intersci).ntypes[i];
1824                 loc->state[i].lad    = C2F(intersci).lad[i];
1825                 loc->state[i].lhsvar = C2F(intersci).lhsvar[i];
1826         }
1827
1828         /************************
1829         * call scicos simulator
1830         ************************/
1831         if (C2F(iop).ddt!=0) C2F(dbcos).idb=1;   /*debug mode if ddt=0*/
1832         C2F(cosim).isrun=1;  /*set isrun=1 to say that we enter in the simulator*/
1833
1834         /* Calling sequence :
1835         * int C2F(scicos)(double *x_in, int *xptr_in, double *z__,
1836         *                 void **work,int *zptr,int *modptr_in,
1837         *                 void **oz,int *ozsz,int *oztyp,int *ozptr,
1838         *                 int *iz,int *izptr,double *t0_in,
1839         *                 double *tf_in,double *tevts_in,int *evtspt_in,
1840         *                 int *nevts,int *pointi_in,void **outtbptr_in,
1841         *                 int *outtbsz_in,int *outtbtyp_in,
1842         *                 outtb_el *outtb_elem_in,int *nelem1,int *nlnk1,
1843         *                 int *funptr,int *funtyp_in,int *inpptr_in,
1844         *                 int *outptr_in, int *inplnk_in,int *outlnk_in,
1845         *                 double *rpar,int *rpptr,int *ipar,int *ipptr,
1846         *                 void **opar,int *oparsz,int *opartyp,int *opptr,
1847         *                 int *clkptr_in,int *ordptr_in,int *nordptr1,
1848         *                 int *ordclk_in,int *cord_in,int *ncord1,
1849         *                 int *iord_in,int *niord1,int *oord_in,
1850         *                 int *noord1,int *zord_in,int *nzord1,
1851         *                 int *critev_in,int *nblk1,int *ztyp,
1852         *                 int *zcptr_in,int *subscr,int *nsubs,
1853         *                 double *simpar,int *flag__,int *ierr_out)
1854         */
1855
1856         C2F(scicos)(l_state_x,l_sim_xptr,l_state_z,
1857                 l_state_iz,l_sim_zptr,l_sim_modptr,
1858                 oz,ozsz,oztyp,l_sim_ozptr,
1859                 l_sim_lab,il_sim_labptr,l_tcur,
1860                 l_tf,l_state_tevts,l_state_evtspt,
1861                 &m1e5,l_pointi,outtbptr,
1862                 outtbsz,outtbtyp,
1863                 outtb_elem,&nelem,&nlnk,
1864                 lfunpt,l_sim_funtyp,l_sim_inpptr,
1865                 l_sim_outptr,l_sim_inplnk,l_sim_outlnk,
1866                 l_sim_rpar,l_sim_rpptr,l_sim_ipar,l_sim_ipptr,
1867                 opar,oparsz,opartyp,l_sim_opptr,
1868                 l_sim_clkptr,l_sim_ordptr,&m_ordptr,
1869                 l_sim_ordclk,l_sim_cord,&m_cord,
1870                 l_sim_iord,&m_iord,l_sim_oord,
1871                 &m_oord,l_sim_zord, &m_zord,
1872                 l_sim_critev,&nblk,l_sim_ztyp,
1873                 l_sim_zcptr,l_sim_subscr,&m_subscr,
1874                 simpar,&flag,&ierr);
1875
1876         C2F(dbcos).idb=0;  /*return in normal mode*/
1877         C2F(cosim).isrun=0;  /*return in normal mode*/
1878
1879         /******************************
1880         * retrieve intersci common
1881         * see intersci_pop in stack2.c
1882         ******************************/
1883         Nbvars = loc->nbvars;
1884         for (i=0;i<Rhs;i++)
1885         {
1886                 C2F(intersci).iwhere[i] = loc->state[i].iwhere ;
1887                 C2F(intersci).ntypes[i] = loc->state[i].ntypes ;
1888                 C2F(intersci).lad[i]    = loc->state[i].lad    ;
1889                 C2F(intersci).lhsvar[i] = loc->state[i].lhsvar ;
1890         }
1891         FREE(loc->state);
1892         FREE(loc);
1893
1894         /**********************
1895         * Free allocated array
1896         **********************/
1897         FREE(outtbptr); FREE(outtbtyp); FREE(outtbsz);
1898         FREE(opar); FREE(oparsz); FREE(opartyp);
1899         FREE(oz); FREE(ozsz); FREE(oztyp);
1900         FREE(lfunpt);
1901         FREE(outtb_elem);
1902
1903         /*************************************
1904         * switch to appropriate message error
1905         *************************************/
1906         if (ierr>0)
1907         {
1908                 switch (ierr)
1909                 {
1910                 case 1  : strcpy(C2F(cha1).buf,_("scheduling problem"));
1911                         C2F(curblk).kfun=0;
1912                         break;
1913
1914                 case 2  : strcpy(C2F(cha1).buf,_("input to zero-crossing stuck on zero"));
1915                         C2F(curblk).kfun=0;
1916                         break;
1917
1918                 case 3  : strcpy(C2F(cha1).buf,_("event conflict"));
1919                         C2F(curblk).kfun=0;
1920                         break;
1921
1922                 case 4  : strcpy(C2F(cha1).buf,_("algebraic loop detected"));
1923                         C2F(curblk).kfun=0;
1924                         break;
1925
1926                 case 5  : strcpy(C2F(cha1).buf,_("cannot allocate memory"));
1927                         C2F(curblk).kfun=0;
1928                         break;
1929
1930                 case 6  : sprintf(C2F(cha1).buf,_("the block %d has been called with input out of its domain"),C2F(curblk).kfun);
1931                         break;
1932
1933                 case 7  : strcpy(C2F(cha1).buf,_("singularity in a block"));
1934                         break;
1935
1936                 case 8  : strcpy(C2F(cha1).buf,_("block produces an internal error"));
1937                         break;
1938
1939                 case 10  : strcpy(C2F(cha1).buf,coserr.buf);
1940                         break;
1941
1942                 case 20  : strcpy(C2F(cha1).buf,_("initial conditions not converging"));
1943                         break;
1944
1945                 case 21  : sprintf(C2F(cha1).buf,_("cannot allocate memory in block=%d"),C2F(curblk).kfun);
1946                         break;
1947
1948                 case 22  : strcpy(C2F(cha1).buf,_("sliding mode condition, cannot integrate"));
1949                         break;
1950
1951                 case 23  : strcpy(C2F(cha1).buf,_("Cannot find the initial mode, maybe there is a sliding mode condition"));
1952                         break;
1953                 case 24  : strcpy(C2F(cha1).buf,_("You have changed a parameter in your model, but the model has been compiled to use an XML file containing initial values and parameters. So you should either recompile your Scicos diagram or [re]launch the initialization interface to regenerate the XML file  with new parameters."));
1954                         break;
1955
1956                 case 25  : strcpy(C2F(cha1).buf,_("Undefined data type."));
1957                         break;
1958                 case 26  : strcpy(C2F(cha1).buf,_("The number of parameter provided by Scicos blocks is different from what expected by the code generated by the Modelica compiler. You might have relaxed a parameter using FIXED property (i.e., fixed=false) in a Modelica model. This will be corrected in the next version"));
1959                         break;
1960                         /*In this case, you need to turn off the parameter embedded code generation mode by setting Modelica_ParEmb=%f in the Scilab command window, and  recompile the Scicos diagram*/
1961                         /* IDA error messages*/
1962                 case 201  : strcpy(C2F(cha1).buf,_("IDA_MEM_NULL:The argument ida_mem was NULL"));
1963                         break;
1964
1965                 case 202  : strcpy(C2F(cha1).buf,_("IDA_ILL_INPUT: One of the input arguments was illegal. This errors message may be returned if the linear solver function initialization (called by the user after calling IDACreate) failed to set the linear solver-specific lsolve field in ida_mem."));
1966                         break;
1967
1968                 case 203  : strcpy(C2F(cha1).buf,_("IDA_NO_MALLOC: indicating that ida_mem was not allocated."));
1969                         break;
1970
1971                 case 204  : strcpy(C2F(cha1).buf,_("IDA_TOO_MUCH_WORK: The solver took mxstep internal steps but could not reach tout. The default value for mxstep is MXSTEP_DEFAULT = 500."));
1972                         break;
1973
1974                 case 205  : strcpy(C2F(cha1).buf,_("IDA_TOO_MUCH_ACC: The solver could not satisfy the accuracy demanded by the user for some internal step."));
1975                         break;
1976
1977                 case 206  : strcpy(C2F(cha1).buf,_("IDA_ERR_FAIL: Error test failures occurred too many times (=MXETF = 10) during one internal step or occurred with |h|=h_min"));
1978                         break;
1979
1980                 case 207  : strcpy(C2F(cha1).buf,_("IDA_CONV_FAIL: IDACalcIC->Failed to get convergence of the Newton iterations. or IDA_solve->Convergence test failures occurred too many times (= MXNCF = 10) during one internal step. "));
1981                         break;
1982
1983                 case 208  : strcpy(C2F(cha1).buf,_("IDA_LINIT_FAIL: The linear solver''s initialization routine failed."));
1984                         break;
1985
1986                 case 209  : strcpy(C2F(cha1).buf,_("IDA_LSETUP_FAIL: The linear solver''s setup routine had a non-recoverable error."));
1987                         break;
1988
1989                 case 210  : strcpy(C2F(cha1).buf,_("IDA_LSOLVE_FAIL: The linear solver''s solve routine had a non-recoverable error."));
1990                         break;
1991
1992                 case 211  : strcpy(C2F(cha1).buf,_("IDA_RES_FAIL: The user''s residual routine returned a non-recoverable error flag."));
1993                         break;
1994
1995                 case 212  : strcpy(C2F(cha1).buf,_("IDA_CONSTR_FAIL: IDACalcIC was unable to find a solution satisfying the inequality constraints."));
1996                         break;
1997
1998                 case 213  : strcpy(C2F(cha1).buf,_("IDA_REP_RES_ERR: The user''s residual function repeatedly returned a recoverable error flag, but the solver was unable to recover."));
1999                         break;
2000
2001                 case 214  : strcpy(C2F(cha1).buf,_("IDA_MEM_FAIL: A memory allocation failed."));
2002                         break;
2003
2004                 case 215  : strcpy(C2F(cha1).buf,_("IDA_BAD_T: t is not in the interval [tn-hu,tn]."));
2005                         break;
2006
2007                 case 216  : strcpy(C2F(cha1).buf,_("IDA_BAD_EWT: Some component of the error weight vector is zero (illegal), either for the input value of y0 or a corrected value."));
2008                         break;
2009
2010                 case 217  : strcpy(C2F(cha1).buf,_("IDA_FIRST_RES_FAIL: The user''s residual routine returned  a recoverable error flag on the first call, but IDACalcIC was unable to recover."));
2011                         break;
2012
2013                 case 218  : strcpy(C2F(cha1).buf,_("IDA_LINESEARCH_FAIL: The Linesearch algorithm failed to find a solution with a step larger than steptol in weighted RMS norm."));
2014                         break;
2015
2016                 case 219  : strcpy(C2F(cha1).buf,_("IDA_NO_RECOVERY: The user''s residual routine, or the linear solver''s setup or solve routine had a  recoverable error, but IDACalcIC was unable to recover."));
2017                         break;
2018
2019                 case 220  : strcpy(C2F(cha1).buf,_("IDA_RTFUNC_FAIL: The root founding function failed."));
2020                         break;
2021
2022                 case 228  : strcpy(C2F(cha1).buf,_("IDA_YOUT_NULL: ''yout'' = NULL illegal."));
2023                         break;
2024                 case 229  : strcpy(C2F(cha1).buf,_("IDA_TRET_NULL: ''tret'' = NULL illegal."));
2025                         break;
2026                 case 230  : strcpy(C2F(cha1).buf,_("IDA_BAD_ITASK: Illegal value for itask."));
2027                         break;
2028                 case 231  : strcpy(C2F(cha1).buf,_("IDA_NO_ESTOP: itask = IDA_NORMAL_TSTOP or itask = IDA_ONE_STEP_TSTOP but tstop was not set"));
2029                         break;
2030                 case 232  : strcpy(C2F(cha1).buf,_("IDA_BAD_H0: h0 and tout - t0 inconsistent."));
2031                         break;
2032                 case 233  : strcpy(C2F(cha1).buf,_("IDA_BAD_TSTOP: tstop is behind current simulation time in the direction of integration."));
2033                         break;
2034                 case 234  : strcpy(C2F(cha1).buf,_("IDA_BAD_INIT_ROOT: Root found at and very near initial t."));
2035                         break;
2036                 case 235  : strcpy(C2F(cha1).buf,_("IDA_NO_EFUN: itol = IDA_WF but no EwtSet function was provided."));
2037                         break;
2038                 case 236  : strcpy(C2F(cha1).buf,_("IDA_EWT_FAIL: The user-provide EwtSet function failed."));
2039                         break;
2040                 case 237  : strcpy(C2F(cha1).buf,_("IDACalc cannot find the initial condition at this point. If you are using a Modelica model, you can try with the initialization GUI to try with other nonlinear solvers.")); 
2041                         break;
2042                 case 238  : strcpy(C2F(cha1).buf,_("IDA_LSOLVE_NULL: The linear solver''s solve routine is NULL."));
2043                         break;
2044                 case 239  : strcpy(C2F(cha1).buf,_("IDA_NULL_Y0: y0 = NULL illegal."));
2045                         break;
2046                 case 240  : strcpy(C2F(cha1).buf,_("IDA_BAD_ITOL: Illegal value for itol. The legal values are IDA_SS, IDA_SV, and IDA_WF."));
2047                         break;
2048                 case 241  : strcpy(C2F(cha1).buf,_("IDA_NULL_F: user supplied ODE routine is (NULL) illegal."));
2049                         break;
2050                 case 242  : strcpy(C2F(cha1).buf,_("IDA_BAD_NVECTOR: A required vector operation is not implemented."));
2051                         break;
2052                 case 243  : strcpy(C2F(cha1).buf,_("IDA_NULL_ABSTOL: absolute tolerances is = NULL illegal."));
2053                         break;
2054                 case 244  : strcpy(C2F(cha1).buf,_("IDA_BAD_RELTOL: relative tolerances is reltol < 0 illegal."));
2055                         break;
2056                 case 245  : strcpy(C2F(cha1).buf,_("IDA_BAD_ABSTOL: abstol has negative component(s) (illegal)."));
2057                         break;
2058                 case 246  : strcpy(C2F(cha1).buf,_("IDA_NULL_G: user supplied zero-crossing routine is (NULL) illegal."));
2059                         break;
2060                 case 247  : strcpy(C2F(cha1).buf,_("IDA_BAD_TOUT: Trouble interpolating. ''tout'' too far back in direction of integration"));
2061                         break;
2062                 case 248  : strcpy(C2F(cha1).buf,_("IDA_YP0_NULL: the derivative yp0 = NULL is illegal."));
2063                         break;
2064                 case 249  : strcpy(C2F(cha1).buf,_("IDA_RES_NULL: the returned residual res = NULL is illegal."));
2065                         break;
2066                 case 250  : strcpy(C2F(cha1).buf,_("IDA_YRET_NULL: yret = NULL illegal.."));
2067                         break;
2068                 case 251  : strcpy(C2F(cha1).buf,_("IDA_YPRET_NULL: yret = NULL illegal.."));
2069                         break;
2070                 case 252  : strcpy(C2F(cha1).buf,_("IDA_BAD_HINIT: yret = NULL illegal.."));
2071                         break;
2072                 case 253  : strcpy(C2F(cha1).buf,_("IDA_MISSING_ID :id = NULL (''id'' defines algebraic and differential states) but suppressalg option on."));
2073                         break;
2074                 case 254  : strcpy(C2F(cha1).buf,_("IDA_Y0_FAIL_CONSTR: y0 fails to satisfy constraints."));
2075                         break;
2076                 case 255  : strcpy(C2F(cha1).buf,_("IDA_TOO_CLOSE: ''tout'' too close to ''t0'' to start integration."));
2077                         break;
2078                 case 256  : strcpy(C2F(cha1).buf,_("IDA_CLOSE_ROOTS: Root found at and very near starting time."));
2079                         break;
2080                 case 257  : strcpy(C2F(cha1).buf,_("IDA_Residual_NAN: The residual function returns NAN."));
2081                         break;
2082                 case 258  : strcpy(C2F(cha1).buf,_("IDA_Rootfunction_NAN: The Root function returns NAN."));
2083                         break;
2084
2085                         /* CVODE error messages*/
2086                 case 301  : strcpy(C2F(cha1).buf,_("CV_TOO_MUCH_WORK: The solver took mxstep internal steps but could not reach ''tout''. The default value for mxstep is MXSTEP_DEFAULT = 500."));
2087                         break;
2088
2089                 case 302  : strcpy(C2F(cha1).buf,_("CV_TOO_MUCH_ACC: The solver could not satisfy the accuracy demanded by the user for some internal step"));
2090                         break;
2091
2092                 case 303  : strcpy(C2F(cha1).buf,_("CV_ERR_FAILURE: Error test failures occurred too many times (=MXETF = 7) during one internal step or occurred with |h|=h_min "));
2093                         break;
2094
2095                 case 304  : strcpy(C2F(cha1).buf,_("CV_CONV_FAILURE: Convergence test failures occurred too many times (= MXNCF = 10) during one internal time step or occurred with |h| = hmin."));
2096                         break;
2097
2098                 case 305  : strcpy(C2F(cha1).buf,_("CV_LINIT_FAIL: The linear solver''s initialization function failed."));
2099                         break;
2100
2101                 case 306  : strcpy(C2F(cha1).buf,_("CV_LSETUP_FAIL: The linear solver''s setup routine failed in an unrecoverable manner."));
2102                         break;
2103
2104                 case 307  : strcpy(C2F(cha1).buf,_("CV_LSOLVE_FAIL: The linear solver''s solve routine failed in an unrecoverable manner."));
2105                         break;
2106
2107                 case 308  : strcpy(C2F(cha1).buf,_("CV_RHSFUNC_FAIL: The right-hand side function (user supplied ODE) failed in an unrecoverable manner"));
2108                         break;
2109
2110                 case 309  : strcpy(C2F(cha1).buf,_("CV_FIRST_RHSFUNC_ERR: The right-hand side function (user supplied ODE) had a recoverable error at the first call"));
2111                         break;
2112
2113                 case 310  : strcpy(C2F(cha1).buf,_("CV_REPTD_RHSFUNC_ERR: Convergence tests occurred too many times due to repeated recoverable errors in the right-hand side function (user supplied ODE). This error may be raised due to repeated  recoverable errors during the estimation of an initial step size."));
2114                         break;
2115
2116                 case 311  : strcpy(C2F(cha1).buf,_("CV_UNREC_RHSFUNC_ERR: The right-hand side function (user supplied ODE) had a recoverable error, but no recovery was possible."));
2117                         break;
2118                 case 312  : strcpy(C2F(cha1).buf,_("CV_RTFUNC_FAIL: The root finding routine failed in an unrecoverable manner."));
2119                         break;
2120                 case 320  : strcpy(C2F(cha1).buf,_("CV_MEM_FAIL: a memory allocation failed, including an attempt to increase maxord"));
2121                         break;
2122                 case 321  : strcpy(C2F(cha1).buf,_("CV_MEM_NULL: the cvode memory was NULL"));
2123                         break;
2124                 case 322  : strcpy(C2F(cha1).buf,_("CV_ILL_INPUT: indicating an input argument was illegal. This include the situation where a component of the error weight vector becomes negative during internal time-stepping. This also includes if the linear solver function initialization (called by the user after calling CVodeCreat) failed to set the linear solver-specific ''lsolve'' field in cvode_mem. This error happens if number of root functions is positive but the return surface value is NULL. "));
2125                         break;
2126                 case 323  : strcpy(C2F(cha1).buf,_("CV_NO_MALLOC: indicating that cvode_mem has not been allocated (i.e., CVodeMalloc has not been called)."));
2127                         break;
2128                 case 324  : strcpy(C2F(cha1).buf,_("CV_BAD_K: k (the order of the derivative of y to be computed) is not in the range 0, 1, ..., qu, where qu is the order last used"));
2129                         break;
2130                 case 325  : strcpy(C2F(cha1).buf,_("CV_BAD_T: t is not in the interval [tn-hu,tn]."));
2131                         break;
2132                 case 326  : strcpy(C2F(cha1).buf,_("CV_BAD_DKY:  The dky argument was NULL. dky is the output derivative vector [((d/dt)^k)y](t)."));
2133                         break;
2134                 case 327  : strcpy(C2F(cha1).buf,_("CV_TOO_CLOSE: ''tout'' too close to ''t0'' to start integration."));
2135                         break;
2136                 case 328  : strcpy(C2F(cha1).buf,_("CV_YOUT_NULL: ''yout'' = NULL illegal."));
2137                         break;
2138                 case 329  : strcpy(C2F(cha1).buf,_("CV_TRET_NULL: ''tret'' = NULL illegal."));
2139                         break;
2140                 case 330  : strcpy(C2F(cha1).buf,_("CV_BAD_ITASK: Illegal value for itask."));
2141                         break;
2142                 case 331  : strcpy(C2F(cha1).buf,_("CV_NO_ESTOP: itask = CV_NORMAL_TSTOP or itask = CV_ONE_STEP_TSTOP but tstop was not set"));
2143                         break;
2144                 case 332  : strcpy(C2F(cha1).buf,_("CV_BAD_H0: h0 and tout - t0 inconsistent."));
2145                         break;
2146                 case 333  : strcpy(C2F(cha1).buf,_("CV_BAD_TSTOP: tstop is behind current simulation time in the direction of integration."));
2147                         break;
2148                 case 334  : strcpy(C2F(cha1).buf,_("CV_BAD_INIT_ROOT: Root found at and very near initial t."));
2149                         break;
2150                 case 335  : strcpy(C2F(cha1).buf,_("CV_NO_EFUN: itol = CV_WF but no EwtSet function was provided."));
2151                         break;
2152                 case 336  : strcpy(C2F(cha1).buf,_("CV_EWT_FAIL: The user-provide EwtSet function failed."));
2153                         break;
2154                 case 337  : strcpy(C2F(cha1).buf,_("CV_BAD_EWT: Initial ewt has component(s) equal to zero (illegal)."));
2155                         break;
2156                 case 338  : strcpy(C2F(cha1).buf,_("CV_LSOLVE_NULL: The linear solver''s solve routine is NULL."));
2157                         break;
2158                 case 339  : strcpy(C2F(cha1).buf,_("CV_NULL_Y0: y0 = NULL illegal."));
2159                         break;
2160                 case 340  : strcpy(C2F(cha1).buf,_("CV_BAD_ITOL: Illegal value for itol. The legal values are CV_SS, CV_SV, and CV_WF."));
2161                         break;
2162                 case 341  : strcpy(C2F(cha1).buf,_("CV_NULL_F: user supplied ODE routine is (NULL) illegal."));
2163                         break;
2164                 case 342  : strcpy(C2F(cha1).buf,_("CV_BAD_NVECTOR: A required vector operation is not implemented."));
2165                         break;
2166                 case 343  : strcpy(C2F(cha1).buf,_("CV_NULL_ABSTOL: absolute tolerances is = NULL illegal."));
2167                         break;
2168                 case 344  : strcpy(C2F(cha1).buf,_("CV_BAD_RELTOL: relative tolerances is reltol < 0 illegal."));
2169                         break;
2170                 case 345  : strcpy(C2F(cha1).buf,_("CV_BAD_ABSTOL: abstol has negative component(s) (illegal)."));
2171                         break;
2172                 case 346  : strcpy(C2F(cha1).buf,_("CV_NULL_G: user supplied zero-crossing routine is (NULL) illegal."));
2173                         break;
2174                 case 347  : strcpy(C2F(cha1).buf,_("CV_BAD_TOUT: Trouble interpolating. ''tout'' too far back in direction of integration"));
2175                         break;
2176                 case 348  : strcpy(C2F(cha1).buf,_("CV_CLOSE_ROOTS: Root found at and very near starting time."));
2177                         break;
2178                 case 349  : strcpy(C2F(cha1).buf,_("CV_Derivative_NAN: The Derivatives returned by blocks are NAN."));
2179                         break;
2180                 case 350  : strcpy(C2F(cha1).buf,_("CV_Rootfunction_NAN: The Root function returns NAN."));
2181                         break;
2182                 case 401  : strcpy(C2F(cha1).buf,_("KIN_MEM_NULL: An error in the memory allocation in KINCreate or KINMalloc."));
2183                         break;
2184                 case 402  : strcpy(C2F(cha1).buf,_("KIN_ILL_INPUT: A supplied parameter is invalid (check error message)."));
2185                         break;
2186                 case 403  : strcpy(C2F(cha1).buf,_("KIN_NO_MALLOC: Additional system memory has not yet been  allocated for vector storage (forgot to call the  KINMalloc routine)"));
2187                         break;
2188                 case 404  : strcpy(C2F(cha1).buf,_("KIN_MEM_FAIL: An error occurred during memory allocation (either insufficient system resources are available or the vector kernel has not yet been initialized "));
2189                         break;
2190                 case 405  : strcpy(C2F(cha1).buf,_("KIN_LINESEARCH_NONCONV:  The line-search algorithm was unable to find an iterate sufficiently distinct  from the current iterate failure to satisfy the sufficient decrease condition could mean the current iterate is close to an approximate solution of the given nonlinear system, the finite-difference  approximation of the matrix-vector product  J(u)*v is inaccurate, or the real scalar scsteptol is too large "));
2191                         break;
2192                 case 406  : strcpy(C2F(cha1).buf,_("KIN_MAXITER_REACHED: The maximum number of nonlinear iterations has been reached "));
2193                         break;
2194                 case 407  : strcpy(C2F(cha1).buf,_("KIN_MXNEWT_5X_EXCEEDE: Five consecutive steps have been taken that satisfy the following inequality:  ||uscale*p||_L2 > 0.99*mxnewtstep where p denotes the current step and mxnewtstep is a real scalar upper bound on the scaled step length such a failure may mean ||fscale*func(u)||_L2 asymptotes from above to a finite value, or the real scalar mxnewtstep is too small "));
2195                         break;
2196                 case 408 : strcpy(C2F(cha1).buf,_("KIN_LINESEARCH_BCFAI: The line search algorithm (implemented in KINLineSearch) was unable to satisfy the beta-condition for MXNBCF + 1 nonlinear iterations (not necessarily consecutive), which may indicate the algorithm is making  poor progress "));
2197                         break;
2198                 case 409  : strcpy(C2F(cha1).buf,_("KIN_LINSOLV_NO_RECOVERY: The user-supplied routine psolve encountered a recoverable error, but the preconditioner is already current"));
2199                         break;
2200                 case 410  : strcpy(C2F(cha1).buf,_("KIN_LINIT_FAIL: The linear solver initialization routine (linit) encountered an error."));
2201                         break;
2202                 case 411  : strcpy(C2F(cha1).buf,_("KIN_LSETUP_FAIL: The user-supplied routine pset (used to compute the preconditioner) encountered an unrecoverable error ."));
2203                         break;
2204                 case 412  : strcpy(C2F(cha1).buf,_("KIN_LSOLVE_FAIL: Either the user-supplied routine psolve (used to solve the preconditioned linear system) encountered an unrecoverable error, or the linear solver routine (lsolve) encountered an error condition."));
2205                         break;
2206                 case 413  : strcpy(C2F(cha1).buf,_("KIN_SYSFUNC_FAIL: Error in the computing function. Please verify your model."));
2207                         break;
2208                 case 414  : strcpy(C2F(cha1).buf,_("KIN_FIRST_SYSFUNC_ERR: The system function failed at the first call. Please verify your model. There might be an error in the computing function, for example a function may be called with illegal inputs."));
2209                         break;
2210                 case 415  : strcpy(C2F(cha1).buf,_("KIN_REPTD_SYSFUNC_ERR: The system function failed repeatedly. Please verify your model. There might be an error in the computing function, for example a function may be called with illegal inputs"));
2211                         break;
2212                 case 416  : strcpy(C2F(cha1).buf,_("KIN_NAN_ERR: The residual function returns NAN. Please verify your model: some functions might be called with illegal inputs."));
2213                         break;
2214
2215                 default  : if(ierr>=1000)
2216                                            strcpy(C2F(cha1).buf,_("unknown or erroneous block"));
2217                                    else if (ierr>=100)
2218                                    {
2219                                            istate=-(ierr-100);
2220                                            sprintf(C2F(cha1).buf, _("integration problem istate=%d"),istate);
2221                                            C2F(curblk).kfun=0;
2222                                    }
2223                                    else
2224                                    {
2225                                            strcpy(C2F(cha1).buf,_("scicos unexpected error, please report..."));
2226                                            C2F(curblk).kfun=0;
2227                                    }
2228                                    break;
2229                 }
2230                 if (! (C2F(errgst).err1>0||C2F(iop).err>0))
2231                 {
2232                         Scierror(888,"%s\n",C2F(cha1).buf);
2233                         /*C2F(curblk).kfun=0;*/
2234                         C2F(com).fun=0; /*set common fun=0 (this disable bug in debug mode)*/
2235                         freeparam;
2236                         return 0;
2237                 }
2238         }
2239
2240         if (C2F(iop).err>0) 
2241         {
2242                 freeparam;
2243                 return 0;
2244         }
2245
2246         /*C2F(curblk).kfun=0;*/
2247         C2F(com).fun=0;
2248
2249         /*********************
2250         * return Lsh variable
2251         *********************/
2252         /*copy int parameters of state in double parameters*/
2253         for(i=0;i<(m1e7*n1e7);i++) ((double *)(il_state_evtspt+4))[i] = (double) l_state_evtspt[i];
2254         for(i=0;i<(m1e8*n1e8);i++) ((double *)(il_pointi+4))[i] = (double) l_pointi[i];
2255         /*set lsh var*/
2256         if (Lhs>=1) LhsVar(1) = 1; /*return state in LhsVar(1)*/
2257         if (Lhs==2) LhsVar(2) = 2; /*return tcur in LhsVar(2)*/
2258
2259     /* end */
2260     freeparam;
2261
2262         PutLhsVar();
2263         
2264         return 0;
2265 }
2266 /*--------------------------------------------------------------------------*/