Xcos-Scicos: indent some files before modification
[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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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
173     {
174         int idb;
175     } C2F(dbcos);   /*declaration of dbcos*/
176
177     typedef struct inter_s_
178     {
179         int iwhere, nbrows, nbcols, itflag, ntypes, lad, ladc, lhsvar;
180     } intersci_state ;
181
182     typedef struct inter_l
183     {
184         intersci_state *state ;
185         int nbvars;
186     } intersci_list ;
187
188     intersci_list *loc = NULL;
189     intersci_state *new = NULL ;
190
191
192     /* declaration of outtb_elem */
193     outtb_el *outtb_elem = NULL;
194     static int nelem  = 0;
195
196     /*auxilary variables for dimension and address*/
197     static int m1 = 0;                  /*state*/
198     static int *il_state = NULL;
199     static int m1e2 = 0, n1e2 = 0;          /*state.x*/
200     static int *il_state_x = NULL;
201     static double *l_state_x = NULL;
202     static int m1e3 = 0, n1e3 = 0;          /*state.z*/
203     static int *il_state_z = NULL;
204     static double *l_state_z = NULL;
205     static int *il_state_oz = NULL;        /*state.oz*/
206     static int noz = 0;
207     static void **oz = NULL;
208     static int *ozsz = NULL;
209     static int *oztyp = NULL;
210     static int m1e5 = 0, n1e5 = 0;          /*state.iz*/
211     static int *il_state_iz = NULL;
212     static void **l_state_iz = NULL;
213     static int m1e6 = 0, n1e6 = 0;          /*state.tevts*/
214     static int *il_state_tevts = NULL;
215     static double *l_state_tevts = NULL;
216     static int m1e7 = 0, n1e7 = 0;          /*state.evtspt*/
217     static int *il_state_evtspt = NULL;
218     static int *l_state_evtspt = NULL;
219     static int m1e8 = 0, n1e8 = 0;          /*state.pointi*/
220     static int *il_pointi = NULL;
221     static int *l_pointi = NULL;
222     static int *il_state_outtb = NULL;     /*state.outtb*/
223     static int nlnk = 0;
224     static void **outtbptr = NULL;
225     static int *outtbsz = NULL;
226     static int *outtbtyp = NULL;
227
228     static int m2 = 0, n2 = 0;              /*tcur*/
229     static int *il_tcur = NULL;
230     static double *l_tcur = NULL;
231
232     static int m3 = 0, n3 = 0;              /*tf*/
233     static int *il_tf = NULL;
234     static double *l_tf = NULL;
235
236     static int m4 = 0, n4 = 0, l4 = 0, il4 = 0;     /*sim*/
237     static int *il_sim = NULL;
238     static int l4e2 = 0, il4e2 = 0;         /*sim.funs*/
239     static int *il_sim_fun = NULL;
240     static int nblk = 0;
241     static int m_xptr = 0, n_xptr = 0;      /*sim.xptr*/
242     static int *il_sim_xptr = NULL;
243     static int *l_sim_xptr = NULL;
244     static int m_zptr = 0, n_zptr = 0;      /*sim.zptr*/
245     static int *il_sim_zptr = NULL;
246     static int *l_sim_zptr = NULL;
247     static int m_ozptr = 0, n_ozptr = 0;    /*sim.ozptr*/
248     static int *il_sim_ozptr = NULL;
249     static int *l_sim_ozptr = NULL;
250
251     static int m_zcptr = 0, n_zcptr = 0;    /*sim.zcptr*/
252     static int *il_sim_zcptr = NULL;
253     static int *l_sim_zcptr = NULL;
254     static int m_inpptr = 0, n_inpptr = 0;  /*sim.inpptr*/
255     static int *il_sim_inpptr = NULL;
256     static int *l_sim_inpptr = NULL;
257     static int m_outptr = 0, n_outptr = 0;  /*sim.outptr*/
258     static int *il_sim_outptr = NULL;
259     static int *l_sim_outptr = NULL;
260     static int m_inplnk = 0, n_inplnk = 0;  /*sim.inplnk*/
261     static int *il_sim_inplnk = NULL;
262     static int *l_sim_inplnk = NULL;
263     static int m_outlnk = 0, n_outlnk = 0;  /*sim.outlnk*/
264     static int *il_sim_outlnk = NULL;
265     static int *l_sim_outlnk = NULL;
266     static int m_rpar = 0, n_rpar = 0;      /*sim.rpar*/
267     static int *il_sim_rpar = NULL;
268     static double *l_sim_rpar = NULL;
269     static int m_rpptr = 0, n_rpptr = 0;    /*sim.rpptr*/
270     static int *il_sim_rpptr = NULL;
271     static int *l_sim_rpptr = NULL;
272     static int m_ipar = 0, n_ipar = 0;      /*sim.ipar*/
273     static int *il_sim_ipar = NULL;
274     static int *l_sim_ipar = NULL;
275     static int m_ipptr = 0, n_ipptr = 0;    /*sim.ipptr*/
276     static int *il_sim_ipptr = NULL;
277     static int *l_sim_ipptr = NULL;
278     static int *il_sim_opar = NULL;        /*sim.opar*/
279     static int nopar = 0;
280     static void **opar = NULL;
281     static int *oparsz = NULL;
282     static int *opartyp = NULL;
283     static int m_opptr = 0, n_opptr = 0;    /*sim.opptr*/
284     static int *il_sim_opptr = NULL;
285     static int *l_sim_opptr = NULL;
286
287     static int m_clkptr = 0, n_clkptr = 0;  /*sim.clkptr*/
288     static int *il_sim_clkptr = NULL;
289     static int *l_sim_clkptr = NULL;
290     static int m_ordptr = 0, n_ordptr = 0;  /*sim.ordptr*/
291     static int *il_sim_ordptr = NULL;
292     static int *l_sim_ordptr = NULL;
293     static int m_execlk = 0, n_execlk = 0;  /*sim.execlk*/
294     static int *il_sim_execlk = NULL;
295     static int *l_sim_execlk = NULL;
296     static int m_ordclk = 0, n_ordclk = 0;  /*sim.ordclk*/
297     static int *il_sim_ordclk = NULL;
298     static int *l_sim_ordclk = NULL;
299     static int m_cord = 0, n_cord = 0;      /*sim.cord*/
300     static int *il_sim_cord = NULL;
301     static int *l_sim_cord = NULL;
302     static int m_oord = 0, n_oord = 0;      /*sim.oord*/
303     static int *il_sim_oord = NULL;
304     static int *l_sim_oord = NULL;
305     static int m_zord = 0, n_zord = 0;      /*sim.zord*/
306     static int *il_sim_zord = NULL;
307     static int *l_sim_zord = NULL;
308     static int m_critev = 0, n_critev = 0;  /*sim.critev*/
309     static int *il_sim_critev = NULL;
310     static int *l_sim_critev = NULL;
311     static int m_nb = 0, n_nb = 0;          /*sim.nb*/
312     static int *il_sim_nb = NULL;
313     static int *l_sim_nb = NULL;
314     static int m_ztyp = 0, n_ztyp = 0;      /*sim.ztyp*/
315     static int *il_sim_ztyp = NULL;
316     static int *l_sim_ztyp = NULL;
317     static int m_nblk = 0, n_nblk = 0;      /*sim.nblk*/
318     static int *il_sim_nblk = NULL;
319     static int *l_sim_nblk = NULL;
320     static int m_ndcblk = 0, n_ndcblk = 0;  /*sim.ndcblk*/
321     static int *il_sim_ndcblk = NULL;
322     static int *l_sim_ndcblk = NULL;
323     static int m_subscr = 0, n_subscr = 0;  /*sim.subscr*/
324     static int *il_sim_subscr = NULL;
325     static int *l_sim_subscr = NULL;
326     static int m_funtyp = 0, n_funtyp = 0;  /*sim.funtyp*/
327     static int *il_sim_funtyp = NULL;
328     static int *l_sim_funtyp = NULL;
329     static int m_iord = 0, n_iord = 0;      /*sim.iord*/
330     static int *il_sim_iord = NULL;
331     static int *l_sim_iord = NULL;
332     static int m_lab = 0, n_lab = 0;        /*sim.labels*/
333     static int *il_sim_lab = NULL;
334     static int *il_sim_labptr = NULL;
335     static int *l_sim_lab = NULL;
336     static int m_modptr = 0, n_modptr = 0;  /*sim.modptr*/
337     static int *il_sim_modptr = NULL;
338     static int *l_sim_modptr = NULL;
339
340     static int m5 = 0, n5 = 0;              /*str*/
341     static int *il_str = NULL;
342     static int *l_str = NULL;
343     static int flag;
344
345     static int m6 = 0, n6 = 0;              /*tol*/
346     static int *il_tol = NULL;
347     static double *l_tol = NULL;
348
349     /*auxilary variables*/
350     static double simpar[7];
351     static int solver = 0;
352     static int *lfunpt = NULL;     /*for function table*/
353     static int lf = 0, ilf = 0, ifun = 0; /*for function table*/
354     static int ierr = 0, istate = 0; /*error variable of scicos.c*/
355
356     /*local variable*/
357     int *subheader = NULL; /*pointer to get address of a subvariable in a list*/
358     int i = 0, j = 0, k = 0;      /*local counter variable*/
359     int sz_str = 0;     /*local variable to store size of string*/
360     int err_check = 0;  /*local variable for cross var. checking dimension*/
361
362     /*definition of min/max input/output argument*/
363     static int minlhs = 1, maxlhs = 2;
364     static int minrhs = 6, maxrhs = 6;
365
366     /*************************************
367     * Check number of inputs and outputs
368     *************************************/
369     CheckRhs(minrhs, maxrhs);
370     CheckLhs(minlhs, maxlhs);
371
372     /****************
373     * state (rhs 1)
374     ****************/
375     il_state = (int *) GetData(1);
376
377     /* make a copy of il_state in a global variabe */
378     set_il_state(il_state);
379
380     if (il_state[0] != 16) /*Check if state is a tlist*/
381     {
382         Scierror(56, "%s : First argument must be a Tlist.\n", fname);
383         C2F(iop).err = 1;
384         return 0;
385     }
386     m1 = il_state[1];
387
388     /*2 : state.x      */
389     il_state_x = (int *) (listentry(il_state, 2));
390     l_state_x  = (double *) (il_state_x + 4);
391     m1e2 = il_state_x[1];
392     n1e2 = il_state_x[2];
393
394     /*3 : state.z      */
395     il_state_z = (int *) (listentry(il_state, 3));
396     l_state_z  = (double *) (il_state_z + 4);
397     m1e3 = il_state_z[1];
398     n1e3 = il_state_z[2];
399
400     /*4 : state.oz     */
401     il_state_oz = (int *) (listentry(il_state, 4));
402     if (il_state_oz[0] != 15) /*check if il_state_oz is a list*/
403     {
404         Scierror(56, _("%s : oz element of state must be a list.\n"), fname);
405         C2F(iop).err = 4;
406         return 0;
407     }
408     noz = il_state_oz[1];
409
410     /*5 : state.iz     */
411     il_state_iz = (int *) (listentry(il_state, 5));
412     l_state_iz  = (void **) (il_state_iz + 4);
413     m1e5 = il_state_iz[1];
414     n1e5 = il_state_iz[2];
415
416     /*6 : state.tevts  */
417     il_state_tevts = (int *) (listentry(il_state, 6));
418     l_state_tevts  = (double *) (il_state_tevts + 4);
419     m1e6 = il_state_tevts[1];
420     n1e6 = il_state_tevts[2];
421
422     /*7 : state.evtspt */
423     il_state_evtspt = (int *) (listentry(il_state, 7));
424     m1e7 = il_state_evtspt[1];
425     n1e7 = il_state_evtspt[2];
426     if ((m1e7 * n1e7) == 0)
427     {
428         l_state_evtspt = NULL;
429     }
430     else
431     {
432         if ((l_state_evtspt = (int *) MALLOC((m1e7 * n1e7) * sizeof(int))) == NULL )
433         {
434             Scierror(999, _("%s: Memory allocation error.\n"), fname);
435             return 0;
436         }
437         else
438         {
439             for (i = 0; i < (m1e7 * n1e7); i++)
440             {
441                 l_state_evtspt[i] = (int) ((double *)(il_state_evtspt + 4))[i];
442             }
443         }
444     }
445
446     /*8 : state.pointi */
447     il_pointi = (int *) (listentry(il_state, 8));
448     m1e8 = il_pointi[1];
449     n1e8 = il_pointi[2];
450     if ((l_pointi = (int *) MALLOC((m1e8 * n1e8) * sizeof(int))) == NULL )
451     {
452         Scierror(999, _("%s: Memory allocation error.\n"), fname);
453         FREE(l_state_evtspt);
454         return 0;
455     }
456     else
457     {
458         for (i = 0; i < (m1e8 * n1e8); i++)
459         {
460             l_pointi[i] = (int) ((double *)(il_pointi + 4))[i];
461         }
462     }
463
464     /*9 : state.outtb  */
465     il_state_outtb = (int *) (listentry(il_state, 9));
466     if (il_state_outtb[0] != 15) /*check if il_state_outtb is a list*/
467     {
468         Scierror(56, _("%s : outtb element of state must be a list.\n"), fname);
469         FREE(l_state_evtspt);
470         FREE(l_pointi);
471         C2F(iop).err = 4;
472         return 0;
473     }
474     nlnk = il_state_outtb[1]; /*nlnk is the dimension of the list state_louttb*/
475
476     /***************
477     * tcur (rhs 2)
478     ***************/
479     il_tcur = (int *) GetData(2);
480     if (il_tcur[0] != 1) /*Check if tcur is a real or complex matrix*/
481     {
482         Scierror(53, _("%s : Second argument must be a scalar.\n"), fname);
483         FREE(l_state_evtspt);
484         FREE(l_pointi);
485         C2F(iop).err = 2;
486         return 0;
487     }
488     l_tcur = (double *) (il_tcur + 4);
489     m2 = il_tcur[1];
490     n2 = il_tcur[2];
491     CheckScalar(2, m2, n2);
492     CheckDims(2, m2, n2, 1, 1);
493
494     /*************
495     * tf (rhs 3)
496     *************/
497     il_tf = (int *) GetData(3);
498     if (il_tf[0] != 1) /*Check if tf is a real or complex matrix*/
499     {
500         Scierror(53, _("%s : Third argument must be a scalar.\n"), fname);
501         FREE(l_state_evtspt);
502         FREE(l_pointi);
503         C2F(iop).err = 3;
504         return 0;
505     }
506     l_tf = (double *) (il_tf + 4);
507     m3 = il_tf[1];
508     n3 = il_tf[2];
509     CheckScalar(3, m3, n3);
510     CheckDims(3, m3, n3, 1, 1);
511
512     /*************
513     * sim (rhs 4)
514     *************/
515     il_sim = (int *) GetData(4);
516
517
518     set_il_sim(il_sim);
519
520     if (il_sim[0] != 16) /*Check if sim is a tlist*/
521     {
522         Scierror(56, _("%s : Fourth argument must be a Tlist.\n"), fname);
523         FREE(l_state_evtspt);
524         FREE(l_pointi);
525         C2F(iop).err = 4;
526         return 0;
527     }
528     m4 = il_sim[1];
529     n4 = il_sim[2];
530
531     /*2  : sim.funs*/
532     il_sim_fun = (int *) (listentry(il_sim, 2));
533     if (il_sim_fun[0] != 15) /*check if sim.funs is a list*/
534     {
535         Scierror(56, _("%s : Second element of sim must be a list.\n"), fname);
536         FREE(l_state_evtspt);
537         FREE(l_pointi);
538         C2F(iop).err = 4;
539         return 0;
540     }
541     nblk = il_sim_fun[1]; /*nblk is the dimension of the list sim.funs*/
542
543     /*3  : sim.xptr   */
544     il_sim_xptr = (int *) (listentry(il_sim, 3));
545     m_xptr = il_sim_xptr[1];
546     n_xptr = il_sim_xptr[2];
547     if (m_xptr * n_xptr == 0)
548     {
549         l_sim_xptr = NULL;
550     }
551     else
552     {
553         if ((l_sim_xptr = (int *) MALLOC((m_xptr * n_xptr) * sizeof(int))) == NULL )
554         {
555             Scierror(999, _("%s: Memory allocation error.\n"), fname);
556             FREE(l_state_evtspt);
557             FREE(l_pointi);
558             return 0;
559         }
560         else
561         {
562             for (i = 0; i < (m_xptr * n_xptr); i++)
563             {
564                 l_sim_xptr[i] = (int) ((double *)(il_sim_xptr + 4))[i];
565             }
566         }
567     }
568
569     /*4  : sim.zptr   */
570     il_sim_zptr = (int *) (listentry(il_sim, 4));
571     m_zptr = il_sim_zptr[1];
572     n_zptr = il_sim_zptr[2];
573     if (m_zptr * n_zptr == 0)
574     {
575         l_sim_zptr = NULL;
576     }
577     else
578     {
579         if ((l_sim_zptr = (int *) MALLOC((m_zptr * n_zptr) * sizeof(int))) == NULL )
580         {
581             Scierror(999, _("%s: Memory allocation error.\n"), fname);
582             FREE(l_sim_xptr);
583             FREE(l_state_evtspt);
584             FREE(l_pointi);
585             return 0;
586         }
587         else
588         {
589             for (i = 0; i < (m_zptr * n_zptr); i++)
590             {
591                 l_sim_zptr[i] = (int) ((double *)(il_sim_zptr + 4))[i];
592             }
593         }
594     }
595
596     /*5  : sim.ozptr   */
597     il_sim_ozptr = (int *) (listentry(il_sim, 5));
598     m_ozptr = il_sim_ozptr[1];
599     n_ozptr = il_sim_ozptr[2];
600     if (m_ozptr * n_ozptr == 0)
601     {
602         l_sim_ozptr = NULL;
603     }
604     else
605     {
606         if ((l_sim_ozptr = (int *) MALLOC((m_ozptr * n_ozptr) * sizeof(int))) == NULL )
607         {
608             Scierror(999, _("%s: Memory allocation error.\n"), fname);
609             FREE(l_sim_zptr);
610             FREE(l_sim_xptr);
611             FREE(l_state_evtspt);
612             FREE(l_pointi);
613             return 0;
614         }
615         else
616         {
617             for (i = 0; i < (m_ozptr * n_ozptr); i++)
618             {
619                 l_sim_ozptr[i] = (int) ((double *)(il_sim_ozptr + 4))[i];
620             }
621         }
622     }
623
624     /*6  : sim.zcptr  */
625     il_sim_zcptr = (int *) (listentry(il_sim, 6));
626     m_zcptr = il_sim_zcptr[1];
627     n_zcptr = il_sim_zcptr[2];
628     if (m_zcptr * n_zcptr == 0)
629     {
630         l_sim_zcptr = NULL;
631     }
632     else
633     {
634         if ((l_sim_zcptr = (int *) MALLOC((m_zcptr * n_zcptr) * sizeof(int))) == NULL )
635         {
636             Scierror(999, _("%s: Memory allocation error.\n"), fname);
637             FREE(l_sim_ozptr);
638             FREE(l_sim_zptr);
639             FREE(l_sim_xptr);
640             FREE(l_state_evtspt);
641             FREE(l_pointi);
642             return 0;
643         }
644         else
645         {
646             for (i = 0; i < (m_zcptr * n_zcptr); i++)
647             {
648                 l_sim_zcptr[i] = (int) ((double *)(il_sim_zcptr + 4))[i];
649             }
650         }
651     }
652
653     /*7  : sim.inpptr */
654     il_sim_inpptr = (int *) (listentry(il_sim, 7));
655     m_inpptr = il_sim_inpptr[1];
656     n_inpptr = il_sim_inpptr[2];
657     if (m_inpptr * n_inpptr == 0)
658     {
659         l_sim_inpptr = NULL;
660     }
661     else
662     {
663         if ((l_sim_inpptr = (int *) MALLOC((m_inpptr * n_inpptr) * sizeof(int))) == NULL )
664         {
665             Scierror(999, _("%s: Memory allocation error.\n"), fname);
666             FREE(l_sim_ozptr);
667             FREE(l_sim_zcptr);
668             FREE(l_sim_zptr);
669             FREE(l_sim_xptr);
670             FREE(l_state_evtspt);
671             FREE(l_pointi);
672             return 0;
673         }
674         else
675         {
676             for (i = 0; i < (m_inpptr * n_inpptr); i++)
677             {
678                 l_sim_inpptr[i] = (int) ((double *)(il_sim_inpptr + 4))[i];
679             }
680         }
681     }
682
683     /*8  : sim.outptr */
684     il_sim_outptr = (int *) (listentry(il_sim, 8));
685     m_outptr = il_sim_outptr[1];
686     n_outptr = il_sim_outptr[2];
687     if (m_outptr * n_outptr == 0)
688     {
689         l_sim_outptr = NULL;
690     }
691     else
692     {
693         if ((l_sim_outptr = (int *) MALLOC((m_outptr * n_outptr) * sizeof(int))) == NULL )
694         {
695             Scierror(999, _("%s: Memory allocation error.\n"), fname);
696             FREE(l_sim_inpptr);
697             FREE(l_sim_ozptr);
698             FREE(l_sim_zcptr);
699             FREE(l_sim_zptr);
700             FREE(l_sim_xptr);
701             FREE(l_state_evtspt);
702             FREE(l_pointi);
703             return 0;
704         }
705         else
706         {
707             for (i = 0; i < (m_outptr * n_outptr); i++)
708             {
709                 l_sim_outptr[i] = (int) ((double *)(il_sim_outptr + 4))[i];
710             }
711         }
712     }
713
714     /*9  : sim.inplnk */
715     il_sim_inplnk = (int *) (listentry(il_sim, 9));
716     m_inplnk = il_sim_inplnk[1];
717     n_inplnk = il_sim_inplnk[2];
718     if (m_inplnk * n_inplnk == 0)
719     {
720         l_sim_inplnk = NULL;
721     }
722     else
723     {
724         if ((l_sim_inplnk = (int *) MALLOC((m_inplnk * n_inplnk) * sizeof(int))) == NULL )
725         {
726             Scierror(999, _("%s: Memory allocation error.\n"), fname);
727             FREE(l_sim_outptr);
728             FREE(l_sim_inpptr);
729             FREE(l_sim_zcptr);
730             FREE(l_sim_ozptr);
731             FREE(l_sim_zptr);
732             FREE(l_sim_xptr);
733             FREE(l_state_evtspt);
734             FREE(l_pointi);
735             return 0;
736         }
737         else
738         {
739             for (i = 0; i < (m_inplnk * n_inplnk); i++)
740             {
741                 l_sim_inplnk[i] = (int) ((double *)(il_sim_inplnk + 4))[i];
742             }
743         }
744     }
745
746     /*10  : sim.outlnk */
747     il_sim_outlnk = (int *) (listentry(il_sim, 10));
748     m_outlnk = il_sim_outlnk[1];
749     n_outlnk = il_sim_outlnk[2];
750     if (m_outlnk * n_outlnk == 0)
751     {
752         l_sim_outlnk = NULL;
753     }
754     else
755     {
756         if ((l_sim_outlnk = (int *) MALLOC((m_outlnk * n_outlnk) * sizeof(int))) == NULL )
757         {
758             Scierror(999, _("%s: Memory allocation error.\n"), fname);
759             FREE(l_sim_inplnk);
760             FREE(l_sim_outptr);
761             FREE(l_sim_inpptr);
762             FREE(l_sim_zcptr);
763             FREE(l_sim_ozptr);
764             FREE(l_sim_zptr);
765             FREE(l_sim_xptr);
766             FREE(l_state_evtspt);
767             FREE(l_pointi);
768             return 0;
769         }
770         else
771         {
772             for (i = 0; i < (m_outlnk * n_outlnk); i++)
773             {
774                 l_sim_outlnk[i] = (int) ((double *)(il_sim_outlnk + 4))[i];
775             }
776         }
777     }
778
779     /*11 : sim.rpar   */
780     il_sim_rpar = (int *) (listentry(il_sim, 11));
781     m_rpar = il_sim_rpar[1];
782     n_rpar = il_sim_rpar[2];
783     if (m_rpar * n_rpar == 0)
784     {
785         l_sim_rpar = NULL;
786     }
787     else
788     {
789         l_sim_rpar = (double *) (il_sim_rpar + 4);
790     }
791
792     /*12 : sim.rpptr  */
793     il_sim_rpptr = (int *) (listentry(il_sim, 12));
794     m_rpptr = il_sim_rpptr[1];
795     n_rpptr = il_sim_rpptr[2];
796     if (m_rpptr * n_rpptr == 0)
797     {
798         l_sim_rpptr = NULL;
799     }
800     else
801     {
802         if ((l_sim_rpptr = (int *) MALLOC((m_rpptr * n_rpptr) * sizeof(int))) == NULL )
803         {
804             Scierror(999, _("%s: Memory allocation error.\n"), fname);
805             FREE(l_sim_outlnk);
806             FREE(l_sim_inplnk);
807             FREE(l_sim_outptr);
808             FREE(l_sim_inpptr);
809             FREE(l_sim_zcptr);
810             FREE(l_sim_ozptr);
811             FREE(l_sim_zptr);
812             FREE(l_sim_xptr);
813             FREE(l_state_evtspt);
814             FREE(l_pointi);
815             return 0;
816         }
817         else
818         {
819             for (i = 0; i < (m_rpptr * n_rpptr); i++)
820             {
821                 l_sim_rpptr[i] = (int) ((double *)(il_sim_rpptr + 4))[i];
822             }
823         }
824     }
825
826     /*13 : sim.ipar   */
827     il_sim_ipar = (int *) (listentry(il_sim, 13));
828     m_ipar = il_sim_ipar[1];
829     n_ipar = il_sim_ipar[2];
830     if (m_ipar * n_ipar == 0)
831     {
832         l_sim_ipar = NULL;
833     }
834     else
835     {
836         if ((l_sim_ipar = (int *) MALLOC((m_ipar * n_ipar) * sizeof(int))) == NULL )
837         {
838             Scierror(999, _("%s: Memory allocation error.\n"), fname);
839             FREE(l_sim_rpptr);
840             FREE(l_sim_outlnk);
841             FREE(l_sim_inplnk);
842             FREE(l_sim_outptr);
843             FREE(l_sim_inpptr);
844             FREE(l_sim_zcptr);
845             FREE(l_sim_ozptr);
846             FREE(l_sim_zptr);
847             FREE(l_sim_xptr);
848             FREE(l_state_evtspt);
849             FREE(l_pointi);
850             return 0;
851         }
852         else
853         {
854             for (i = 0; i < (m_ipar * n_ipar); i++)
855             {
856                 l_sim_ipar[i] = (int) ((double *)(il_sim_ipar + 4))[i];
857             }
858         }
859     }
860
861     /*14 : sim.ipptr  */
862     il_sim_ipptr = (int *) (listentry(il_sim, 14));
863     m_ipptr = il_sim_ipptr[1];
864     n_ipptr = il_sim_ipptr[2];
865     if (m_ipptr * n_ipptr == 0)
866     {
867         l_sim_ipptr = NULL;
868     }
869     else
870     {
871         if ((l_sim_ipptr = (int *) MALLOC((m_ipptr * n_ipptr) * sizeof(int))) == NULL )
872         {
873             Scierror(999, _("%s: Memory allocation error.\n"), fname);
874             FREE(l_sim_ipar);
875             FREE(l_sim_rpptr);
876             FREE(l_sim_outlnk);
877             FREE(l_sim_inplnk);
878             FREE(l_sim_outptr);
879             FREE(l_sim_inpptr);
880             FREE(l_sim_zcptr);
881             FREE(l_sim_ozptr);
882             FREE(l_sim_zptr);
883             FREE(l_sim_xptr);
884             FREE(l_state_evtspt);
885             FREE(l_pointi);
886             return 0;
887         }
888         else
889         {
890             for (i = 0; i < (m_ipptr * n_ipptr); i++)
891             {
892                 l_sim_ipptr[i] = (int) ((double *)(il_sim_ipptr + 4))[i];
893             }
894         }
895     }
896
897     /*15 : sim.opar   */
898     il_sim_opar = (int *) (listentry(il_sim, 15));
899     if (il_sim_opar[0] != 15) /*Check if sim.opar is a list*/
900     {
901         Scierror(56, _("%s : sim.opar must be a list.\n"), fname);
902         FREE(l_sim_ipptr);
903         FREE(l_sim_ipar);
904         FREE(l_sim_rpptr);
905         FREE(l_sim_outlnk);
906         FREE(l_sim_inplnk);
907         FREE(l_sim_outptr);
908         FREE(l_sim_inpptr);
909         FREE(l_sim_zcptr);
910         FREE(l_sim_ozptr);
911         FREE(l_sim_zptr);
912         FREE(l_sim_xptr);
913         FREE(l_state_evtspt);
914         FREE(l_pointi);
915         C2F(iop).err = 4;
916         return 0;
917     }
918     nopar = il_sim_opar[1];
919
920     /*16 : sim.opptr  */
921     il_sim_opptr = (int *) (listentry(il_sim, 16));
922     m_opptr = il_sim_opptr[1];
923     n_opptr = il_sim_opptr[2];
924     if (m_opptr * n_opptr == 0)
925     {
926         l_sim_opptr = NULL;
927     }
928     else
929     {
930         if ((l_sim_opptr = (int *) MALLOC((m_opptr * n_opptr) * sizeof(int))) == NULL )
931         {
932             Scierror(999, _("%s: Memory allocation error.\n"), fname);
933             FREE(l_sim_ipptr);
934             FREE(l_sim_ipar);
935             FREE(l_sim_rpptr);
936             FREE(l_sim_outlnk);
937             FREE(l_sim_inplnk);
938             FREE(l_sim_outptr);
939             FREE(l_sim_inpptr);
940             FREE(l_sim_zcptr);
941             FREE(l_sim_ozptr);
942             FREE(l_sim_zptr);
943             FREE(l_sim_xptr);
944             FREE(l_state_evtspt);
945             FREE(l_pointi);
946             return 0;
947         }
948         else
949         {
950             for (i = 0; i < (m_opptr * n_opptr); i++)
951             {
952                 l_sim_opptr[i] = (int) ((double *)(il_sim_opptr + 4))[i];
953             }
954         }
955     }
956
957     /*17 : sim.clkptr */
958     il_sim_clkptr = (int *) (listentry(il_sim, 17));
959     m_clkptr = il_sim_clkptr[1];
960     n_clkptr = il_sim_clkptr[2];
961     if (m_clkptr * n_clkptr == 0)
962     {
963         l_sim_clkptr = NULL;
964     }
965     else
966     {
967         if ((l_sim_clkptr = (int *) MALLOC((m_clkptr * n_clkptr) * sizeof(int))) == NULL )
968         {
969             Scierror(999,  _("%s: Memory allocation error.\n"), fname);
970             FREE(l_sim_clkptr);
971             FREE(l_sim_opptr);
972             FREE(l_sim_ipptr);
973             FREE(l_sim_ipar);
974             FREE(l_sim_rpptr);
975             FREE(l_sim_outlnk);
976             FREE(l_sim_inplnk);
977             FREE(l_sim_outptr);
978             FREE(l_sim_inpptr);
979             FREE(l_sim_zcptr);
980             FREE(l_sim_ozptr);
981             FREE(l_sim_zptr);
982             FREE(l_sim_xptr);
983             FREE(l_state_evtspt);
984             FREE(l_pointi);
985             return 0;
986         }
987         else
988         {
989             for (i = 0; i < (m_clkptr * n_clkptr); i++)
990             {
991                 l_sim_clkptr[i] = (int) ((double *)(il_sim_clkptr + 4))[i];
992             }
993         }
994     }
995
996     /*18 : sim.ordptr */
997     il_sim_ordptr = (int *) (listentry(il_sim, 18));
998     m_ordptr = il_sim_ordptr[1];
999     n_ordptr = il_sim_ordptr[2];
1000     if ((l_sim_ordptr = (int *) MALLOC((m_ordptr * n_ordptr) * sizeof(int))) == NULL )
1001     {
1002         Scierror(999, _("%s: Memory allocation error.\n"), fname);
1003         FREE(l_sim_clkptr);
1004         FREE(l_sim_opptr);
1005         FREE(l_sim_ipptr);
1006         FREE(l_sim_ipar);
1007         FREE(l_sim_rpptr);
1008         FREE(l_sim_outlnk);
1009         FREE(l_sim_inplnk);
1010         FREE(l_sim_outptr);
1011         FREE(l_sim_inpptr);
1012         FREE(l_sim_zcptr);
1013         FREE(l_sim_ozptr);
1014         FREE(l_sim_zptr);
1015         FREE(l_sim_xptr);
1016         FREE(l_state_evtspt);
1017         FREE(l_pointi);
1018         return 0;
1019     }
1020     else
1021     {
1022         for (i = 0; i < (m_ordptr * n_ordptr); i++)
1023         {
1024             l_sim_ordptr[i] = (int) ((double *)(il_sim_ordptr + 4))[i];
1025         }
1026     }
1027
1028     /*19 : sim.execlk */
1029     il_sim_execlk = (int *) (listentry(il_sim, 19));
1030     m_execlk = il_sim_execlk[1];
1031     n_execlk = il_sim_execlk[2];
1032     if (m_execlk * n_execlk == 0)
1033     {
1034         l_sim_execlk = NULL;
1035     }
1036     else
1037     {
1038         if ((l_sim_execlk = (int *) MALLOC((m_execlk * n_execlk) * sizeof(int))) == NULL )
1039         {
1040             Scierror(999, _("%s: Memory allocation error.\n"), fname);
1041             FREE(l_sim_ordptr);
1042             FREE(l_sim_clkptr);
1043             FREE(l_sim_opptr);
1044             FREE(l_sim_ipptr);
1045             FREE(l_sim_ipar);
1046             FREE(l_sim_rpptr);
1047             FREE(l_sim_outlnk);
1048             FREE(l_sim_inplnk);
1049             FREE(l_sim_outptr);
1050             FREE(l_sim_inpptr);
1051             FREE(l_sim_zcptr);
1052             FREE(l_sim_ozptr);
1053             FREE(l_sim_zptr);
1054             FREE(l_sim_xptr);
1055             FREE(l_state_evtspt);
1056             FREE(l_pointi);
1057             return 0;
1058         }
1059         else
1060         {
1061             for (i = 0; i < (m_execlk * n_execlk); i++)
1062             {
1063                 l_sim_execlk[i] = (int) ((double *)(il_sim_execlk + 4))[i];
1064             }
1065         }
1066     }
1067
1068     /*20 : sim.ordclk */
1069     il_sim_ordclk = (int *) (listentry(il_sim, 20));
1070     m_ordclk = il_sim_ordclk[1];
1071     n_ordclk = il_sim_ordclk[2];
1072     if (m_ordclk * n_ordclk == 0)
1073     {
1074         l_sim_ordclk = NULL;
1075     }
1076     else
1077     {
1078         if ((l_sim_ordclk = (int *) MALLOC((m_ordclk * n_ordclk) * sizeof(int))) == NULL )
1079         {
1080             Scierror(999, _("%s: Memory allocation error.\n"), fname);
1081             FREE(l_sim_execlk);
1082             FREE(l_sim_ordptr);
1083             FREE(l_sim_clkptr);
1084             FREE(l_sim_opptr);
1085             FREE(l_sim_ipptr);
1086             FREE(l_sim_ipar);
1087             FREE(l_sim_rpptr);
1088             FREE(l_sim_outlnk);
1089             FREE(l_sim_inplnk);
1090             FREE(l_sim_outptr);
1091             FREE(l_sim_inpptr);
1092             FREE(l_sim_zcptr);
1093             FREE(l_sim_ozptr);
1094             FREE(l_sim_zptr);
1095             FREE(l_sim_xptr);
1096             FREE(l_state_evtspt);
1097             FREE(l_pointi);
1098             return 0;
1099         }
1100         else
1101         {
1102             for (i = 0; i < (m_ordclk * n_ordclk); i++)
1103             {
1104                 l_sim_ordclk[i] = (int) ((double *)(il_sim_ordclk + 4))[i];
1105             }
1106         }
1107     }
1108
1109     /*21 : sim.cord   */
1110     il_sim_cord = (int *) (listentry(il_sim, 21));
1111     m_cord = il_sim_cord[1];
1112     n_cord = il_sim_cord[2];
1113     if (m_cord * n_cord == 0)
1114     {
1115         l_sim_cord = NULL;
1116     }
1117     else
1118     {
1119         if ((l_sim_cord = (int *) MALLOC((m_cord * n_cord) * sizeof(int))) == NULL )
1120         {
1121             Scierror(999, _("%s: Memory allocation error.\n"), fname);
1122             FREE(l_sim_ordclk);
1123             FREE(l_sim_execlk);
1124             FREE(l_sim_ordptr);
1125             FREE(l_sim_clkptr);
1126             FREE(l_sim_opptr);
1127             FREE(l_sim_ipptr);
1128             FREE(l_sim_ipar);
1129             FREE(l_sim_rpptr);
1130             FREE(l_sim_outlnk);
1131             FREE(l_sim_inplnk);
1132             FREE(l_sim_outptr);
1133             FREE(l_sim_inpptr);
1134             FREE(l_sim_zcptr);
1135             FREE(l_sim_ozptr);
1136             FREE(l_sim_zptr);
1137             FREE(l_sim_xptr);
1138             FREE(l_state_evtspt);
1139             FREE(l_pointi);
1140             return 0;
1141         }
1142         else
1143         {
1144             for (i = 0; i < (m_cord * n_cord); i++)
1145             {
1146                 l_sim_cord[i] = (int) ((double *)(il_sim_cord + 4))[i];
1147             }
1148         }
1149     }
1150
1151     /*22 : sim.oord   */
1152     il_sim_oord = (int *) (listentry(il_sim, 22));
1153     m_oord = il_sim_oord[1];
1154     n_oord = il_sim_oord[2];
1155     if (m_oord * n_oord == 0)
1156     {
1157         l_sim_oord = NULL;
1158     }
1159     else
1160     {
1161         if ((l_sim_oord = (int *) MALLOC((m_oord * n_oord) * sizeof(int))) == NULL )
1162         {
1163             Scierror(999, _("%s: Memory allocation error.\n"), fname);
1164             FREE(l_sim_cord);
1165             FREE(l_sim_ordclk);
1166             FREE(l_sim_execlk);
1167             FREE(l_sim_ordptr);
1168             FREE(l_sim_clkptr);
1169             FREE(l_sim_opptr);
1170             FREE(l_sim_ipptr);
1171             FREE(l_sim_ipar);
1172             FREE(l_sim_rpptr);
1173             FREE(l_sim_outlnk);
1174             FREE(l_sim_inplnk);
1175             FREE(l_sim_outptr);
1176             FREE(l_sim_inpptr);
1177             FREE(l_sim_zcptr);
1178             FREE(l_sim_ozptr);
1179             FREE(l_sim_zptr);
1180             FREE(l_sim_xptr);
1181             FREE(l_state_evtspt);
1182             FREE(l_pointi);
1183             return 0;
1184         }
1185         else
1186         {
1187             for (i = 0; i < (m_oord * n_oord); i++)
1188             {
1189                 l_sim_oord[i] = (int) ((double *)(il_sim_oord + 4))[i];
1190             }
1191         }
1192     }
1193
1194     /*23 : sim.zord   */
1195     il_sim_zord = (int *) (listentry(il_sim, 23));
1196     m_zord = il_sim_zord[1];
1197     n_zord = il_sim_zord[2];
1198     if (m_zord * n_zord == 0)
1199     {
1200         l_sim_zord = NULL;
1201     }
1202     else
1203     {
1204         if ((l_sim_zord = (int *) MALLOC((m_zord * n_zord) * sizeof(int))) == NULL )
1205         {
1206             Scierror(999, _("%s: Memory allocation error.\n"), fname);
1207             FREE(l_sim_oord);
1208             FREE(l_sim_cord);
1209             FREE(l_sim_ordclk);
1210             FREE(l_sim_execlk);
1211             FREE(l_sim_ordptr);
1212             FREE(l_sim_clkptr);
1213             FREE(l_sim_opptr);
1214             FREE(l_sim_ipptr);
1215             FREE(l_sim_ipar);
1216             FREE(l_sim_rpptr);
1217             FREE(l_sim_outlnk);
1218             FREE(l_sim_inplnk);
1219             FREE(l_sim_outptr);
1220             FREE(l_sim_inpptr);
1221             FREE(l_sim_zcptr);
1222             FREE(l_sim_ozptr);
1223             FREE(l_sim_zptr);
1224             FREE(l_sim_xptr);
1225             FREE(l_state_evtspt);
1226             FREE(l_pointi);
1227             return 0;
1228         }
1229         else
1230         {
1231             for (i = 0; i < (m_zord * n_zord); i++)
1232             {
1233                 l_sim_zord[i] = (int) ((double *)(il_sim_zord + 4))[i];
1234             }
1235         }
1236     }
1237
1238     /*24 : sim.critev */
1239     il_sim_critev = (int *) (listentry(il_sim, 24));
1240     m_critev = il_sim_critev[1];
1241     n_critev = il_sim_critev[2];
1242     if (m_critev * n_critev == 0)
1243     {
1244         l_sim_critev = NULL;
1245     }
1246     else
1247     {
1248         if ((l_sim_critev = (int *) MALLOC((m_critev * n_critev) * sizeof(int))) == NULL )
1249         {
1250             Scierror(999, _("%s: Memory allocation error.\n"), fname);
1251             FREE(l_sim_zord);
1252             FREE(l_sim_oord);
1253             FREE(l_sim_cord);
1254             FREE(l_sim_ordclk);
1255             FREE(l_sim_execlk);
1256             FREE(l_sim_ordptr);
1257             FREE(l_sim_clkptr);
1258             FREE(l_sim_opptr);
1259             FREE(l_sim_ipptr);
1260             FREE(l_sim_ipar);
1261             FREE(l_sim_rpptr);
1262             FREE(l_sim_outlnk);
1263             FREE(l_sim_inplnk);
1264             FREE(l_sim_outptr);
1265             FREE(l_sim_inpptr);
1266             FREE(l_sim_zcptr);
1267             FREE(l_sim_ozptr);
1268             FREE(l_sim_zptr);
1269             FREE(l_sim_xptr);
1270             FREE(l_state_evtspt);
1271             FREE(l_pointi);
1272             return 0;
1273         }
1274         else
1275         {
1276             for (i = 0; i < (m_critev * n_critev); i++)
1277             {
1278                 l_sim_critev[i] = (int) ((double *)(il_sim_critev + 4))[i];
1279             }
1280         }
1281     }
1282
1283     /*25 : sim.nb     */
1284     il_sim_nb = (int *) (listentry(il_sim, 25));
1285     m_nb = il_sim_nb[1];
1286     n_nb = il_sim_nb[2];
1287     if ((l_sim_nb = (int *) MALLOC((m_nb * n_nb) * sizeof(int))) == NULL )
1288     {
1289         Scierror(999, _("%s: Memory allocation error.\n"), fname);
1290         FREE(l_sim_critev);
1291         FREE(l_sim_zord);
1292         FREE(l_sim_oord);
1293         FREE(l_sim_cord);
1294         FREE(l_sim_ordclk);
1295         FREE(l_sim_execlk);
1296         FREE(l_sim_ordptr);
1297         FREE(l_sim_clkptr);
1298         FREE(l_sim_opptr);
1299         FREE(l_sim_ipptr);
1300         FREE(l_sim_ipar);
1301         FREE(l_sim_rpptr);
1302         FREE(l_sim_outlnk);
1303         FREE(l_sim_inplnk);
1304         FREE(l_sim_outptr);
1305         FREE(l_sim_inpptr);
1306         FREE(l_sim_zcptr);
1307         FREE(l_sim_ozptr);
1308         FREE(l_sim_zptr);
1309         FREE(l_sim_xptr);
1310         FREE(l_state_evtspt);
1311         FREE(l_pointi);
1312         return 0;
1313     }
1314     else
1315     {
1316         for (i = 0; i < (m_nb * n_nb); i++)
1317         {
1318             l_sim_nb[i] = (int) ((double *)(il_sim_nb + 4))[i];
1319         }
1320     }
1321     if (l_sim_nb[0] != nblk) /*value of nb must be equal to nblk*/
1322     {
1323         Scierror(42, _("%s : Incompatible sim.nb RHS parameter.\n"), fname);
1324         return 0;
1325     }
1326
1327     /*26 : sim.ztyp   */
1328     il_sim_ztyp = (int *) (listentry(il_sim, 26));
1329     m_ztyp = il_sim_ztyp[1];
1330     n_ztyp = il_sim_ztyp[2];
1331     if ((l_sim_ztyp = (int *) MALLOC((m_ztyp * n_ztyp) * sizeof(int))) == NULL )
1332     {
1333         Scierror(999, _("%s: Memory allocation error.\n"), fname);
1334         FREE(l_sim_nb);
1335         FREE(l_sim_critev);
1336         FREE(l_sim_zord);
1337         FREE(l_sim_oord);
1338         FREE(l_sim_cord);
1339         FREE(l_sim_ordclk);
1340         FREE(l_sim_execlk);
1341         FREE(l_sim_ordptr);
1342         FREE(l_sim_clkptr);
1343         FREE(l_sim_opptr);
1344         FREE(l_sim_ipptr);
1345         FREE(l_sim_ipar);
1346         FREE(l_sim_rpptr);
1347         FREE(l_sim_outlnk);
1348         FREE(l_sim_inplnk);
1349         FREE(l_sim_outptr);
1350         FREE(l_sim_inpptr);
1351         FREE(l_sim_zcptr);
1352         FREE(l_sim_ozptr);
1353         FREE(l_sim_zptr);
1354         FREE(l_sim_xptr);
1355         FREE(l_state_evtspt);
1356         FREE(l_pointi);
1357         return 0;
1358     }
1359     else
1360     {
1361         for (i = 0; i < (m_ztyp * n_ztyp); i++)
1362         {
1363             l_sim_ztyp[i] = (int) ((double *)(il_sim_ztyp + 4))[i];
1364         }
1365     }
1366
1367     /*27 : sim.nblk   */
1368     il_sim_nblk = (int *) (listentry(il_sim, 27));
1369     m_nblk = il_sim_nblk[1];
1370     n_nblk = il_sim_nblk[2];
1371     if ((l_sim_nblk = (int *) MALLOC((m_nblk * n_nblk) * sizeof(int))) == NULL )
1372     {
1373         Scierror(999, _("%s: Memory allocation error.\n"), fname);
1374         FREE(l_sim_ztyp);
1375         FREE(l_sim_nb);
1376         FREE(l_sim_critev);
1377         FREE(l_sim_zord);
1378         FREE(l_sim_oord);
1379         FREE(l_sim_cord);
1380         FREE(l_sim_ordclk);
1381         FREE(l_sim_execlk);
1382         FREE(l_sim_ordptr);
1383         FREE(l_sim_clkptr);
1384         FREE(l_sim_opptr);
1385         FREE(l_sim_ipptr);
1386         FREE(l_sim_ipar);
1387         FREE(l_sim_rpptr);
1388         FREE(l_sim_outlnk);
1389         FREE(l_sim_inplnk);
1390         FREE(l_sim_outptr);
1391         FREE(l_sim_inpptr);
1392         FREE(l_sim_zcptr);
1393         FREE(l_sim_ozptr);
1394         FREE(l_sim_zptr);
1395         FREE(l_sim_xptr);
1396         FREE(l_state_evtspt);
1397         FREE(l_pointi);
1398         return 0;
1399     }
1400     else
1401     {
1402         for (i = 0; i < (m_nblk * n_nblk); i++)
1403         {
1404             l_sim_nblk[i] = (int) ((double *)(il_sim_ztyp + 4))[i];
1405         }
1406     }
1407
1408     /*28 : sim.ndcblk */
1409     il_sim_ndcblk = (int *) (listentry(il_sim, 28));
1410     m_ndcblk = il_sim_ndcblk[1];
1411     n_ndcblk = il_sim_ndcblk[2];
1412     if ((l_sim_ndcblk = (int *) MALLOC((m_ndcblk * n_ndcblk) * sizeof(int))) == NULL )
1413     {
1414         Scierror(999, _("%s: Memory allocation error.\n"), fname);
1415         FREE(l_sim_nblk);
1416         FREE(l_sim_ztyp);
1417         FREE(l_sim_nb);
1418         FREE(l_sim_critev);
1419         FREE(l_sim_zord);
1420         FREE(l_sim_oord);
1421         FREE(l_sim_cord);
1422         FREE(l_sim_ordclk);
1423         FREE(l_sim_execlk);
1424         FREE(l_sim_ordptr);
1425         FREE(l_sim_clkptr);
1426         FREE(l_sim_opptr);
1427         FREE(l_sim_ipptr);
1428         FREE(l_sim_ipar);
1429         FREE(l_sim_rpptr);
1430         FREE(l_sim_outlnk);
1431         FREE(l_sim_inplnk);
1432         FREE(l_sim_outptr);
1433         FREE(l_sim_inpptr);
1434         FREE(l_sim_zcptr);
1435         FREE(l_sim_ozptr);
1436         FREE(l_sim_zptr);
1437         FREE(l_sim_xptr);
1438         FREE(l_state_evtspt);
1439         FREE(l_pointi);
1440         return 0;
1441     }
1442     else
1443     {
1444         for (i = 0; i < (m_ndcblk * n_ndcblk); i++)
1445         {
1446             l_sim_ndcblk[i] = (int) ((double *)(il_sim_ndcblk + 4))[i];
1447         }
1448     }
1449
1450     /*29 : sim.subscr */
1451     il_sim_subscr = (int *) (listentry(il_sim, 29));
1452     m_subscr = il_sim_subscr[1];
1453     n_subscr = il_sim_subscr[2];
1454     if (m_subscr * n_subscr == 0)
1455     {
1456         l_sim_subscr = NULL;
1457     }
1458     else
1459     {
1460         if ((l_sim_subscr = (int *) MALLOC((m_subscr * n_subscr) * sizeof(int))) == NULL )
1461         {
1462             Scierror(999, _("%s: Memory allocation error.\n"), fname);
1463             FREE(l_sim_ndcblk);
1464             FREE(l_sim_nblk);
1465             FREE(l_sim_ztyp);
1466             FREE(l_sim_nb);
1467             FREE(l_sim_critev);
1468             FREE(l_sim_zord);
1469             FREE(l_sim_oord);
1470             FREE(l_sim_cord);
1471             FREE(l_sim_ordclk);
1472             FREE(l_sim_execlk);
1473             FREE(l_sim_ordptr);
1474             FREE(l_sim_clkptr);
1475             FREE(l_sim_opptr);
1476             FREE(l_sim_ipptr);
1477             FREE(l_sim_ipar);
1478             FREE(l_sim_rpptr);
1479             FREE(l_sim_outlnk);
1480             FREE(l_sim_inplnk);
1481             FREE(l_sim_outptr);
1482             FREE(l_sim_inpptr);
1483             FREE(l_sim_zcptr);
1484             FREE(l_sim_ozptr);
1485             FREE(l_sim_zptr);
1486             FREE(l_sim_xptr);
1487             FREE(l_state_evtspt);
1488             FREE(l_pointi);
1489             return 0;
1490         }
1491         else
1492         {
1493             for (i = 0; i < (m_subscr * n_subscr); i++)
1494             {
1495                 l_sim_subscr[i] = (int) ((double *)(il_sim_subscr + 4))[i];
1496             }
1497         }
1498     }
1499
1500     /*30 : sim.funtyp */
1501     il_sim_funtyp = (int *) (listentry(il_sim, 30));
1502     m_funtyp = il_sim_funtyp[1];
1503     n_funtyp = il_sim_funtyp[2];
1504     if ((l_sim_funtyp = (int *) MALLOC((m_funtyp * n_funtyp) * sizeof(int))) == NULL )
1505     {
1506         Scierror(999, _("%s: Memory allocation error.\n"), fname);
1507         FREE(l_sim_subscr);
1508         FREE(l_sim_ndcblk);
1509         FREE(l_sim_nblk);
1510         FREE(l_sim_ztyp);
1511         FREE(l_sim_nb);
1512         FREE(l_sim_critev);
1513         FREE(l_sim_zord);
1514         FREE(l_sim_oord);
1515         FREE(l_sim_cord);
1516         FREE(l_sim_ordclk);
1517         FREE(l_sim_execlk);
1518         FREE(l_sim_ordptr);
1519         FREE(l_sim_clkptr);
1520         FREE(l_sim_opptr);
1521         FREE(l_sim_ipptr);
1522         FREE(l_sim_ipar);
1523         FREE(l_sim_rpptr);
1524         FREE(l_sim_outlnk);
1525         FREE(l_sim_inplnk);
1526         FREE(l_sim_outptr);
1527         FREE(l_sim_inpptr);
1528         FREE(l_sim_zcptr);
1529         FREE(l_sim_ozptr);
1530         FREE(l_sim_zptr);
1531         FREE(l_sim_xptr);
1532         FREE(l_state_evtspt);
1533         FREE(l_pointi);
1534         return 0;
1535     }
1536     else
1537     {
1538         for (i = 0; i < (m_funtyp * n_funtyp); i++)
1539         {
1540             l_sim_funtyp[i] = (int) ((double *)(il_sim_funtyp + 4))[i];
1541         }
1542     }
1543
1544     /*31 : sim.iord   */
1545     il_sim_iord = (int *) (listentry(il_sim, 31));
1546     m_iord = il_sim_iord[1];
1547     n_iord = il_sim_iord[2];
1548     if (m_iord * n_iord == 0)
1549     {
1550         l_sim_iord = NULL;
1551     }
1552     else
1553     {
1554         if ((l_sim_iord = (int *) MALLOC((m_iord * n_iord) * sizeof(int))) == NULL )
1555         {
1556             Scierror(999, _("%s: Memory allocation error.\n"), fname);
1557             FREE(l_sim_funtyp);
1558             FREE(l_sim_subscr);
1559             FREE(l_sim_ndcblk);
1560             FREE(l_sim_nblk);
1561             FREE(l_sim_ztyp);
1562             FREE(l_sim_nb);
1563             FREE(l_sim_critev);
1564             FREE(l_sim_zord);
1565             FREE(l_sim_oord);
1566             FREE(l_sim_cord);
1567             FREE(l_sim_ordclk);
1568             FREE(l_sim_execlk);
1569             FREE(l_sim_ordptr);
1570             FREE(l_sim_clkptr);
1571             FREE(l_sim_opptr);
1572             FREE(l_sim_ipptr);
1573             FREE(l_sim_ipar);
1574             FREE(l_sim_rpptr);
1575             FREE(l_sim_outlnk);
1576             FREE(l_sim_inplnk);
1577             FREE(l_sim_outptr);
1578             FREE(l_sim_inpptr);
1579             FREE(l_sim_zcptr);
1580             FREE(l_sim_ozptr);
1581             FREE(l_sim_zptr);
1582             FREE(l_sim_xptr);
1583             FREE(l_state_evtspt);
1584             FREE(l_pointi);
1585             return 0;
1586         }
1587         else
1588         {
1589             for (i = 0; i < (m_iord * n_iord); i++)
1590             {
1591                 l_sim_iord[i] = (int) ((double *)(il_sim_iord + 4))[i];
1592             }
1593         }
1594     }
1595
1596     /*32 : sim.labels */
1597     il_sim_lab = (int *) (listentry(il_sim, 32));
1598     m_lab = il_sim_lab[1];
1599     n_lab = il_sim_lab[2];
1600     il_sim_labptr = &il_sim_lab[4];  /*get address-1 of first pointer in labels*/
1601     l_sim_lab = (int *) (il_sim_lab + m_lab + 5); /*get address of first string in labels*/
1602
1603     /*33 : sim.modptr */
1604     il_sim_modptr = (int *) (listentry(il_sim, 33));
1605     m_modptr = il_sim_modptr[1];
1606     n_modptr = il_sim_modptr[2];
1607     if ((l_sim_modptr = (int *) MALLOC((m_modptr * n_modptr) * sizeof(int))) == NULL )
1608     {
1609         Scierror(999, _("%s: Memory allocation error.\n"), fname);
1610         FREE(l_sim_iord);
1611         FREE(l_sim_funtyp);
1612         FREE(l_sim_subscr);
1613         FREE(l_sim_ndcblk);
1614         FREE(l_sim_nblk);
1615         FREE(l_sim_ztyp);
1616         FREE(l_sim_nb);
1617         FREE(l_sim_critev);
1618         FREE(l_sim_zord);
1619         FREE(l_sim_oord);
1620         FREE(l_sim_cord);
1621         FREE(l_sim_ordclk);
1622         FREE(l_sim_execlk);
1623         FREE(l_sim_ordptr);
1624         FREE(l_sim_clkptr);
1625         FREE(l_sim_opptr);
1626         FREE(l_sim_ipptr);
1627         FREE(l_sim_ipar);
1628         FREE(l_sim_rpptr);
1629         FREE(l_sim_outlnk);
1630         FREE(l_sim_inplnk);
1631         FREE(l_sim_outptr);
1632         FREE(l_sim_inpptr);
1633         FREE(l_sim_zcptr);
1634         FREE(l_sim_ozptr);
1635         FREE(l_sim_zptr);
1636         FREE(l_sim_xptr);
1637         FREE(l_state_evtspt);
1638         FREE(l_pointi);
1639         return 0;
1640     }
1641     else
1642     {
1643         for (i = 0; i < (m_modptr * n_modptr); i++)
1644         {
1645             l_sim_modptr[i] = (int) ((double *)(il_sim_modptr + 4))[i];
1646         }
1647     }
1648
1649     /*************
1650     * str (rhs 5)
1651     *************/
1652     il_str = (int *) GetData(5);
1653     m5 = il_str[1];
1654     n5 = il_str[2];
1655     l_str = (int *) (il_str + 6);
1656     CheckDims(5, m5, n5, m5, 1);
1657
1658     sz_str = il_str[5] - 1; /*store the length of str*/
1659     C2F(cha1).buf[0] = ' ';
1660     C2F(cvstr)(&sz_str, &l_str[0], &C2F(cha1).buf[0], (j = 1, &j), sz_str); /*codetoascii*/
1661     C2F(cha1).buf[sz_str] = '\0';
1662     if (strcmp(C2F(cha1).buf, "start") == 0)
1663     {
1664         flag = 1;
1665     }
1666     else if (strcmp(C2F(cha1).buf, "run") == 0)
1667     {
1668         flag = 2;
1669     }
1670     else if (strcmp(C2F(cha1).buf, "finish") == 0)
1671     {
1672         flag = 3;
1673     }
1674     else if (strcmp(C2F(cha1).buf, "linear") == 0)
1675     {
1676         flag = 4;
1677     }
1678     else if (strcmp(C2F(cha1).buf, "Kinsol") == 0)
1679     {
1680         flag = 5;
1681     }
1682     else
1683     {
1684         Scierror(44, "%s : Fifth argument is incorrect.\n", fname);
1685         freeparam;
1686         C2F(iop).err = 5;
1687         return 0;
1688     }
1689
1690     /*************
1691     * tol (rhs 6)
1692     *************/
1693     il_tol = (int *) GetData(6);
1694     l_tol = (double *) (il_tol + 4);
1695     m6 = il_tol[1];
1696     n6 = il_tol[2];
1697     m6 = m6 * n6;
1698     if (m6 < 4) /*Check if tol has a minimun of four elements*/
1699     {
1700         Scierror(89, _("%s : Sixth argument must have at least four elements.\n"), fname);
1701         freeparam;
1702         C2F(iop).err = 6;
1703         return 0;
1704     }
1705     else if (m6 > 7) /*Check if tol has a maximum of seven elements*/
1706     {
1707         Scierror(89, _("%s : Sixth argument must have a maximum of seven elements.\n"), fname);
1708         freeparam;
1709         C2F(iop).err = 6;
1710         return 0;
1711     }
1712
1713     /******************
1714     * set simpar array
1715     ******************/
1716     if (m6 == 4)
1717     {
1718         for (i = 0; i < 4; i++)
1719         {
1720             simpar[i] = l_tol[i];
1721         }
1722         simpar[4] = 0;
1723         simpar[5] = 0;
1724         simpar[6] = 0;
1725     }
1726     else if (m6 == 5)
1727     {
1728         for (i = 0; i < 5; i++)
1729         {
1730             simpar[i] = l_tol[i];
1731         }
1732         simpar[5] = 0;
1733         simpar[6] = 0;
1734     }
1735     else if (m6 == 6)
1736     {
1737         for (i = 0; i < 6; i++)
1738         {
1739             simpar[i] = l_tol[i];
1740         }
1741         simpar[6] = 0;
1742     }
1743     else for (i = 0; i < 7; i++)
1744         {
1745             simpar[i] = l_tol[i];
1746         }
1747     solver = (int)simpar[5]; /*set solver variable*/
1748
1749     /******************************
1750     * cross variable size checking
1751     ******************************/
1752     err_check = 0;
1753     if (m1e6 != m1e7)
1754     {
1755         err_check = 1;    /*tevts vs evtspt*/
1756     }
1757     else if (m_xptr != m_zptr)
1758     {
1759         err_check = 2;    /*xptr vs zptr*/
1760     }
1761     else if (m_xptr != m_ozptr)
1762     {
1763         err_check = 3;    /*xptr vs ozptr*/
1764     }
1765     else if (m_xptr != m_zcptr)
1766     {
1767         err_check = 4;    /*xptr vs zcptr*/
1768     }
1769     else if (m_xptr != m_inpptr)
1770     {
1771         err_check = 5;    /*xptr vs inpptr*/
1772     }
1773     else if (m_xptr != m_outptr)
1774     {
1775         err_check = 6;    /*xptr vs outptr*/
1776     }
1777     else if (m_xptr != m_rpptr)
1778     {
1779         err_check = 7;    /*xptr vs rpptr*/
1780     }
1781     else if (m_xptr != m_ipptr)
1782     {
1783         err_check = 8;    /*xptr vs ipptr*/
1784     }
1785     else if (m_xptr != m_opptr)
1786     {
1787         err_check = 8;    /*xptr vs opptr*/
1788     }
1789     else if (m_xptr != m_clkptr)
1790     {
1791         err_check = 10;    /*xptr vs clkptr*/
1792     }
1793     else if ((n_ordclk != 2) & (m_ordclk != 0))
1794     {
1795         err_check = 11;    /*sim.ordclk*/
1796     }
1797     else if ((n_cord != 2) & (m_cord != 0))
1798     {
1799         err_check = 12;    /*sim.cord*/
1800     }
1801     else if ((n_oord != 2) & (m_oord != 0))
1802     {
1803         err_check = 13;    /*sim.oord*/
1804     }
1805     else if ((n_zord != 2) & (m_zord != 0))
1806     {
1807         err_check = 14;    /*sim.zord*/
1808     }
1809     else if ((n_iord != 2) & (m_iord != 0))
1810     {
1811         err_check = 15;    /*sim.iord*/
1812     }
1813     if (err_check != 0)
1814     {
1815         /* please write an error table here  */
1816         Scierror(42, _("%s : error in cross variable size checking : %d\n"), \
1817                  fname, err_check);
1818         freeparam;
1819         return 0;
1820     }
1821
1822     /*******************************
1823     * set function table for blocks
1824     *******************************/
1825     il4 = iadr(*Lstk(Top - Rhs + 4)); /*sim*/
1826     l4 = sadr(il4 + m4 + 3);
1827     il4e2 = iadr(l4 + *istk(il4 + 3) - 1);
1828     l4e2 = sadr(il4e2 + nblk + 3);
1829     lf = l4e2;  /*first element of the list sim.funs*/
1830     /*define new variable lfunpt*/
1831     if ((lfunpt = (int *) MALLOC(nblk * sizeof(int))) == NULL )
1832     {
1833         Scierror(999, _("%s: Memory allocation error.\n"), fname);
1834         freeparam;
1835         return 0;
1836     }
1837
1838     /*for each block*/
1839     for (i = 0; i < nblk; i++)
1840     {
1841         ilf = iadr(lf); /*should be removed later*/
1842         subheader = (int *)(listentry(il_sim_fun, i + 1));
1843         /*Block is defined by a scilab function*/
1844         if ((subheader[0] == 11) | (subheader[0] == 13))
1845         {
1846             lfunpt[i] = -lf;
1847         }
1848         /*Block is defined by a function described by a characater strings*/
1849         else if (subheader[0] == 10)
1850         {
1851             sz_str = subheader[5] - 1; /*store the length of function name*/
1852             C2F(cha1).buf[0] = ' ';
1853             C2F(cvstr)(&sz_str, &subheader[6], &C2F(cha1).buf[0], (j = 1, &j), sz_str); /*codetoascii*/
1854             C2F(cha1).buf[sz_str] = '\0';
1855             ifun = C2F(funnum)(C2F(cha1).buf); /*search associated function number of function name*/
1856             /*Block is defined by a C or Fortran function*/
1857             if (ifun > 0)
1858             {
1859                 lfunpt[i] = ifun;
1860             }
1861             /*Block is defined by a predefined scilab function*/
1862             else
1863             {
1864                 C2F(namstr)(id, &subheader[6], &sz_str, (j = 0, &j));
1865                 C2F(com).fin = 0;
1866                 C2F(funs)(id);
1867                 if ((C2F(com).fun == -1) | (C2F(com).fun == -2))
1868                 {
1869                     lfunpt[i] = -*Lstk(C2F(com).fin);
1870                 }
1871                 else
1872                 {
1873                     C2F(curblk).kfun = i + 1;
1874                     Scierror(888, _("%s : unknown block : %s\n"), fname, C2F(cha1).buf);
1875                     FREE(lfunpt);
1876                     freeparam;
1877                     return 0;
1878                 }
1879             }
1880         }
1881         else
1882         {
1883             C2F(iop).err = 4;
1884             Scierror(44, _("%s : error\n"), fname);
1885             FREE(lfunpt);
1886             freeparam;
1887             return 0;
1888         }
1889         lf = lf + *istk(il4e2 + 3 + i) - *istk(il4e2 + i + 2);
1890     }
1891
1892     /**********************
1893     * set oz, ozsz, oztyp
1894     **********************/
1895     if (noz == 0)
1896     {
1897         oz = NULL;
1898         ozsz = NULL;
1899         oztyp = NULL;
1900     }
1901     else
1902     {
1903         /*Allocation of oz*/
1904         if ((oz = (void **) MALLOC((noz) * sizeof(void *))) == NULL )
1905         {
1906             Scierror(999, _("%s: Memory allocation error.\n"), fname);
1907             FREE(lfunpt);
1908             freeparam;
1909             return 0;
1910         }
1911         /*Allocation of ozsz*/
1912         if ((ozsz = (int *) MALLOC(2 * (noz) * sizeof(int))) == NULL )
1913         {
1914             Scierror(999, _("%s: Memory allocation error.\n"), fname);
1915             FREE(oz);
1916             FREE(lfunpt);
1917             freeparam;
1918             return 0;
1919         }
1920         /*Allocation of oztyp*/
1921         if ((oztyp = (int *) MALLOC((noz) * sizeof(int))) == NULL )
1922         {
1923             Scierror(999, _("%s: Memory allocation error.\n"), fname);
1924             FREE(oz);
1925             FREE(ozsz);
1926             FREE(lfunpt);
1927             freeparam;
1928             return 0;
1929         }
1930
1931         /*set vectors of oz*/
1932         for (j = 0; j < noz; j++)
1933         {
1934             subheader = (int *)(listentry(il_state_oz, j + 1));
1935
1936             switch (subheader[0]) /*store type and address*/
1937             {
1938                     /*matrix of double*/
1939                 case 1  :
1940                     switch (subheader[3])
1941                     {
1942                         case 0  :
1943                             oztyp[j] = SCSREAL_N; /*double real matrix*/
1944                             ozsz[j] = subheader[1];
1945                             ozsz[j + noz] = subheader[2];
1946                             oz[j] = (SCSREAL_COP *)(subheader + 4);
1947                             break;
1948
1949                         case 1  :
1950                             oztyp[j] = SCSCOMPLEX_N; /*double complex matrix*/
1951                             ozsz[j] = subheader[1];
1952                             ozsz[j + noz] = subheader[2];
1953                             oz[j] = (SCSCOMPLEX_COP *)(subheader + 4);
1954                             break;
1955
1956                         default :
1957                             oztyp[j] = SCSUNKNOW_N;
1958                             ozsz[j] = il_state_oz[3 + j] - il_state_oz[2 + j];
1959                             ozsz[j + noz] = 1;
1960                             oz[j] = (SCSUNKNOW_COP *)subheader;
1961                             break;
1962                     }
1963                     break;
1964
1965                     /*matrix of integers*/
1966                 case 8  :
1967                     switch (subheader[3])
1968                     {
1969                         case 1  :
1970                             oztyp[j] = SCSINT8_N; /*int8*/
1971                             ozsz[j] = subheader[1];
1972                             ozsz[j + noz] = subheader[2];
1973                             oz[j] = (SCSINT8_COP *)(subheader + 4);
1974                             break;
1975
1976                         case 2  :
1977                             oztyp[j] = SCSINT16_N; /*int16*/
1978                             ozsz[j] = subheader[1];
1979                             ozsz[j + noz] = subheader[2];
1980                             oz[j] = (SCSINT16_COP *)(subheader + 4);
1981                             break;
1982
1983                         case 4  :
1984                             oztyp[j] = SCSINT32_N; /*int32*/
1985                             ozsz[j] = subheader[1];
1986                             ozsz[j + noz] = subheader[2];
1987                             oz[j] = (SCSINT32_COP *)(subheader + 4);
1988                             break;
1989
1990                         case 11 :
1991                             oztyp[j] = SCSUINT8_N; /*uint8*/
1992                             ozsz[j] = subheader[1];
1993                             ozsz[j + noz] = subheader[2];
1994                             oz[j] = (SCSUINT8_COP *)(subheader + 4);
1995                             break;
1996
1997                         case 12 :
1998                             oztyp[j] = SCSUINT16_N; /*uint16*/
1999                             ozsz[j] = subheader[1];
2000                             ozsz[j + noz] = subheader[2];
2001                             oz[j] = (SCSUINT16_COP *)(subheader + 4);
2002                             break;
2003
2004                         case 14 :
2005                             oztyp[j] = SCSUINT32_N; /*uint32*/
2006                             ozsz[j] = subheader[1];
2007                             ozsz[j + noz] = subheader[2];
2008                             oz[j] = (SCSUINT32_COP *)(subheader + 4);
2009                             break;
2010
2011                         default :
2012                             oztyp[j] = SCSUNKNOW_N;
2013                             ozsz[j] = il_state_oz[3 + j] - il_state_oz[2 + j];
2014                             ozsz[j + noz] = 1;
2015                             oz[j] = (SCSUNKNOW_COP *)subheader;
2016                             break;
2017                     }
2018                     break;
2019
2020                 default :
2021                     oztyp[j] = SCSUNKNOW_N;
2022                     ozsz[j] = il_state_oz[3 + j] - il_state_oz[2 + j];
2023                     ozsz[j + noz] = 1;
2024                     oz[j] = (SCSUNKNOW_COP *)subheader;
2025                     break;
2026             }
2027         }
2028     }
2029
2030     /****************************
2031     * set opar, oparsz, opartyp
2032     ****************************/
2033     if (nopar == 0)
2034     {
2035         opar = NULL;
2036         oparsz = NULL;
2037         opartyp = NULL;
2038     }
2039     else
2040     {
2041         /*Allocation of opar*/
2042         if ((opar = (void **) MALLOC((nopar) * sizeof(void *))) == NULL )
2043         {
2044             Scierror(999, _("%s: Memory allocation error.\n"), fname);
2045             FREE(oz);
2046             FREE(ozsz);
2047             FREE(oztyp);
2048             FREE(lfunpt);
2049             freeparam;
2050             return 0;
2051         }
2052         /*Allocation of oparsz*/
2053         if ((oparsz = (int *) MALLOC(2 * (nopar) * sizeof(int))) == NULL )
2054         {
2055             Scierror(999, _("%s: Memory allocation error.\n"), fname);
2056             FREE(opar);
2057             FREE(oz);
2058             FREE(ozsz);
2059             FREE(oztyp);
2060             FREE(lfunpt);
2061             freeparam;
2062             return 0;
2063         }
2064         /*Allocation of opartyp*/
2065         if ((opartyp = (int *) MALLOC((nopar) * sizeof(int))) == NULL )
2066         {
2067             Scierror(999, _("%s: Memory allocation error.\n"), fname);
2068             FREE(opar);
2069             FREE(oparsz);
2070             FREE(oz);
2071             FREE(ozsz);
2072             FREE(oztyp);
2073             FREE(lfunpt);
2074             freeparam;
2075             return 0;
2076         }
2077
2078         /*set vectors of opar*/
2079         for (j = 0; j < nopar; j++)
2080         {
2081             subheader = (int *)(listentry(il_sim_opar, j + 1));
2082
2083             switch (subheader[0]) /*store type and address*/
2084             {
2085                     /*matrix of double*/
2086                 case 1  :
2087                     switch (subheader[3])
2088                     {
2089                         case 0  :
2090                             opartyp[j] = SCSREAL_N; /*double real matrix*/
2091                             oparsz[j] = subheader[1];
2092                             oparsz[j + nopar] = subheader[2];
2093                             opar[j] = (SCSREAL_COP *)(subheader + 4);
2094                             break;
2095
2096                         case 1  :
2097                             opartyp[j] = SCSCOMPLEX_N; /*double complex matrix*/
2098                             oparsz[j] = subheader[1];
2099                             oparsz[j + nopar] = subheader[2];
2100                             opar[j] = (SCSCOMPLEX_COP *)(subheader + 4);
2101                             break;
2102
2103                         default :
2104                             opartyp[j] = SCSUNKNOW_N;
2105                             oparsz[j] = il_sim_opar[3 + j] - il_sim_opar[2 + j];
2106                             oparsz[j + nopar] = 1;
2107                             opar[j] = (SCSUNKNOW_COP *)subheader;
2108                             break;
2109                     }
2110                     break;
2111
2112                     /*matrix of integers*/
2113                 case 8  :
2114                     switch (subheader[3])
2115                     {
2116                         case 1  :
2117                             opartyp[j] = SCSINT8_N; /*int8*/
2118                             oparsz[j] = subheader[1];
2119                             oparsz[j + nopar] = subheader[2];
2120                             opar[j] = (SCSINT8_COP *)(subheader + 4);
2121                             break;
2122
2123                         case 2  :
2124                             opartyp[j] = SCSINT16_N; /*int16*/
2125                             oparsz[j] = subheader[1];
2126                             oparsz[j + nopar] = subheader[2];
2127                             opar[j] = (SCSINT16_COP *)(subheader + 4);
2128                             break;
2129
2130                         case 4  :
2131                             opartyp[j] = SCSINT32_N; /*int32*/
2132                             oparsz[j] = subheader[1];
2133                             oparsz[j + nopar] = subheader[2];
2134                             opar[j] = (SCSINT32_COP *)(subheader + 4);
2135                             break;
2136
2137                         case 11 :
2138                             opartyp[j] = SCSUINT8_N; /*uint8*/
2139                             oparsz[j] = subheader[1];
2140                             oparsz[j + nopar] = subheader[2];
2141                             opar[j] = (SCSUINT8_COP *)(subheader + 4);
2142                             break;
2143
2144                         case 12 :
2145                             opartyp[j] = SCSUINT16_N; /*uint16*/
2146                             oparsz[j] = subheader[1];
2147                             oparsz[j + nopar] = subheader[2];
2148                             opar[j] = (SCSUINT16_COP *)(subheader + 4);
2149                             break;
2150
2151                         case 14 :
2152                             opartyp[j] = SCSUINT32_N; /*uint32*/
2153                             oparsz[j] = subheader[1];
2154                             oparsz[j + nopar] = subheader[2];
2155                             opar[j] = (SCSUINT32_COP *)(subheader + 4);
2156                             break;
2157
2158                         default :
2159                             opartyp[j] = SCSUNKNOW_N;
2160                             oparsz[j] = il_sim_opar[3 + j] - il_sim_opar[2 + j];
2161                             oparsz[j + nopar] = 1;
2162                             opar[j] = (SCSUNKNOW_COP *)subheader;
2163                             break;
2164                     }
2165                     break;
2166
2167                 default :
2168                     opartyp[j] = SCSUNKNOW_N;
2169                     oparsz[j] = il_sim_opar[3 + j] - il_sim_opar[2 + j];
2170                     oparsz[j + nopar] = 1;
2171                     opar[j] = (SCSUNKNOW_COP *)subheader;
2172                     break;
2173             }
2174         }
2175     }
2176
2177     /*******************************
2178     * set outtbptr,outtbsz,outtbtyp
2179     *******************************/
2180     if (nlnk == 0)
2181     {
2182         outtbptr = NULL;
2183         outtbsz = NULL;
2184         outtbtyp = NULL;
2185         outtb_elem = NULL;
2186         nelem = 0;
2187     }
2188     else
2189     {
2190         /*Allocation of outtbptr*/
2191         if ((outtbptr = (void **) MALLOC(nlnk * sizeof(void *))) == NULL )
2192         {
2193             Scierror(999, _("%s: Memory allocation error.\n"), fname);
2194             FREE(opar);
2195             FREE(oparsz);
2196             FREE(opartyp);
2197             FREE(oz);
2198             FREE(ozsz);
2199             FREE(oztyp);
2200             FREE(lfunpt);
2201             freeparam;
2202             return 0;
2203         }
2204         /*Allocation of outtbsz*/
2205         if ((outtbsz = (int *) MALLOC(nlnk * 2 * sizeof(int))) == NULL )
2206         {
2207             Scierror(999, _("%s: Memory allocation error.\n"), fname);
2208             FREE(outtbptr);
2209             FREE(opar);
2210             FREE(oparsz);
2211             FREE(opartyp);
2212             FREE(oz);
2213             FREE(ozsz);
2214             FREE(oztyp);
2215             FREE(lfunpt);
2216             freeparam;
2217             return 0;
2218         }
2219         /*Allocation of outtbtyp*/
2220         if ((outtbtyp = (int *) MALLOC(nlnk * sizeof(int))) == NULL )
2221         {
2222             Scierror(999, _("%s: Memory allocation error.\n"), fname);
2223             FREE(outtbsz);
2224             FREE(outtbptr);
2225             FREE(opar);
2226             FREE(oparsz);
2227             FREE(opartyp);
2228             FREE(oz);
2229             FREE(ozsz);
2230             FREE(oztyp);
2231             FREE(lfunpt);
2232             freeparam;
2233             return 0;
2234         }
2235
2236         /*initalize nelem*/
2237         nelem = 0;
2238
2239         /*set vectors of outtb*/
2240         for (j = 0; j < nlnk; j++) /*for each link*/
2241         {
2242             subheader = (int *)(listentry(il_state_outtb, j + 1)); /*get header of outtbl(j+1)*/
2243             outtbsz[j] = subheader[1]; /*store dimensions*/
2244             outtbsz[j + nlnk] = subheader[2];
2245
2246             switch (subheader[0]) /*store type and address*/
2247             {
2248                     /*matrix of double*/
2249                 case 1  :
2250                     switch (subheader[3])
2251                     {
2252                         case 0  :
2253                             outtbtyp[j] = SCSREAL_N; /*double real matrix*/
2254                             outtbptr[j] = (SCSREAL_COP *)(subheader + 4);
2255                             break;
2256
2257                         case 1  :
2258                             outtbtyp[j] = SCSCOMPLEX_N; /*double complex matrix*/
2259                             outtbptr[j] = (SCSCOMPLEX_COP *)(subheader + 4);
2260                             break;
2261
2262                         default :
2263                             Scierror(888, _("%s : error. Type %d of double scalar matrix not yet supported for outtb.\n"), \
2264                                      fname, subheader[3]);
2265                             FREE(outtbptr);
2266                             FREE(outtbtyp);
2267                             FREE(outtbsz);
2268                             FREE(opar);
2269                             FREE(oparsz);
2270                             FREE(opartyp);
2271                             FREE(oz);
2272                             FREE(ozsz);
2273                             FREE(oztyp);
2274                             FREE(lfunpt);
2275                             freeparam;
2276                             FREE(outtb_elem);
2277                             break;
2278                     }
2279                     break;
2280
2281                     /*matrix of integers*/
2282                 case 8  :
2283                     switch (subheader[3])
2284                     {
2285                         case 1  :
2286                             outtbtyp[j] = SCSINT8_N; /*int8*/
2287                             outtbptr[j] = (SCSINT8_COP *)(subheader + 4);
2288                             break;
2289
2290                         case 2  :
2291                             outtbtyp[j] = SCSINT16_N; /*int16*/
2292                             outtbptr[j] = (SCSINT16_COP *)(subheader + 4);
2293                             break;
2294
2295                         case 4  :
2296                             outtbtyp[j] = SCSINT32_N; /*int32*/
2297                             outtbptr[j] = (SCSINT32_COP *)(subheader + 4);
2298                             break;
2299
2300                         case 11 :
2301                             outtbtyp[j] = SCSUINT8_N; /*uint8*/
2302                             outtbptr[j] = (SCSUINT8_COP *)(subheader + 4);
2303                             break;
2304
2305                         case 12 :
2306                             outtbtyp[j] = SCSUINT16_N; /*uint16*/
2307                             outtbptr[j] = (SCSUINT16_COP *)(subheader + 4);
2308                             break;
2309
2310                         case 14 :
2311                             outtbtyp[j] = SCSUINT32_N; /*uint32*/
2312                             outtbptr[j] = (SCSUINT32_COP *)(subheader + 4);
2313                             break;
2314
2315                         default :
2316                             Scierror(888, \
2317                                      _("%s : error. Type %d of int scalar matrix not yet supported for outtb.\n"), \
2318                                      fname, subheader[3]);
2319                             FREE(outtbptr);
2320                             FREE(outtbtyp);
2321                             FREE(outtbsz);
2322                             FREE(opar);
2323                             FREE(oparsz);
2324                             FREE(opartyp);
2325                             FREE(oz);
2326                             FREE(ozsz);
2327                             FREE(oztyp);
2328                             FREE(lfunpt);
2329                             freeparam;
2330                             FREE(outtb_elem);
2331                             break;
2332                     }
2333                     break;
2334
2335                 default :
2336                     Scierror(888, _("%s : error. Type %d not yet supported for outtb.\n"), fname, subheader[0]);
2337                     FREE(outtbptr);
2338                     FREE(outtbtyp);
2339                     FREE(outtbsz);
2340                     FREE(opar);
2341                     FREE(oparsz);
2342                     FREE(opartyp);
2343                     FREE(oz);
2344                     FREE(ozsz);
2345                     FREE(oztyp);
2346                     FREE(lfunpt);
2347                     freeparam;
2348                     FREE(outtb_elem);
2349                     return 0;
2350                     break;
2351             }
2352
2353             /* store lnk and pos in outtb_elem */
2354             k = nelem;
2355             nelem += outtbsz[j] * outtbsz[j + nlnk];
2356             if ((outtb_elem = (outtb_el *) REALLOC(outtb_elem, nelem * sizeof(outtb_el))) == NULL)
2357             {
2358                 Scierror(999, _("%s : No more free memory.\n"), fname);
2359                 FREE(outtbptr);
2360                 FREE(outtbtyp);
2361                 FREE(outtbsz);
2362                 FREE(opar);
2363                 FREE(oparsz);
2364                 FREE(opartyp);
2365                 FREE(oz);
2366                 FREE(ozsz);
2367                 FREE(oztyp);
2368                 FREE(lfunpt);
2369                 freeparam;
2370                 FREE(outtb_elem);
2371                 return 0;
2372             }
2373             for (i = 0; i < outtbsz[j]*outtbsz[j + nlnk]; i++)
2374             {
2375                 outtb_elem[k + i].lnk = j;
2376                 outtb_elem[k + i].pos = i;
2377             }
2378         }
2379     }
2380
2381     /********************************
2382     * save intersci common
2383     * see intersci_push in stack2.c
2384     ********************************/
2385     Nbvars = Rhs; /*because of the use of getdata*/
2386     new = MALLOC(Rhs * sizeof(intersci_state));
2387     if (new == NULL)
2388     {
2389         Scierror(999, _("%s: Memory allocation error.\n"), fname);
2390         FREE(outtbptr);
2391         FREE(outtbtyp);
2392         FREE(outtbsz);
2393         FREE(opar);
2394         FREE(oparsz);
2395         FREE(opartyp);
2396         FREE(oz);
2397         FREE(ozsz);
2398         FREE(oztyp);
2399         FREE(lfunpt);
2400         FREE(outtb_elem);
2401         freeparam;
2402         return 0;
2403     }
2404     loc = MALLOC(sizeof(intersci_list));
2405     if (loc == NULL)
2406     {
2407         Scierror(999, _("%s: Memory allocation error.\n"), fname);
2408         FREE(outtbptr);
2409         FREE(outtbtyp);
2410         FREE(outtbsz);
2411         FREE(opar);
2412         FREE(oparsz);
2413         FREE(opartyp);
2414         FREE(oz);
2415         FREE(ozsz);
2416         FREE(oztyp);
2417         FREE(lfunpt);
2418         FREE(outtb_elem);
2419         FREE(new);
2420         freeparam;
2421         return 0;
2422     }
2423     loc->state = new;
2424     loc->nbvars = Nbvars;
2425     for (i = 0; i < Rhs; i++)
2426     {
2427         loc->state[i].iwhere = C2F(intersci).iwhere[i];
2428         loc->state[i].ntypes = C2F(intersci).ntypes[i];
2429         loc->state[i].lad    = C2F(intersci).lad[i];
2430         loc->state[i].lhsvar = C2F(intersci).lhsvar[i];
2431     }
2432
2433     /************************
2434     * call scicos simulator
2435     ************************/
2436     if (C2F(iop).ddt != 0)
2437     {
2438         C2F(dbcos).idb = 1;    /*debug mode if ddt=0*/
2439     }
2440     C2F(cosim).isrun = 1; /*set isrun=1 to say that we enter in the simulator*/
2441
2442     /* Calling sequence :
2443     * int C2F(scicos)(double *x_in, int *xptr_in, double *z__,
2444     *                 void **work,int *zptr,int *modptr_in,
2445     *                 void **oz,int *ozsz,int *oztyp,int *ozptr,
2446     *                 int *iz,int *izptr,double *t0_in,
2447     *                 double *tf_in,double *tevts_in,int *evtspt_in,
2448     *                 int *nevts,int *pointi_in,void **outtbptr_in,
2449     *                 int *outtbsz_in,int *outtbtyp_in,
2450     *                 outtb_el *outtb_elem_in,int *nelem1,int *nlnk1,
2451     *                 int *funptr,int *funtyp_in,int *inpptr_in,
2452     *                 int *outptr_in, int *inplnk_in,int *outlnk_in,
2453     *                 double *rpar,int *rpptr,int *ipar,int *ipptr,
2454     *                 void **opar,int *oparsz,int *opartyp,int *opptr,
2455     *                 int *clkptr_in,int *ordptr_in,int *nordptr1,
2456     *                 int *ordclk_in,int *cord_in,int *ncord1,
2457     *                 int *iord_in,int *niord1,int *oord_in,
2458     *                 int *noord1,int *zord_in,int *nzord1,
2459     *                 int *critev_in,int *nblk1,int *ztyp,
2460     *                 int *zcptr_in,int *subscr,int *nsubs,
2461     *                 double *simpar,int *flag__,int *ierr_out)
2462     */
2463
2464     C2F(scicos)(l_state_x, l_sim_xptr, l_state_z,
2465                 l_state_iz, l_sim_zptr, l_sim_modptr,
2466                 oz, ozsz, oztyp, l_sim_ozptr,
2467                 l_sim_lab, il_sim_labptr, l_tcur,
2468                 l_tf, l_state_tevts, l_state_evtspt,
2469                 &m1e5, l_pointi, outtbptr,
2470                 outtbsz, outtbtyp,
2471                 outtb_elem, &nelem, &nlnk,
2472                 lfunpt, l_sim_funtyp, l_sim_inpptr,
2473                 l_sim_outptr, l_sim_inplnk, l_sim_outlnk,
2474                 l_sim_rpar, l_sim_rpptr, l_sim_ipar, l_sim_ipptr,
2475                 opar, oparsz, opartyp, l_sim_opptr,
2476                 l_sim_clkptr, l_sim_ordptr, &m_ordptr,
2477                 l_sim_ordclk, l_sim_cord, &m_cord,
2478                 l_sim_iord, &m_iord, l_sim_oord,
2479                 &m_oord, l_sim_zord, &m_zord,
2480                 l_sim_critev, &nblk, l_sim_ztyp,
2481                 l_sim_zcptr, l_sim_subscr, &m_subscr,
2482                 simpar, &flag, &ierr);
2483
2484     C2F(dbcos).idb = 0; /*return in normal mode*/
2485     C2F(cosim).isrun = 0; /*return in normal mode*/
2486
2487     /******************************
2488     * retrieve intersci common
2489     * see intersci_pop in stack2.c
2490     ******************************/
2491     Nbvars = loc->nbvars;
2492     for (i = 0; i < Rhs; i++)
2493     {
2494         C2F(intersci).iwhere[i] = loc->state[i].iwhere ;
2495         C2F(intersci).ntypes[i] = loc->state[i].ntypes ;
2496         C2F(intersci).lad[i]    = loc->state[i].lad    ;
2497         C2F(intersci).lhsvar[i] = loc->state[i].lhsvar ;
2498     }
2499     FREE(loc->state);
2500     FREE(loc);
2501
2502     /**********************
2503     * Free allocated array
2504     **********************/
2505     FREE(outtbptr);
2506     FREE(outtbtyp);
2507     FREE(outtbsz);
2508     FREE(opar);
2509     FREE(oparsz);
2510     FREE(opartyp);
2511     FREE(oz);
2512     FREE(ozsz);
2513     FREE(oztyp);
2514     FREE(lfunpt);
2515     FREE(outtb_elem);
2516
2517     /*************************************
2518     * switch to appropriate message error
2519     *************************************/
2520     if (ierr > 0)
2521     {
2522         switch (ierr)
2523         {
2524             case 1  :
2525                 strcpy(C2F(cha1).buf, _("scheduling problem"));
2526                 C2F(curblk).kfun = 0;
2527                 break;
2528
2529             case 2  :
2530                 strcpy(C2F(cha1).buf, _("input to zero-crossing stuck on zero"));
2531                 C2F(curblk).kfun = 0;
2532                 break;
2533
2534             case 3  :
2535                 strcpy(C2F(cha1).buf, _("event conflict"));
2536                 C2F(curblk).kfun = 0;
2537                 break;
2538
2539             case 4  :
2540                 strcpy(C2F(cha1).buf, _("algebraic loop detected"));
2541                 C2F(curblk).kfun = 0;
2542                 break;
2543
2544             case 5  :
2545                 strcpy(C2F(cha1).buf, _("cannot allocate memory"));
2546                 C2F(curblk).kfun = 0;
2547                 break;
2548
2549             case 6  :
2550                 sprintf(C2F(cha1).buf, _("the block %d has been called with input out of its domain"), C2F(curblk).kfun);
2551                 break;
2552
2553             case 7  :
2554                 strcpy(C2F(cha1).buf, _("singularity in a block"));
2555                 break;
2556
2557             case 8  :
2558                 strcpy(C2F(cha1).buf, _("block produces an internal error"));
2559                 break;
2560
2561             case 10  :
2562                 strcpy(C2F(cha1).buf, coserr.buf);
2563                 break;
2564
2565             case 20  :
2566                 strcpy(C2F(cha1).buf, _("initial conditions not converging"));
2567                 break;
2568
2569             case 21  :
2570                 sprintf(C2F(cha1).buf, _("cannot allocate memory in block=%d"), C2F(curblk).kfun);
2571                 break;
2572
2573             case 22  :
2574                 strcpy(C2F(cha1).buf, _("sliding mode condition, cannot integrate"));
2575                 break;
2576
2577             case 23  :
2578                 strcpy(C2F(cha1).buf, _("Cannot find the initial mode, maybe there is a sliding mode condition"));
2579                 break;
2580             case 24  :
2581                 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."));
2582                 break;
2583
2584             case 25  :
2585                 strcpy(C2F(cha1).buf, _("Undefined data type."));
2586                 break;
2587             case 26  :
2588                 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"));
2589                 break;
2590                 /*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*/
2591
2592             default  :
2593                 if (ierr >= 1000)
2594                 {
2595                     strcpy(C2F(cha1).buf, _("unknown or erroneous block"));
2596                 }
2597                 else if (ierr >= 201 && ierr <= 416) /* Sundials error messages, stocked in coserr.buf */
2598                 {
2599                     strcpy(C2F(cha1).buf, coserr.buf);
2600                 }
2601                 else if (ierr >= 100)
2602                 {
2603                     istate = -(ierr - 100);
2604                     sprintf(C2F(cha1).buf, _("integration problem istate=%d"), istate);
2605                     C2F(curblk).kfun = 0;
2606                 }
2607                 else
2608                 {
2609                     strcpy(C2F(cha1).buf, _("scicos unexpected error, please report..."));
2610                     C2F(curblk).kfun = 0;
2611                 }
2612                 break;
2613         }
2614         if (! (C2F(errgst).err1 > 0 || C2F(iop).err > 0))
2615         {
2616             Scierror(888, "%s\n", C2F(cha1).buf);
2617             /*C2F(curblk).kfun=0;*/
2618             C2F(com).fun = 0; /*set common fun=0 (this disable bug in debug mode)*/
2619             freeparam;
2620             return 0;
2621         }
2622     }
2623
2624     if (C2F(iop).err > 0)
2625     {
2626         freeparam;
2627         return 0;
2628     }
2629
2630     /*C2F(curblk).kfun=0;*/
2631     C2F(com).fun = 0;
2632
2633     /*********************
2634     * return Lsh variable
2635     *********************/
2636     /*copy int parameters of state in double parameters*/
2637     for (i = 0; i < (m1e7 * n1e7); i++)
2638     {
2639         ((double *)(il_state_evtspt + 4))[i] = (double) l_state_evtspt[i];
2640     }
2641     for (i = 0; i < (m1e8 * n1e8); i++)
2642     {
2643         ((double *)(il_pointi + 4))[i] = (double) l_pointi[i];
2644     }
2645     /*set lsh var*/
2646     if (Lhs >= 1)
2647     {
2648         LhsVar(1) = 1;    /*return state in LhsVar(1)*/
2649     }
2650     if (Lhs == 2)
2651     {
2652         LhsVar(2) = 2;    /*return tcur in LhsVar(2)*/
2653     }
2654
2655     /* end */
2656     freeparam;
2657
2658     PutLhsVar();
2659
2660     return 0;
2661 }
2662 /*--------------------------------------------------------------------------*/
2663