bug 7845 Code Generation + fix warnings no headers used ...
[scilab.git] / scilab / modules / scicos / macros / scicos_scicos / do_compile_superblock42.sci
1 //  Scicos
2 //
3 //  Copyright (C) INRIA - METALAU Project <scicos@inria.fr>
4 //                      - Alan Layec <alan.layec@inria.fr>
5 //                      - Ramine Nikoukhah <ramine.nikoukhah@inria.fr>
6 //                      - Rachid Djenidi
7 //
8 //                      - Scilab 5 update by Simone Mannori
9 //
10 //  Copyright (C) DIGITEO - 2010 - Allan CORNET
11 //
12 // This program is free software; you can redistribute it and/or modify
13 // it under the terms of the GNU General Public License as published by
14 // the Free Software Foundation; either version 2 of the License, or
15 // (at your option) any later version.
16 //
17 // This program is distributed in the hope that it will be useful,
18 // but WITHOUT ANY WARRANTY; without even the implied warranty of
19 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20 // GNU General Public License for more details.
21 //
22 // You should have received a copy of the GNU General Public License
23 // along with this program; if not, write to the Free Software
24 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 //
26 // See the file ../license.txt
27 //
28
29 //**---------------------------------------------------------------------------------------------------------------------------------
30 //
31 //16/06/07 Author : ?, A. Layec
32 //
33 function [Code,actt,proto]=call_actuator(i)
34   nin=inpptr(i+1)-inpptr(i);  //** number of input ports
35   nout=outptr(i+1)-outptr(i); //** number of output ports
36
37   if funtyp(i)==0 then
38     if nin==0 then
39       uk    = 0;
40       nuk_1 = 0;
41       nuk_2 = 0;
42       uk_t  = 1;
43       //Code($+1)=+'  args[0]=(double *)outtbptr[0]);';
44     else
45       uk    = inplnk(inpptr(i));
46       nuk_1 = size(outtb(uk),1);
47       nuk_2 = size(outtb(uk),2);
48       uk_t  = mat2scs_c_nb(outtb(uk));
49       //Code($+1)=' args[0]=('+mat2scs_c_ptr(outtb(uk))+' *)outtbptr['+string(uk-1)+'];';
50     end
51   end
52   //pour la fonction gui ont a : num de bloc l'adresse dans
53   //nouveau  z et la taille du port
54   actt=[i uk nuk_1 nuk_2 uk_t bllst(i).ipar]
55
56   Code($+1)='block_'+rdnom+'['+string(i-1)+'].nevprt=nevprt;'
57
58   Code=['/* Call of actuator (blk nb '+string(i)+') */'
59         Code;
60         'nport = '+string(nbact)+';';
61         rdnom+'_actuator(&flag, &nport, &block_'+rdnom+'['+string(i-1)+'].nevprt, told, '+..
62         '('+mat2scs_c_ptr(outtb(uk))+' *)outtbptr['+string(uk-1)+'], &nrd_'+string(nuk_1)+', &nrd_'+..
63         string(nuk_2)+', &nrd_'+string(uk_t)+',bbb);'];
64
65   proto='void '+rdnom+'_actuator('+..
66         'int *, int *, int *, double *, void *, int *, int *,int *,int);'
67   proto=cformatline(proto,70);
68 endfunction
69
70 //CallBlock : generate C calling sequence
71 //            of a scicos block
72 //
73 //inputs : bk   : bloc index
74 //         pt   : evt activation number
75 //         flag : flag
76 //
77 //output : txt  :
78 //
79 //16/06/07 Authors : Alan Layec
80 function txt=call_block42(bk,pt,flag)
81   txt=[]
82   //**
83   if flag==2 & ((zptr(bk+1)-zptr(bk))+..
84                 (ozptr(bk+1)-ozptr(bk))+..
85                 (xptr(bk+1)-xptr(bk)+..
86                 with_work(bk))==0 |..
87                 pt<=0) & ~(stalone & or(bk==actt(:,1))) then
88     return // block without state or continuously activated
89   end
90   if flag==0 & ((xptr(bk+1)-xptr(bk))==0) then
91     return // block without continuous state
92   end
93   if flag==9 & ((zcptr(bk+1)-zcptr(bk))==0) then
94     return // block without continuous state
95   end
96   if flag==3 & ((clkptr(bk+1)-clkptr(bk))==0) then
97     return
98   end
99
100   //** adjust pt
101   if ~(flag==3 & ((zcptr(bk+1)-zcptr(bk))<>0)) then
102     pt=abs(pt)
103   end
104
105   //** add comment
106   txt=[get_comment('call_blk',list(funs(bk),funtyp(bk),bk));]
107
108   //** set nevprt and flag for called block
109   txt=[txt;
110        'block_'+rdnom+'['+string(bk-1)+'].nevprt = '+string(pt)+';'
111        'local_flag = '+string(flag)+';']
112
113   //**see if its bidon, actuator or sensor
114   if funs(bk)=='bidon' then
115     txt=[];
116     return
117   elseif funs(bk)=='bidon2' then
118     txt=[];
119     return
120   elseif or(bk==actt(:,1)) then
121     ind=find(bk==actt(:,1))
122     uk=actt(ind,2)
123     nuk_1=actt(ind,3)
124     nuk_2=actt(ind,4)
125     uk_t=actt(ind,5)
126     txt = [txt;
127            'nport = '+string(ind)+';']
128     txt = [txt;
129            rdnom+'_actuator(&local_flag, &nport, &block_'+rdnom+'['+string(bk-1)+'].nevprt, \'
130            get_blank(rdnom+'_actuator')+' &t, ('+mat2scs_c_ptr(outtb(uk))+' *)'+rdnom+'_block_outtbptr['+string(uk-1)+'], \'
131            get_blank(rdnom+'_actuator')+' &nrd_'+string(nuk_1)+', &nrd_'+string(nuk_2)+', &nrd_'+string(uk_t)+',bbb);']
132     txt = [txt;
133            'if(local_flag < 0) return(5 - local_flag);']
134     return
135   elseif or(bk==capt(:,1)) then
136     ind=find(bk==capt(:,1))
137     yk=capt(ind,2);
138     nyk_1=capt(ind,3);
139     nyk_2=capt(ind,4);
140     yk_t=capt(ind,5);
141     txt = [txt;
142            'nport = '+string(ind)+';']
143     txt = [txt;
144            rdnom+'_sensor(&local_flag, &nport, &block_'+rdnom+'['+string(bk-1)+'].nevprt, \'
145            get_blank(rdnom+'_sensor')+' &t, ('+mat2scs_c_ptr(outtb(yk))+' *)'+rdnom+'_block_outtbptr['+string(yk-1)+'], \'
146            get_blank(rdnom+'_sensor')+' &nrd_'+string(nyk_1)+', &nrd_'+string(nyk_2)+', &nrd_'+string(yk_t)+',aaa);']
147     txt = [txt;
148            'if(local_flag < 0) return(5 - local_flag);']
149     return
150   end
151
152   //**
153   nx=xptr(bk+1)-xptr(bk);
154   nz=zptr(bk+1)-zptr(bk);
155   nrpar=rpptr(bk+1)-rpptr(bk);
156   nipar=ipptr(bk+1)-ipptr(bk);
157   nin=inpptr(bk+1)-inpptr(bk);  //* number of input ports */
158   nout=outptr(bk+1)-outptr(bk); //* number of output ports */
159
160   //**
161   //l'adresse du pointeur de ipar
162   if nipar<>0 then ipar=ipptr(bk), else ipar=1;end
163   //l'adresse du pointeur de rpar
164   if nrpar<>0 then rpar=rpptr(bk), else rpar=1; end
165   //l'adresse du pointeur de z attention -1 pas sur
166   if nz<>0 then z=zptr(bk)-1, else z=0;end
167   //l'adresse du pointeur de x
168   if nx<>0 then x=xptr(bk)-1, else x=0;end
169
170   //**
171   ftyp=funtyp(bk)
172   if ftyp>2000 then ftyp=ftyp-2000,end
173   if ftyp>1000 then ftyp=ftyp-1000,end
174
175   //** check function type
176   if ftyp < 0 then //** ifthenelse eselect blocks
177       txt = [];
178       return;
179   else
180     if (ftyp<>0 & ftyp<>1 & ftyp<>2 & ftyp<>3 & ftyp<>4) then
181       disp("types other than 0,1,2,3 or 4 are not supported.")
182       txt = [];
183       return;
184     end
185   end
186
187   select ftyp
188
189     case 0 then
190       //**** input/output addresses definition ****//
191       if nin>1 then
192         for k=1:nin
193           uk=inplnk(inpptr(bk)-1+k);
194           nuk=size(outtb(uk),'*');
195           txt=[txt;
196                'rdouttb['+string(k-1)+']=(double *)'+rdnom+'_block_outtbptr['+string(uk-1)+'];']
197         end
198         txt=[txt;
199              'args[0]=&(rdouttb[0]);']
200       elseif nin==0
201         uk=0;
202         nuk=0;
203         txt=[txt;
204              'args[0]=(double *)'+rdnom+'_block_outtbptr[0];']
205       else
206         uk=inplnk(inpptr(bk));
207         nuk=size(outtb(uk),'*');
208         txt=[txt;
209              'args[0]=(double *)'+rdnom+'_block_outtbptr['+string(uk-1)+'];']
210       end
211
212       if nout>1 then
213         for k=1:nout
214           yk=outlnk(outptr(bk)-1+k);
215           nyk=size(outtb(yk),'*');
216           txt=[txt;
217                'rdouttb['+string(k+nin-1)+']=(double *)'+rdnom+'_block_outtbptr['+string(yk-1)+'];'];
218         end
219         txt=[txt;
220              'args[1]=&(rdouttb['+string(nin)+']);'];
221       elseif nout==0
222         yk=0;
223         nyk=0;
224         txt=[txt;
225              'args[1]=(double *)'+rdnom+'_block_outtbptr[0];'];
226       else
227         yk=outlnk(outptr(bk));
228         nyk=size(outtb(yk),'*'),;
229         txt=[txt;
230              'args[1]=(double *)'+rdnom+'_block_outtbptr['+string(yk-1)+'];'];
231       end
232       //*******************************************//
233
234       //*********** call seq definition ***********//
235       txtc=['(&local_flag,&block_'+rdnom+'['+string(bk-1)+'].nevprt,&t,block_'+rdnom+'['+string(bk-1)+'].xd, \';
236             'block_'+rdnom+'['+string(bk-1)+'].x,&block_'+rdnom+'['+string(bk-1)+'].nx, \';
237             'block_'+rdnom+'['+string(bk-1)+'].z,&block_'+rdnom+'['+string(bk-1)+'].nz,block_'+rdnom+'['+string(bk-1)+'].evout, \';
238             '&block_'+rdnom+'['+string(bk-1)+'].nevout,block_'+rdnom+'['+string(bk-1)+'].rpar,&block_'+rdnom+'['+string(bk-1)+'].nrpar, \';
239             'block_'+rdnom+'['+string(bk-1)+'].ipar,&block_'+rdnom+'['+string(bk-1)+'].nipar, \';
240             '(double *)args[0],&nrd_'+string(nuk)+',(double *)args[1],&nrd_'+string(nyk)+');'];
241       if (funtyp(bk)>2000 & funtyp(bk)<3000)
242         blank = get_blank(funs(bk)+'( ');
243         txtc(1) = funs(bk)+txtc(1);
244       elseif (funtyp(bk)<2000)
245         txtc(1) = 'C2F('+funs(bk)+')'+txtc(1);
246         blank = get_blank('C2F('+funs(bk)+') ');
247       end
248       txtc(2:$) = blank + txtc(2:$);
249       txt = [txt;txtc];
250       //*******************************************//
251
252
253     //**
254     case 1 then
255       //*********** call seq definition ***********//
256       txtc=['(&local_flag,&block_'+rdnom+'['+string(bk-1)+'].nevprt,&t,block_'+rdnom+'['+string(bk-1)+'].xd, \';
257             'block_'+rdnom+'['+string(bk-1)+'].x,&block_'+rdnom+'['+string(bk-1)+'].nx, \';
258             'block_'+rdnom+'['+string(bk-1)+'].z,&block_'+rdnom+'['+string(bk-1)+'].nz,block_'+rdnom+'['+string(bk-1)+'].evout, \';
259             '&block_'+rdnom+'['+string(bk-1)+'].nevout,block_'+rdnom+'['+string(bk-1)+'].rpar,&block_'+rdnom+'['+string(bk-1)+'].nrpar, \';
260             'block_'+rdnom+'['+string(bk-1)+'].ipar,&block_'+rdnom+'['+string(bk-1)+'].nipar'];
261       if (funtyp(bk)>2000 & funtyp(bk)<3000)
262         blank = get_blank(funs(bk)+'( ');
263         txtc(1) = funs(bk)+txtc(1);
264       elseif (funtyp(bk)<2000)
265         txtc(1) = 'C2F('+funs(bk)+')'+txtc(1);
266         blank = get_blank('C2F('+funs(bk)+') ');
267       end
268       if nin>=1 | nout>=1 then
269         txtc($)=txtc($)+', \'
270         txtc=[txtc;'']
271         if nin>=1 then
272           for k=1:nin
273             uk=inplnk(inpptr(bk)-1+k);
274             nuk=size(outtb(uk),'*');
275             txtc($)=txtc($)+'(double *)'+rdnom+'_block_outtbptr['+string(uk-1)+'],&nrd_'+string(nuk)+',';
276           end
277           txtc($)=part(txtc($),1:length(txtc($))-1); //remove last ,
278         end
279         if nout>=1 then
280           if nin>=1 then
281             txtc($)=txtc($)+', \'
282             txtc=[txtc;'']
283           end
284           for k=1:nout
285             yk=outlnk(outptr(bk)-1+k);
286             nyk=size(outtb(yk),'*');
287             txtc($)=txtc($)+'(double *)'+rdnom+'_block_outtbptr['+string(yk-1)+'],&nrd_'+string(nyk)+',';
288           end
289           txtc($)=part(txtc($),1:length(txtc($))-1); //remove last ,
290         end
291       end
292
293       if ztyp(bk) then
294         txtc($)=txtc($)+', \'
295         txtc=[txtc;
296               'block_'+rdnom+'['+string(bk-1)+'].g,&block_'+rdnom+'['+string(bk-1)+'].ng);']
297       else
298         txtc($)=txtc($)+');';
299       end
300
301       txtc(2:$) = blank + txtc(2:$);
302       txt = [txt;txtc];
303       //*******************************************//
304
305     //**
306     case 2 then
307
308       //*********** call seq definition ***********//
309       txtc=[funs(bk)+'(&local_flag,&block_'+rdnom+'['+string(bk-1)+'].nevprt,&t,block_'+rdnom+'['+string(bk-1)+'].xd, \';
310             'block_'+rdnom+'['+string(bk-1)+'].x,&block_'+rdnom+'['+string(bk-1)+'].nx, \';
311             'block_'+rdnom+'['+string(bk-1)+'].z,&block_'+rdnom+'['+string(bk-1)+'].nz,block_'+rdnom+'['+string(bk-1)+'].evout, \';
312             '&block_'+rdnom+'['+string(bk-1)+'].nevout,block_'+rdnom+'['+string(bk-1)+'].rpar,&block_'+rdnom+'['+string(bk-1)+'].nrpar, \';
313             'block_'+rdnom+'['+string(bk-1)+'].ipar,&block_'+rdnom+'['+string(bk-1)+'].nipar, \';
314             '(double **)block_'+rdnom+'['+string(bk-1)+'].inptr,block_'+rdnom+'['+string(bk-1)+'].insz,&block_'+rdnom+'['+string(bk-1)+'].nin, \';
315             '(double **)block_'+rdnom+'['+string(bk-1)+'].outptr,block_'+rdnom+'['+string(bk-1)+'].outsz, &block_'+rdnom+'['+string(bk-1)+'].nout'];
316       if ~ztyp(bk) then
317         txtc($)=txtc($)+');';
318       else
319         txtc($)=txtc($)+', \';
320         txtc=[txtc;
321               'block_'+rdnom+'['+string(bk-1)+'].g,&block_'+rdnom+'['+string(bk-1)+'].ng);']
322       end
323       blank = get_blank(funs(bk)+'( ');
324       txtc(2:$) = blank + txtc(2:$);
325       txt = [txt;txtc];
326       //*******************************************//
327
328     //**
329     case 4 then
330       txt=[txt;
331            funs(bk)+'(&block_'+rdnom+'['+string(bk-1)+'],local_flag);'];
332
333   end
334
335   txt =[txt;'if(local_flag < 0) return(5 - local_flag);']
336
337 endfunction
338
339 //CallBlock : generate C calling sequence
340 //            of a scicos block
341 //
342 //inputs : bk   : bloc index
343 //         pt   :
344 //         flag :block_'+rdnom+'[
345 //
346 //output : txt  :
347 //
348 //16/06/07 Authors : R.Nikoukhah, A.Layec
349 function txt=call_block4(bk)
350 //   if flag==2 & ((zptr(bk+1)-zptr(bk))+(ozptr(bk+1)-ozptr(bk))==0 | pt<=0) then
351 //     return // block without discrete state or continuously activated
352 //            // If work allocated in the absence of z and oz, it does not work
353 //   end
354
355   //**
356   nx=xptr(bk+1)-xptr(bk);
357   nz=zptr(bk+1)-zptr(bk);
358   nrpar=rpptr(bk+1)-rpptr(bk);
359   nipar=ipptr(bk+1)-ipptr(bk);
360   nin=inpptr(bk+1)-inpptr(bk);  //* number of input ports */
361   nout=outptr(bk+1)-outptr(bk); //* number of output ports */
362
363   //**
364   //l'adresse du pointeur de ipar
365   if nipar<>0 then ipar=ipptr(bk), else ipar=1;end
366   //l'adresse du pointeur de rpar
367   if nrpar<>0 then rpar=rpptr(bk), else rpar=1; end
368   //l'adresse du pointeur de z attention -1 pas sur
369   if nz<>0 then z=zptr(bk)-1, else z=0;end
370   //l'adresse du pointeur de x
371   if nx<>0 then x=xptr(bk)-1, else x=0;end
372
373   //**
374   ftyp=funtyp(bk)
375   if ftyp>2000 then ftyp=ftyp-2000,end
376   if ftyp>1000 then ftyp=ftyp-1000,end
377
378   //** check function type
379   if ftyp < 0 then //** ifthenelse eselect blocks
380       txt = [];
381       return;
382   else
383     if (ftyp<>0 & ftyp<>1 & ftyp<>2 & ftyp<>3 & ftyp<>4) then
384       disp("types other than 0,1,2,3 or 4 are not supported.")
385       txt = [];
386       return;
387     end
388   end
389
390   //** add comment
391   txt=[get_comment('call_blk',list(funs(bk),funtyp(bk),bk));]
392
393   //** write nevprt activation
394 //   nclock=abs(pt);
395   txt=[txt;
396        'block_'+rdnom+'['+string(bk-1)+'].nevprt=nevprt;']
397
398   select ftyp
399     //** zero funtyp
400     case 0 then
401       //**** input/output addresses definition ****//
402       if nin>1 then
403         for k=1:nin
404           uk=inplnk(inpptr(bk)-1+k);
405           nuk=size(outtb(uk),'*');
406           TYPE=mat2scs_c_ptr(outtb(uk));//scilab index start from 1
407           txt=[txt;
408                'rdouttb['+string(k-1)+']=('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(uk-1)+'];']
409         end
410         txt=[txt;
411              'args[0]=&(rdouttb[0]);']
412       elseif nin==0
413         uk=0;
414         nuk=0;
415         txt=[txt;
416              'args[0]=(SCSREAL_COP *)'+rdnom+'_block_outtbptr[0];']
417       else
418         uk=inplnk(inpptr(bk));
419         nuk=size(outtb(uk),'*');
420         TYPE=mat2scs_c_ptr(outtb(uk));//scilab index start from 1
421         txt=[txt;
422              'args[0]=('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(uk-1)+'];']
423       end
424
425       if nout>1 then
426         for k=1:nout
427           yk=outlnk(outptr(bk)-1+k);
428           nyk=size(outtb(yk),'*');
429           TYPE=mat2scs_c_ptr(outtb(yk));//scilab index start from 1
430           txt=[txt;
431                'rdouttb['+string(k+nin-1)+']=('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(yk-1)+'];'];
432         end
433         txt=[txt;
434              'args[1]=&(rdouttb['+string(nin)+']);'];
435       elseif nout==0
436         yk=0;
437         nyk=0;
438         txt=[txt;
439              'args[1]=(SCSREAL_COP *)'+rdnom+'_block_outtbptr[0];'];
440       else
441         yk=outlnk(outptr(bk));
442         nyk=size(outtb(yk),'*'),;
443         TYPE=mat2scs_c_ptr(outtb(yk));//scilab index start from 1
444         txt=[txt;
445              'args[1]=('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(yk-1)+'];'];
446       end
447       //*******************************************//
448
449       //*********** call seq definition ***********//
450       txtc=['(&flag,&block_'+rdnom+'['+string(bk-1)+'].nevprt,told,block_'+rdnom+'['+string(bk-1)+'].xd, \';
451             'block_'+rdnom+'['+string(bk-1)+'].x,&block_'+rdnom+'['+string(bk-1)+'].nx, \';
452             'block_'+rdnom+'['+string(bk-1)+'].z,&block_'+rdnom+'['+string(bk-1)+'].nz,block_'+rdnom+'['+string(bk-1)+'].evout, \';
453             '&block_'+rdnom+'['+string(bk-1)+'].nevout,block_'+rdnom+'['+string(bk-1)+'].rpar,&block_'+rdnom+'['+string(bk-1)+'].nrpar, \';
454             'block_'+rdnom+'['+string(bk-1)+'].ipar,&block_'+rdnom+'['+string(bk-1)+'].nipar, \';
455             '(double *)args[0],&nrd_'+string(nuk)+',(double *)args[1],&nrd_'+string(nyk)+');'];
456       if (funtyp(bk)>2000 & funtyp(bk)<3000)
457         blank = get_blank(funs(bk)+'( ');
458         txtc(1) = funs(bk)+txtc(1);
459       elseif (funtyp(bk)<2000)
460         txtc(1) = 'C2F('+funs(bk)+')'+txtc(1);
461         blank = get_blank('C2F('+funs(bk)+') ');
462       end
463       txtc(2:$) = blank + txtc(2:$);
464       txt = [txt;txtc];
465       //*******************************************//
466
467
468     //**
469     case 1 then
470       //**** input/output addresses definition ****//
471 //       if nin>=1 then
472 //         for k=1:nin
473 //           uk=inplnk(inpptr(i)-1+k);
474 //           nuk=size(outtb(uk),'*');
475 //         end
476 //       end
477 //       if nout>=1 then
478 //         for k=1:nout
479 //           yk=outlnk(outptr(i)-1+k);
480 //           nyk=size(outtb(yk),'*');
481 //         end
482 //       end
483       //*******************************************//
484
485       //*********** call seq definition ***********//
486       txtc=['(&flag,&block_'+rdnom+'['+string(bk-1)+'].nevprt,told,block_'+rdnom+'['+string(bk-1)+'].xd, \';
487             'block_'+rdnom+'['+string(bk-1)+'].x,&block_'+rdnom+'['+string(bk-1)+'].nx, \';
488             'block_'+rdnom+'['+string(bk-1)+'].z,&block_'+rdnom+'['+string(bk-1)+'].nz,block_'+rdnom+'['+string(bk-1)+'].evout, \';
489             '&block_'+rdnom+'['+string(bk-1)+'].nevout,block_'+rdnom+'['+string(bk-1)+'].rpar,&block_'+rdnom+'['+string(bk-1)+'].nrpar, \';
490             'block_'+rdnom+'['+string(bk-1)+'].ipar,&block_'+rdnom+'['+string(bk-1)+'].nipar'];
491       if (funtyp(bk)>2000 & funtyp(bk)<3000)
492         blank = get_blank(funs(bk)+'( ');
493         txtc(1) = funs(bk)+txtc(1);
494       elseif (funtyp(bk)<2000)
495         txtc(1) = 'C2F('+funs(bk)+')'+txtc(1);
496         blank = get_blank('C2F('+funs(bk)+') ');
497       end
498       if nin>=1 | nout>=1 then
499         txtc($)=txtc($)+', \'
500         txtc=[txtc;'']
501         if nin>=1 then
502           for k=1:nin
503             uk=inplnk(inpptr(bk)-1+k);
504             nuk=size(outtb(uk),'*');
505             txtc($)=txtc($)+'(SCSREAL_COP *)'+rdnom+'_block_outtbptr['+string(uk-1)+'],&nrd_'+string(nuk)+',';
506           end
507           txtc($)=part(txtc($),1:length(txtc($))-1); //remove last ,
508         end
509         if nout>=1 then
510           if nin>=1 then
511             txtc($)=txtc($)+', \'
512             txtc=[txtc;'']
513           end
514           for k=1:nout
515             yk=outlnk(outptr(bk)-1+k);
516             nyk=size(outtb(yk),'*');
517             txtc($)=txtc($)+'(SCSREAL_COP *)'+rdnom+'_block_outtbptr['+string(yk-1)+'],&nrd_'+string(nyk)+',';
518           end
519           txtc($)=part(txtc($),1:length(txtc($))-1); //remove last ,
520         end
521       end
522
523       if ztyp(bk) then
524         txtc($)=txtc($)+', \'
525         txtc=[txtc;'w,&nrd_0);'];
526       else
527         txtc($)=txtc($)+');';
528       end
529
530       txtc(2:$) = blank + txtc(2:$);
531       txt = [txt;txtc];
532       //*******************************************//
533
534     //**
535     case 2 then
536
537       //*********** call seq definition ***********//
538       txtc=[funs(bk)+'(&flag,&block_'+rdnom+'['+string(bk-1)+'].nevprt,told,block_'+rdnom+'['+string(bk-1)+'].xd, \';
539             'block_'+rdnom+'['+string(bk-1)+'].x,&block_'+rdnom+'['+string(bk-1)+'].nx, \';
540             'block_'+rdnom+'['+string(bk-1)+'].z,&block_'+rdnom+'['+string(bk-1)+'].nz,block_'+rdnom+'['+string(bk-1)+'].evout, \';
541             '&block_'+rdnom+'['+string(bk-1)+'].nevout,block_'+rdnom+'['+string(bk-1)+'].rpar,&block_'+rdnom+'['+string(bk-1)+'].nrpar, \';
542             'block_'+rdnom+'['+string(bk-1)+'].ipar,&block_'+rdnom+'['+string(bk-1)+'].nipar, \';
543             '(double **)block_'+rdnom+'['+string(bk-1)+'].inptr,block_'+rdnom+'['+string(bk-1)+'].insz,&block_'+rdnom+'['+string(bk-1)+'].nin, \';
544             '(double **)block_'+rdnom+'['+string(bk-1)+'].outptr,block_'+rdnom+'['+string(bk-1)+'].outsz, &block_'+rdnom+'['+string(bk-1)+'].nout'];
545       if ~ztyp(bk) then
546         txtc($)=txtc($)+');';
547       else
548         txtc($)=txtc($)+', \';
549         txtc=[txtc;
550               'block_'+rdnom+'['+string(bk-1)+'].g,&block_'+rdnom+'['+string(bk-1)+'].ng);']
551       end
552       blank = get_blank(funs(bk)+'( ');
553       txtc(2:$) = blank + txtc(2:$);
554       txt = [txt;txtc];
555       //*******************************************//
556
557     //**
558     case 4 then
559       txt=[txt;
560            funs(bk)+'(&block_'+rdnom+'['+string(bk-1)+'],flag);'];
561
562   end
563 endfunction
564
565 //
566 //16/06/07 Author : ?, A. Layec
567 //
568 function [Code,capt,proto]=call_sensor(i)
569   nin=inpptr(i+1)-inpptr(i); ///* number of input ports */
570   nout=outptr(i+1)-outptr(i); ///* number of output ports */
571
572   //declaration des I/O des blocs de type 1
573   if funtyp(i)==0 then
574     if nout==0 then
575       yk    = 0;
576       nyk_1 = 0;
577       nyk_2 = 0;
578       yk_t  = 1;
579       //Code($+1)=+'  args[1]=(double *)(outtbptr[0]);';
580     else
581       yk    = outlnk(outptr(i));
582       nyk_1 = size(outtb(yk),1);
583       nyk_2 = size(outtb(yk),2);
584       yk_t  = mat2scs_c_nb(outtb(yk));
585       //Code($+1)='  args[1]=('+mat2scs_c_ptr(outtb(yk))+' *)(outtbptr['+string(yk-1)+']);';
586     end
587
588   end
589   capt=[i yk nyk_1 nyk_2 yk_t bllst(i).ipar]
590   Code($+1)='block_'+rdnom+'['+string(i-1)+'].nevprt=nevprt;'
591   Code=['/* Call of sensor (blk nb '+string(i)+') */'
592         Code;
593         'nport = '+string(nbcap)+';';
594         rdnom+'_sensor(&flag, &nport, &block_'+rdnom+'['+string(i-1)+'].nevprt, '+..
595         'told, ('+mat2scs_c_ptr(outtb(yk))+' *)(outtbptr['+string(yk-1)+']), &nrd_'+string(nyk_1)+..
596         ', &nrd_'+string(nyk_2)+', &nrd_'+string(yk_t)+',aaa);'];
597   proto='void '+rdnom+'_sensor('+..
598         'int *, int *, int *, double *,void *, int *, int *,int *, int);'
599   proto=cformatline(proto,70);
600 endfunction
601
602 //Generates Code for dynamically linked Fortran and C Blocks
603 function [CCode,FCode]=gen_blocks()
604   CCode=[]
605   FCode=[]
606
607   kdyn=find(funtyp>1000) //dynamically linked blocs
608                          //100X : Fortran blocks
609                          //200X : C blocks
610
611   if (size(kdyn,'*') >1)
612     kfuns=[];
613     //get the block data structure in the initial scs_m structure
614     if size(corinv(kdyn(1)),'*')==1 then
615       O=scs_m.objs(corinv(kdyn(1)));
616     else
617       path=list('objs');
618       for l=corinv(kdyn(1))(1:$-1)
619         path($+1)=l;
620         path($+1)='model';
621         path($+1)='rpar';
622         path($+1)='objs';
623       end
624       path($+1)=corinv(kdyn(1))($);
625       O=scs_m(path);
626     end
627     if funtyp(kdyn(1))>2000 then
628       //C block
629       CCode=[CCode;O.graphics.exprs(2)]
630     else
631       FCode=[FCode;O.graphics.exprs(2)]
632     end
633     kfuns=funs(kdyn(1));
634     for i=2:size(kdyn,'*')
635       //get the block data structure in the initial scs_m structure
636       if size(corinv(kdyn(i)),'*')==1 then
637         O=scs_m.objs(corinv(kdyn(i)));
638       else
639         path=list('objs');
640          for l=corinv(kdyn(i))(1:$-1)
641            path($+1)=l;
642            path($+1)='model';
643            path($+1)='rpar';
644            path($+1)='objs';
645         end
646         path($+1)=corinv(kdyn(i))($);
647         O=scs_m(path);
648       end
649       if (find(kfuns==funs(kdyn(i))) == [])
650         kfuns=[kfuns;funs(kdyn(i))];
651         if funtyp(kdyn(i))>2000  then
652           //C block
653           CCode=[CCode;O.graphics.exprs(2)]
654         else
655           FCode=[FCode;O.graphics.exprs(2)]
656         end
657       end
658     end
659   elseif (size(kdyn,'*')==1)
660     //get the block data structure in the initial scs_m structure
661     if size(corinv(kdyn),'*')==1 then
662       O=scs_m.objs(corinv(kdyn));
663     else
664       path=list('objs');
665       for l=corinv(kdyn)(1:$-1)
666         path($+1)=l;
667         path($+1)='model';
668         path($+1)='rpar';
669         path($+1)='objs';
670       end
671       path($+1)=corinv(kdyn)($);
672       O=scs_m(path);
673     end
674     if funtyp(kdyn)>2000 then
675       //C block
676       CCode=[CCode;O.graphics.exprs(2)]
677     else
678       FCode=[FCode;O.graphics.exprs(2)]
679     end
680   end
681   if CCode==[]
682     CCode=['void no_ccode()'
683            '{'
684            '  return;'
685            '}']
686   end
687 endfunction
688
689 //** Generates the C code for new block simulation
690 //
691 //12/07/07 Alan Layec
692 function ok=gen_ccode42();
693
694   //** Generate code for scicos block
695   Code=make_computational42()
696
697   ierr=execstr('mputl(Code,rpat+''/''+rdnom+''.c'')','errcatch')
698   if ierr<>0 then
699     message(lasterror())
700     ok=%f
701     return
702   end
703
704   //** Generate files for dynamically linked scicos blocks
705   [CCode,FCode]=gen_blocks()
706   if FCode<>[] then
707     ierr=execstr('mputl(FCode,rpat+''/''+rdnom+''f.f'')','errcatch')
708     if ierr<>0 then
709       message(lasterror())
710       ok=%f
711       return
712     end
713   end
714   if CCode<>[] then
715     ierr=execstr('mputl(CCode,rpat+''/''+rdnom+''_Cblocks.c'')','errcatch')
716     if ierr<>0 then
717       message(lasterror())
718       ok=%f
719       return
720     end
721   end
722
723   //** Generate _void_io.c
724   Code=['/*---------------------------------------- Actuators */'
725         'void '+rdnom+'_actuator(flag,nport,nevprt,t,u,nu1,nu2,ut,flag1)'
726              '     int *flag,*nevprt,*nport;'
727              '     int *nu1,*nu2,*ut,flag1;'
728         '     double *t;'
729         '     void *u;'
730         '{'
731         '  int k = 0,l = 0;'
732         '}'
733         '/*---------------------------------------- Sensor */'
734         'void '+rdnom+'_sensor(flag,nport,nevprt,t,y,ny1,ny2,yt,flag1)'
735         '     int *flag,*nevprt,*nport;'
736         '     int *ny1,*ny2,*yt,flag1;'
737         '     double *t;'
738         '     void *y;'
739         '{'
740         '  int k = 0,l = 0;'
741         '}']
742
743   ierr=execstr('mputl(Code,rpat+''/''+rdnom+''_void_io.c'')','errcatch')
744   if ierr<>0 then
745     message(lasterror())
746     ok=%f
747     return
748   end
749
750   //** Generate _standalone.c
751   Code=make_standalone42()
752
753   ierr=execstr('mputl(Code,rpat+''/''+rdnom+''_standalone.c'')','errcatch')
754   if ierr<>0 then
755     message(lasterror())
756     ok=%f
757     return
758   end
759
760 //** This copy is indispensable only for stand alone code generation
761 //** not supported in Scilab 5
762
763   //** copy source code of machine.h/scicos_block4.h
764   //   in target path
765 //   txt=mgetl(SCI+'/modules/core/includes/machine.h');
766 //   ierr=execstr('mputl(txt,rpat+''/machine.h'')','errcatch')
767 //   if ierr<>0 then
768 //     message(lasterror())
769 //     ok=%f
770 //     return
771 //   end
772 //
773 //   txt=mgetl(SCI+'/modules/scicos_blocks/includes/scicos_block4.h');
774 //   ierr=execstr('mputl(txt,rpat+''/scicos_block4.h'')','errcatch')
775 //   if ierr<>0 then
776 //     message(lasterror())
777 //     ok=%f
778 //     return
779 //   end
780
781   //** Generate _act_sens_events.c
782   Code=['#include <stdio.h>'
783         '#include <stdlib.h>'
784         '#include <math.h>'
785         '#include <string.h>'
786         'extern void **'+rdnom+'_block_outtbptr;'
787         'extern char input[50],output[50];'
788         'FILE *fprr = NULL, *fprw = NULL;'
789         make_outevents()
790         make_actuator(%t)
791         make_sensor(%t)]
792
793   created=[];
794   reponse=[];
795
796   created=fileinfo(rpat+'/'+rdnom+'_act_sens_events.c')
797   if created~=[] then
798     reponse=messagebox(['File: ""'+rdnom+'_act_sens_events.c"" already exists,';
799                        'do you want to replace it ?'],"modal","question",['Yes','No']);
800   end
801
802   if reponse==1 |  reponse==[] then
803     ierr=execstr('mputl(Code,rpat+''/''+rdnom+''_act_sens_events.c'')', ...
804                  'errcatch')
805     if ierr<>0 then
806       message(lasterror())
807       ok=%f
808       return
809     end
810   end
811 endfunction
812
813 //creates the Scicos GUI function associated with the new block
814 //
815 //Author : Rachid Djenidi, A.Layec
816 //
817 //20/06/07, A.Layec : update with in2,out2,intyp,outtyp
818 //27/06/07, A.Layec : update opar,oz
819 //
820 function ok=gen_gui42();
821   clkinput=ones(clkIN)';
822   clkoutput=ones(clkOUT)';
823   //outtb=outtb;
824   oz=cpr.state.oz;
825
826   new_oz=list();
827   for i=1:lstsize(oz)
828     new_oz($+1) = oz(i)
829   end
830   for i=1:lstsize(outtb)
831     new_oz($+1) = outtb(i)
832   end
833
834   //outtb($+1) = zeros(nblk,1);
835   Code=['function [x,y,typ]='+rdnom+'_c(job,arg1,arg2)';
836         '// Copyright INRIA';
837         '// Copyright DIGITEO - 2010';
838         ' x=[];y=[];typ=[];';
839         ' select job';
840         ' case ''plot'' then';
841         '   standard_draw(arg1)';
842         ' case ''getinputs'' then';
843         '   [x,y,typ]=standard_inputs(arg1)';
844         ' case ''getoutputs'' then';
845         '   [x,y,typ]=standard_outputs(arg1)';
846         ' case ''getorigin'' then';
847         '   [x,y]=standard_origin(arg1)';
848         ' case ''set'' then';
849         '   x=arg1;';
850         ' case ''define'' then'
851         '   '+sci2exp(capt(:,3),'in',70); //input ports sizes 1
852         '   '+sci2exp(capt(:,4),'in2',70); //input ports sizes 2
853         '   '+sci2exp(scs_c_nb2scs_nb(capt(:,5)),'intyp',70); //input ports type
854         '   '+sci2exp(actt(:,3),'out',70); //output ports sizes 1
855         '   '+sci2exp(actt(:,4),'out2',70); //output ports sizes 2
856         '   '+sci2exp(scs_c_nb2scs_nb(actt(:,5)),'outtyp',70); //output ports type
857         '   '+sci2exp(x,'x',70); //initial continuous state
858         '   '+sci2exp(z,'z',70); //initial discrete state
859         '   work=zeros('+string(nblk)+',1)';
860         '   Z=[z;work]';
861         '   '+sci2exp(new_oz,'odstate',70);
862         '   '+sci2exp(cpr.sim.rpar,'rpar',70); //real parameters
863         '   '+sci2exp(cpr.sim.ipar,'ipar',70); //integer parameters
864         '   '+sci2exp(cpr.sim.opar,'opar',70); //object parameters
865         '   '+sci2exp(clkinput,'clkinput',70);
866         '   '+sci2exp(clkoutput,'clkoutput',70);
867         '   '+sci2exp(FIRING,'firing',70);
868         '   nzcross='+string(sum(cpr.sim.zcptr(2:$)-cpr.sim.zcptr(1:$-1)))';
869         '   nmode='+string(sum(cpr.sim.modptr(2:$)-cpr.sim.modptr(1:$-1)))';]
870
871   for i=1:length(bllst)
872     deput=[%t,%f]
873     if (bllst(i).dep_ut(2) == %t) then
874       deput(1,2)=%t;
875       break;
876     end
877   end
878   Code($+1)='   '+sci2exp(deput,'dep_ut',70);
879   Code=[Code
880         '   model=scicos_model(sim=list('''+rdnom+''',4),..'
881         '                      in=in,..'
882         '                      in2=in2,..'
883         '                      intyp=intyp,..'
884         '                      out=out,..'
885         '                      out2=out2,..'
886         '                      outtyp=outtyp,..'
887         '                      evtin=clkinput,..'
888         '                      evtout=clkoutput,..'
889         '                      firing=firing,..'
890         '                      state=x,..'
891         '                      dstate=Z,..'
892         '                      odstate=odstate,..'
893         '                      rpar=rpar,..'
894         '                      ipar=ipar,..'
895         '                      opar=opar,..'
896         '                      blocktype=''c'',..'
897         '                      dep_ut=dep_ut,..'
898         '                      nzcross=nzcross,..'
899         '                      nmode=nmode)'
900         '   gr_i=''xstringb(orig(1),orig(2),'''''+rdnom+''''',sz(1),..'
901         '          sz(2),''''fill'''')''';
902         '   x=standard_define([2 2],model,[],gr_i)';
903         ' end'
904         'endfunction'];
905   //Create file
906   ierr=execstr('mputl(Code,rpat+''/''+rdnom+''_c.sci'')','errcatch')
907   if ierr<>0 then
908     message(lasterror())
909     ok=%f
910   end
911 endfunction
912
913 function  [ok,XX,alreadyran,flgcdgen,szclkINTemp,freof] = do_compile_superblock42(XX,all_scs_m,numk,alreadyran)
914 // Transforms a given Scicos discrete and continuous SuperBlock into a C defined Block
915
916   scs_m=XX.model.rpar
917   par=scs_m.props;
918   if alreadyran then
919     //terminate current simulation
920     do_terminate()
921     alreadyran=%f
922   end
923   hname=scs_m.props.title(1) //superblock name
924   //***********************************************************
925   //Check blocks properties and adapt them if necessary
926   //***********************************************************
927
928   IN=[];OUT=[];clkIN=[];clkOUT=[];numa=[];numc=[];
929   for i=1:size(scs_m.objs)
930     if typeof(scs_m.objs(i))=='Block' then
931       if scs_m.objs(i).gui=='CLKOUT_f' then
932         ok=%f;%cpr=list()
933         message('Superblock should not have any activation output port.')
934         return
935       elseif scs_m.objs(i).gui=='IN_f' then
936         //replace input ports by sensor blocks
937         numc=numc+1
938         scs_m.objs(i).gui='INPUTPORTEVTS';
939         scs_m.objs(i).model.evtin=1
940         scs_m.objs(i).model.sim(1)='capteur'+string(numc)
941         IN=[IN scs_m.objs(i).model.ipar]
942       elseif scs_m.objs(i).gui=='OUT_f' then
943         //replace output ports by actuator blocks
944         numa=numa+1
945         scs_m.objs(i).gui='OUTPUTPORTEVTS';
946         scs_m.objs(i).model.sim(1)='actionneur'+string(numa)
947         OUT=[OUT  scs_m.objs(i).model.ipar]
948       elseif scs_m.objs(i).gui=='CLKINV_f' then
949         //replace event input ports by  fictious block
950         scs_m.objs(i).gui='EVTGEN_f';
951         scs_m.objs(i).model.sim(1)='bidon'
952         clkIN=[clkIN scs_m.objs(i).model.ipar];
953         //elseif scs_m.objs(i).model.dep_ut(2)==%t then
954         //check for time dependency PAS IICI
955         //ok=%f;%cpr=list()
956         //message('a block have time dependence.')
957         //return
958       elseif scs_m.objs(i).gui=='CLKOUTV_f' then
959         scs_m.objs(i).gui='EVTOUT_f';
960         scs_m.objs(i).model.sim(1)='bidon2'
961         clkOUT=[clkOUT scs_m.objs(i).model.ipar];
962       end
963     end
964   end
965
966   //Check if input/output ports are numered properly
967   IN=-gsort(-IN);
968   if or(IN<>[1:size(IN,'*')]) then
969     ok=%f;%cpr=list()
970     message('Input ports are not numbered properly.')
971     return
972   end
973   OUT=-gsort(-OUT);
974   if or(OUT<>[1:size(OUT,'*')]) then
975     ok=%f;%cpr=list()
976     message('Output ports are not numbered properly.')
977     return
978   end
979   clkIN=-gsort(-clkIN);
980   if or(clkIN<>[1:size(clkIN,'*')]) then
981     ok=%f;%cpr=list()
982     message('Event input ports are not numbered properly.')
983     return
984   end
985   clkOUT=-gsort(-clkOUT);
986   if or(clkOUT<>[1:size(clkOUT,'*')]) then
987     ok=%f;%cpr=list()
988     message('Event output ports are not numbered properly.')
989     return
990   end
991
992   //Check if there is more than one clock in the diagram
993   szclkIN=size(clkIN,2);
994   if szclkIN==0 then
995     szclkIN=[]
996   end
997   flgcdgen=szclkIN;
998   [bllst,connectmat,clkconnect,cor,corinv,ok,scs_m,flgcdgen,freof]=c_pass1(scs_m,flgcdgen);
999   if flgcdgen<> szclkIN
1000     clkIN=[clkIN flgcdgen]
1001   end
1002   szclkINTemp=szclkIN;
1003   szclkIN=flgcdgen;
1004  // [bllst,connectmat,clkconnect,cor,corinv,ok]=c_pass1(scs_m);
1005
1006   //Test for  ALWAYS_ACTIVE sblock (RN -25/06/07)
1007   ALWAYS_ACTIVE=%f;
1008   for blki=bllst
1009     if blki.dep_ut($) then
1010       ALWAYS_ACTIVE=%t;
1011       break;
1012     end
1013   end
1014   if ALWAYS_ACTIVE then
1015     CAPTEURS=[];
1016     for Ii=1:length(bllst)
1017       if part(bllst(Ii).sim(1),1:7)=='capteur' then
1018         bllst(Ii).dep_ut($)=%t
1019 //       elseif part(bllst(Ii).sim(1),1:10)=='actionneur' then
1020 //         bllst(Ii).dep_ut($)=%t
1021       end
1022     end
1023   end
1024
1025   if ~ok then
1026     message('Sorry: problem in the pre-compilation step.')
1027     return
1028   end
1029   a=[];
1030   b=[];
1031   tt=[];
1032   howclk=[];
1033   allhowclk=[];
1034   allhowclk2=[];
1035   cap=[];
1036   act=[];
1037
1038   ///**********************************
1039   for i=1:size(bllst)
1040     for j=1:size(bllst)
1041       if (bllst(i).sim(1)=='actionneur'+string(j)) then
1042         if tt<>i then
1043           act=[act;i];
1044           tt=i;
1045         end
1046       elseif (bllst(i).sim(1)=='capteur'+string(j)) then
1047         if tt<>i then
1048           cap=[cap;i];
1049           tt=i;
1050         end
1051       elseif (bllst(i).sim(1)=='bidon') then
1052         if tt<>i then
1053           allhowclk=[allhowclk;i];
1054           tt=i;
1055         end
1056       elseif (bllst(i).sim(1)=='bidon2') then
1057         if tt<>i then
1058           allhowclk2=[allhowclk2;i];
1059           tt=i;
1060         end
1061       end
1062     end
1063   end
1064   ///**********************************
1065
1066   if szclkIN>1 then
1067     //replace the N Event inputs by a fictious block with 2^N as many event
1068     //outputs
1069     output=ones((2^szclkIN)-1,1)
1070     bllst($+1)=scicos_model(sim=list('bidon',1),evtout=output,..
1071                             blocktype='d',..
1072                             firing=-output',dep_ut=[%f %f])
1073     corinv(size(bllst))=size(bllst)+1;
1074     howclk=size(bllst)
1075     // adjust the links accordingly
1076     for i=1:(2^szclkIN)-1
1077       vec=codebinaire(i,szclkIN)
1078       for j=1:szclkIN
1079         if vec(j)*allhowclk(j)>=1 then
1080           for k=1:size(clkconnect,1)
1081             if clkconnect(k,1)==allhowclk(j) then
1082               clkconnect=[clkconnect;[howclk i clkconnect(k,3:4)]]
1083             end
1084           end
1085         end
1086       end
1087     end
1088   elseif szclkIN==[]&~ALWAYS_ACTIVE then
1089     //superblock has no Event input, add a fictious clock
1090     output=ones((2^(size(cap,'*')))-1,1)
1091     if (output == []) then
1092       output=0;
1093     end
1094     bllst($+1)=scicos_model(sim=list('bidon',1),evtout=output,..
1095                             firing=-output,blocktype='d',dep_ut=[%f %f])
1096     corinv(size(bllst))=size(bllst)+1;
1097     howclk=size(bllst);
1098   elseif szclkIN==1  then
1099     howclk=allhowclk;
1100   end
1101
1102   //mise en ordre de clkconnect
1103   if szclkIN>1 then
1104     newclkconnect=clkconnect;
1105     clkconnect=[];
1106     for i=1:size(newclkconnect,1)-1
1107       if or(newclkconnect(i,:)<>newclkconnect(i+1,:)) then
1108         clkconnect=[clkconnect;newclkconnect(i,:)]
1109       end
1110     end
1111     if or(newclkconnect($-1,:)<>newclkconnect($,:)) then
1112       clkconnect=[clkconnect;newclkconnect($,:)]
1113     end
1114
1115     //suppression des blocs bidons
1116     newclkconnect=clkconnect;nkt=[];
1117     for i=1:szclkIN
1118       for k=1:size(newclkconnect,1)
1119         if newclkconnect(k,1)~=allhowclk(i) then
1120           nkt=[nkt;newclkconnect(k,:)];
1121         end
1122       end
1123       newclkconnect=nkt;
1124       nkt=[];
1125     end
1126     clkconnect=newclkconnect;
1127   end
1128
1129   //**************************************************
1130   // nouveau clkconnect avec liaisons sur les capteurs
1131   //**************************************************
1132   //Test for  ALWAYS_ACTIVE sblock (RN -25/06/07)
1133   if ~(ALWAYS_ACTIVE&szclkIN==[]) then
1134     n=size(cap,1)
1135     for i=1:n
1136       if szclkIN>1 then
1137         for j=1:(2^szclkIN)-1
1138           clkconnect=[clkconnect;[howclk j cap(i) 1]];
1139         end
1140       elseif szclkIN==1 then
1141         clkconnect=[clkconnect;[howclk 1 cap(i) 1]];
1142       end
1143     end
1144
1145     //codage de l'activation des capteurs dans le cas de l'heritage
1146     for i=1:2^n-1
1147       vec=codebinaire(i,n);
1148       for j=1:n
1149         if (vec(j)==1) then
1150           clkconnect=[clkconnect;[howclk i cap(j) 1]];
1151         end
1152       end
1153     end
1154   end
1155
1156   FIRING=[]
1157   for i=1:size(allhowclk2,1)
1158     j = find(clkconnect(:,3)==allhowclk2(i))
1159     if j<>[] then
1160       FIRING=[FIRING;bllst(clkconnect(j,1)).firing(clkconnect(j,2))]
1161     end
1162   end
1163
1164   Code_gene_run=[];
1165
1166   //** OLD GRAPHICS
1167   //** %windo=xget('window')
1168
1169   cpr=c_pass2(bllst,connectmat,clkconnect,cor,corinv)
1170
1171   if cpr==list() then ok=%f,return, end
1172
1173   //** Alan's patch 5/07/07: try to solve
1174   //   which blocks use work
1175   funs_save=cpr.sim.funs;
1176   funtyp_save=cpr.sim.funtyp;
1177   with_work = zeros(cpr.sim.nblk,1)
1178   for i=1:lstsize(cpr.sim.funs)
1179     if part(cpr.sim.funs(i),1:10)=='actionneur' then
1180        cpr.sim.funs(i) ='bidon'
1181        cpr.sim.funtyp(i) = 1
1182     elseif part(cpr.sim.funs(i),1:7)=='capteur' then
1183        cpr.sim.funs(i) ='bidon'
1184        cpr.sim.funtyp(i) = 1
1185     end
1186   end
1187
1188   //**
1189   //** retrieve all open Scilab windows with winsid()
1190   //**
1191
1192   BeforeCG_WinList = winsid();
1193
1194   ierr=execstr('[state,t]=scicosim(cpr.state,0,0,cpr.sim,'+..
1195                '''start'',scs_m.props.tol)','errcatch')
1196   if ierr==0 then
1197     for i=1:cpr.sim.nblk
1198        if state.iz(i)<>0 then
1199           with_work(i)=%t
1200        end
1201     end
1202     ierr=execstr('[state,t]=scicosim(state,0,0,cpr.sim,'+..
1203                  '''finish'',scs_m.props.tol)','errcatch')
1204   end
1205
1206   //**
1207   //** retrieve all open Scilab windows with winsid
1208   //** and close the additional windows open since first
1209   //**
1210
1211   //** This code does not cover 100% of the possible situations because the user can
1212   //** destroy one or more Scicos wins manually during this intermediate phase
1213   //** This code is 100% functional if the the user does not close manually any win.
1214   //** TO BE updated in Scilab 5.0
1215
1216   AfterCG_WinList = winsid();
1217
1218   AfterCG_size = size(AfterCG_WinList); //** matrix
1219   AfterCG_size = AfterCG_size(2) ; //** vector lenght
1220
1221   BeforeCG_size = size(BeforeCG_WinList); //** matrix
1222   BeforeCG_size = BeforeCG_size(2) ; //** vector lenght
1223
1224   if (or(AfterCG_WinList<>BeforeCG_WinList)) & (AfterCG_size>BeforeCG_size) then
1225      //** means that a scope or other scicos object has created some
1226      //** output window
1227
1228      DiffCG_Winlist = AfterCG_WinList<>BeforeCG_WinList ; //** T/F mismatch
1229      DiffCG_Index = find(DiffCG_Winlist); //** recover the mismatched indexes only
1230
1231      for win_idx = DiffCG_Index
1232          delete( scf( AfterCG_WinList(win_idx) ) ) ; //** clear the spurious windows
1233      end
1234
1235   end
1236   //**------------- end of windows cleaning ----------------------------------------
1237
1238   cpr.sim.funs=funs_save;
1239   cpr.sim.funtyp=funtyp_save;
1240
1241   //** OLD GRAPHICS
1242   //** xset('window',%windo)
1243
1244   ///////////////////
1245   //les pointeurs de cpr :
1246   x=cpr.state.x;
1247   z=cpr.state.z;
1248   outtb=cpr.state.outtb;
1249
1250   //RN
1251   zcptr=cpr.sim.zcptr;
1252   ozptr=cpr.sim.ozptr;
1253   rpptr=cpr.sim.rpptr;
1254   ipptr=cpr.sim.ipptr;
1255   opptr=cpr.sim.opptr;
1256   funs=cpr.sim.funs;
1257   xptr=cpr.sim.xptr;
1258   zptr=cpr.sim.zptr;
1259   inpptr=cpr.sim.inpptr;
1260   inplnk=cpr.sim.inplnk;
1261   outptr=cpr.sim.outptr;
1262   outlnk=cpr.sim.outlnk;
1263   //@l@n lnkptr=cpr.sim.lnkptr;
1264   ordclk=cpr.sim.ordclk;
1265   funtyp=cpr.sim.funtyp;
1266   cord=cpr.sim.cord;
1267   ncord=size(cord,1);
1268   nblk=cpr.sim.nb;
1269   ztyp=cpr.sim.ztyp;
1270   clkptr=cpr.sim.clkptr
1271   //taille totale de z : nztotal
1272   nztotal=size(z,1);
1273
1274   //*******************************
1275   //Checking if superblock is valid
1276   //*******************************
1277   msg=[]
1278   for i=1:length(funs)-1
1279     if funtyp(i)==3 then
1280       msg=[msg;'Type 3 block''s not allowed']
1281 //RN   elseif ztyp(i)<>0 then
1282     //elseif (zcptr(i+1)-zcptr(i))<>0 then
1283 //
1284       //msg=[msg;'Active zero crossing block''s not allowed']
1285     elseif (clkptr(i+1)-clkptr(i))<>0 &funtyp(i)>-1 &funs(i)~='bidon' then
1286       msg=[msg;'Regular block generating activation not allowed yet']
1287     end
1288     if msg<>[] then message(msg),ok=%f,return,end
1289   end
1290
1291   //********************************************************
1292   // Change logical units for readf and writef blocks if any ???
1293   //********************************************************
1294   lunit=0
1295   for d=1:length(funs)
1296     if funs(d)=='readf'  then
1297       z(zptr(d)+2)=lunit
1298       lunit=lunit+1;
1299     elseif funs(d)=='writef'
1300       z(zptr(d)+1)=lunit
1301       lunit=lunit+1;
1302     end
1303   end
1304
1305   //***********************************
1306   // Get the name of the file
1307   //***********************************
1308   foo=3;
1309   okk=%f;
1310   rdnom='foo';
1311   rpat=pwd();
1312   libs='';
1313   label1=[hname;pwd()+'/'+hname;''];
1314
1315   while %t do
1316     ok=%t  // to avoid infinite loop
1317     [okk,..
1318      rdnom,..
1319      rpat,..
1320      libs,..
1321      label1]=scicos_getvalue('Set code generator parameters :',..
1322                       ['New block''s name :';
1323                        'Created files Path :';
1324                        'Other object files to link with (if any)'],..
1325                        list('str',1,'str',1,'str',1),label1);
1326     if okk==%f then
1327       ok=%f
1328       return
1329     end
1330     rpat=stripblanks(rpat);
1331
1332     //** 1/07/06 Alan trying to solve multiple libraries during week-end
1333     if strindex(libs,'''')<>[] | strindex(libs,'""')<>[] then
1334       ierr=execstr('libs=evstr(libs)','errcatch')
1335       if ierr<>0  then
1336         message(['Can''t solve other files to link'])
1337         ok=%f;
1338         return
1339       end
1340     end
1341
1342     //** Alan, I put a warning here in order to inform the user
1343     //** that the name of the superblock will change
1344     //** because the space char in name isn't allowed.
1345     if grep(rdnom," ")<>[] then
1346       message(['Superblock name cannot contains space characters.';
1347                'space chars will be automatically substituted by ""_"" '])
1348     end
1349     rdnom = strsubst(rdnom,' ','_');
1350
1351     //** Put a warning here in order to inform the user
1352     //** that the name of the superblock will change
1353     //** because the "-" char could generate GCC problems
1354     //** (the C functions contains the name of the superblock).
1355     if grep(rdnom,"-")<>[] then
1356       message(['For full C compiler compatibility ';
1357                'Superblock name cannot contains ""-"" characters';
1358                '""-"" chars will be automatically substituted by ""_"" '])
1359     end
1360     rdnom = strsubst(rdnom,'-','_');
1361
1362     dirinfo=fileinfo(rpat)
1363
1364     if dirinfo==[] then
1365       [pathrp,fnamerp,extensionrp]=fileparts(rpat)
1366       ok=mkdir(pathrp,fnamerp+extensionrp)
1367       if ~ok then
1368         messagebox('Directory '+rpat+' cannot be created',"modal","info");
1369       end
1370     elseif filetype(dirinfo(2))<>'Directory' then
1371       ok=%f;
1372       messagebox(rpat+' is not a directory',"modal","error");
1373     end
1374
1375     if stripblanks(rdnom)==emptystr() then
1376       ok=%f;
1377       messagebox('sorry C file name not defined',"modal","error");
1378     end
1379     if ok then break,end
1380   end
1381
1382   //////////////////////////////////////////////////
1383   maxnrpar=max(rpptr(2:$)-rpptr(1:$-1))
1384   maxnipar=max(ipptr(2:$)-ipptr(1:$-1))
1385   maxnx=max(xptr(2:$)-xptr(1:$-1))
1386   maxnz=max(zptr(2:$)-zptr(1:$-1))
1387   maxnin=max(inpptr(2:$)-inpptr(1:$-1))
1388   maxnout=max(outptr(2:$)-outptr(1:$-1))
1389   maxdim=[];
1390   for i=1:lstsize(cpr.state.outtb)
1391     maxdim=max(size(cpr.state.outtb(i)))
1392   end
1393   maxtotal=max([maxnrpar;maxnipar;maxnx;maxnz;maxnin;maxnout;maxdim]);
1394
1395   //************************************************************************
1396   //generate the call to the blocks and blocs simulation function prototypes
1397   //************************************************************************
1398   wfunclist=list();
1399   nbcap=0;nbact=0;capt=[];actt=[];Protostalone=[];Protos=[];
1400   dfuns=[]
1401   for i=1:length(funs)
1402     if or(i==act) then //block is an actuator
1403       nbact=nbact+1;
1404       [Code,actti,protoi]=call_actuator(i)
1405       wfunclist($+1)=[Code;'if(flag < 0 ) return(5 - flag);']
1406       if nbact==1 then Protostalone=[Protostalone;'';protoi],end
1407       actt=[actt;actti]
1408     elseif or(i==cap) then //block is a sensor
1409       nbcap=nbcap+1;
1410       [Code,capti,protoi]=call_sensor(i)
1411       wfunclist($+1)=[Code;'if(flag < 0 ) return(5 - flag);']
1412       if nbcap==1 then Protostalone=[Protostalone;'';protoi] ,end
1413       capt=[capt;capti]
1414     elseif funs(i)=='bidon'
1415       wfunclist($+1)=' '
1416     elseif funs(i)=='bidon2'
1417       wfunclist($+1)=' '
1418     else
1419       ki=find(funs(i)==dfuns)
1420       dfuns=[dfuns;funs(i)]
1421       //[Code,protoi]=call_block(i)
1422       [Code]=call_block4(i)
1423       if Code<>[] then
1424         wfunclist($+1)=[Code;'if(flag < 0 ) return(5 - flag);']
1425       else
1426         wfunclist($+1)=' ';
1427       end
1428       if ki==[] then
1429         Protos=[Protos;'';BlockProto(i)];
1430         Protostalone=[Protostalone;'';BlockProto(i)];
1431       end
1432     end
1433   end
1434
1435   //**************************************
1436   //on prend en compte l'ordre des numerotation graphique des
1437   //capteur et des actionneur
1438   [junk,index]=gsort(-actt(:,$));
1439   actt=actt(index,1:$) ;
1440   [junk,index]=gsort(-capt(:,$));
1441   capt=capt(index,1:$) ;
1442
1443   //***************************************************
1444   //Compute the initial state and outtb (links)  values
1445   //***************************************************
1446   //petite modification pour uniformiser les fichiers capteurs
1447   //et actionneurs ???
1448   rdcpr=cpr.sim.funs;
1449   for r=1:length(cap),rdcpr(cap(r))='bidon';end
1450   for r=1:length(act),rdcpr(act(r))='bidon';end
1451   Total_rdcpr=cpr.sim;Total_rdcpr.funs=rdcpr;
1452   //
1453   tcur=0;
1454   tf=scs_m.props.tf;
1455   tolerances=scs_m.props.tol;
1456   //[state,t]=scicosim(cpr.state,tcur,tf,Total_rdcpr,'start',tolerances);
1457   //cpr.state=state;
1458   z=cpr.state.z;
1459   outtb=cpr.state.outtb;
1460   //[junk_state,t]=scicosim(cpr.state,tcur,tf,Total_rdcpr,'finish',tolerances);
1461
1462   //***********************************
1463   // Scilab and C files generation
1464   //***********************************
1465
1466   //** generate scilab interfacing funtion
1467   //   of the generated scicos block
1468   ok=gen_gui42();
1469
1470
1471   //** generate C files
1472   //   of the generated scicos block
1473   if ok then
1474     ok=gen_ccode42()
1475   end
1476
1477   //** Generates Makefile, loader
1478   //   and compile and link C files
1479
1480   //** def files to build
1481   files=[rdnom rdnom+'_void_io' rdnom+'_Cblocks']
1482
1483   //** def files to build for standalone
1484   filestan=[rdnom+'_standalone' rdnom+'_act_sens_events' rdnom+'_Cblocks']
1485
1486   if ok then
1487     ok = buildnewblock(rdnom,files,filestan,rpat,libs,'','')
1488   end
1489
1490   //**
1491   //if ok then ok=gen_loader(),end
1492
1493   if ok then
1494     //load the gui function
1495     exec(rpat+'/'+rdnom+'_c.sci');
1496     //Change diagram superblock to new generated block
1497     XX=update_block(XX);
1498     execstr(rdnom+'_c=resume('+rdnom+'_c)')
1499   end
1500
1501 endfunction
1502
1503 //BlockProto : generate prototype
1504 //            of a scicos block
1505 //
1506 //inputs : bk   : bloc index
1507 //
1508 //output : txt  :
1509 //
1510 //16/06/07 Author : A.Layec
1511 function [txt]=BlockProto(bk)
1512
1513   nin=inpptr(bk+1)-inpptr(bk);  //* number of input ports */
1514   nout=outptr(bk+1)-outptr(bk); //* number of output ports */
1515
1516   //**
1517   ftyp=funtyp(bk)
1518   if ftyp>2000 then ftyp=ftyp-2000,end
1519   if ftyp>1000 then ftyp=ftyp-1000,end
1520
1521   //** check function type
1522   if ftyp < 0 then //** ifthenelse eselect blocks
1523       txt = [];
1524       return;
1525   else
1526     if (ftyp<>0 & ftyp<>1 & ftyp<>2 & ftyp<>3 & ftyp<>4) then
1527       disp("types other than 0,1,2,3 or 4 are not yet supported.")
1528       txt = [];
1529       return;
1530     end
1531   end
1532
1533   //** add comment
1534   txt=[get_comment('proto_blk',list(funs(bk),funtyp(bk),bk));]
1535
1536   select ftyp
1537     //** zero funtyp
1538     case 0 then
1539
1540       //*********** prototype definition ***********//
1541       txtp=['(int *, int *, double *, double *, double *, int *, double *, \';
1542             ' int *, double *, int *, double *, int *,int *, int *, \';
1543             ' double *, int *, double *, int *);'];
1544       if (funtyp(bk)>2000 & funtyp(bk)<3000)
1545         blank = get_blank('void '+funs(bk)+'(');
1546         txtp(1) = 'void '+funs(bk)+txtp(1);
1547       elseif (funtyp(bk)<2000)
1548         txtp(1) = 'void C2F('+funs(bk)+')'+txtp(1);
1549         blank = get_blank('void C2F('+funs(bk)+')');
1550       end
1551       txtp(2:$) = blank + txtp(2:$);
1552       txt = [txt;txtp];
1553       //*******************************************//
1554
1555
1556     //**
1557     case 1 then
1558
1559       //*********** prototype definition ***********//
1560       txtp=['(int *, int *, double *, double *, double *, int *, double *, \';
1561             ' int *, double *, int *, double *, int *,int *, int *';]
1562       if (funtyp(bk)>2000 & funtyp(bk)<3000)
1563         blank = get_blank('void '+funs(bk)+'(');
1564         txtp(1) = 'void '+funs(bk)+txtp(1);
1565       elseif (funtyp(bk)<2000)
1566         txtp(1) = 'void C2F('+funs(bk)+')'+txtp(1);
1567         blank = get_blank('void C2F('+funs(bk)+')');
1568       end
1569       if nin>=1 | nout>=1 then
1570         txtp($)=txtp($)+', \'
1571         txtp=[txtp;'']
1572         if nin>=1 then
1573           for k=1:nin
1574             txtp($)=txtp($)+' double *, int * ,'
1575           end
1576           txtp($)=part(txtp($),1:length(txtp($))-1); //remove last ,
1577         end
1578         if nout>=1 then
1579           if nin>=1 then
1580             txtp($)=txtp($)+', \'
1581             txtp=[txtp;'']
1582           end
1583           for k=1:nout
1584             txtp($)=txtp($)+' double *, int * ,'
1585           end
1586           txtp($)=part(txtp($),1:length(txtp($))-1); //remove last ,
1587         end
1588       end
1589
1590       if ztyp(bk) then
1591         txtp($)=txtp($)+', \'
1592         txtp=[txtp;' double *,int *);'];
1593       else
1594         txtp($)=txtp($)+');';
1595       end
1596
1597       txtp(2:$) = blank + txtp(2:$);
1598       txt = [txt;txtp];
1599       //*******************************************//
1600
1601     //**
1602     case 2 then
1603
1604       //*********** prototype definition ***********//
1605
1606       txtp=['void '+funs(bk)+...
1607             '(int *, int *, double *, double *, double *, int *, double *, \';
1608             ' int *, double *, int *, double *, int *, int *, int *, \'
1609             ' double **, int *, int *, double **,int *, int *'];
1610       if ~ztyp(bk) then
1611         txtp($)=txtp($)+');';
1612       else
1613         txtp($)=txtp($)+', \';
1614         txtp=[txtp;
1615               ' double *,int *);']
1616       end
1617       blank = get_blank('void '+funs(bk));
1618       txtp(2:$) = blank + txtp(2:$);
1619       txt = [txt;txtp];
1620       //********************************************//
1621
1622     //**
1623     case 4 then
1624       txt=[txt;
1625            'void '+funs(bk)+'(scicos_block *, int );'];
1626
1627   end
1628 endfunction
1629
1630 //Generating the routine for actuators interfacing
1631 //
1632 //
1633 //Authors : R. Djenid, R. Nikoukhah, A. Layec
1634 //
1635 //actt=[i uk nuk_1 nuk_2 uk_t bllst(i).ipar]
1636 function Code=make_actuator(standalone)
1637   Call=['/*'+part('-',ones(1,40))+' Actuators */';
1638         'void '+rdnom+'_actuator(flag,nport,nevprt,t,u,nu1,nu2,ut,flag1)']
1639
1640   comments=['     /*'
1641             '      * To be customized for standalone execution';
1642             '      * flag  : specifies the action to be done'
1643             '      * nport : specifies the  index of the Super Bloc'
1644             '      *         regular input (The input ports are numbered'
1645             '      *         from the top to the bottom )'
1646             '      * nevprt: indicates if an activation had been received'
1647             '      *         0 = no activation'
1648             '      *         1 = activation'
1649             '      * t     : the current time value'
1650             '      * u     : the vector inputs value'
1651             '      * nu1   : the input size 1'
1652             '      * nu2   : the input size 2'
1653             '      * ut    : the input type'
1654             '      * flag1 : learn mode (0 from terminal,1 from input file'
1655             '      */']
1656
1657   dcl=['     int *flag,*nevprt,*nport;'
1658        '     int *nu1,*nu2,*ut,flag1;'
1659        ''
1660        '     double *t;'
1661        '     void *u;'
1662        '{'
1663        '  int j,k,l;'];
1664
1665   if standalone then
1666     a_actuator=['  /* skeleton to be customized */'
1667                 '    switch (*flag) {'
1668                 '    case 2 :'
1669                 '      /*if(*nevprt>0) { get the input value */'
1670                 '        switch (*ut) {'
1671                 '        case 10 :'
1672                 '          for (l=0;l<*nu2;l++) {'
1673                 '            for (k=0;k<*nu1;k++) {'
1674                 '              printf(""Actuator: time=%f, '+...
1675                                   'u(%d,%d) of actuator %d is %f '+...
1676                                   '\n"", \'
1677                 '                     *t, k, l, *nport,'+...
1678                                       '*((double *) u+(k+l*(*nu1))));'
1679                 '            }'
1680                 '          }'
1681                 '          break;'
1682                 ''
1683                 '        case 11 :'
1684                 '          for (l=0;l<*nu2;l++) {'
1685                 '            for (k=0;k<*nu1;k++) {'
1686                 '              printf(""Actuator: time=%f, '+...
1687                                   'u(%d,%d) of actuator %d is %f,%f '+...
1688                                   '\n"", \'
1689                 '                     *t, k, l, *nport,'+...
1690                                       '*((double *) u+(k+l*(*nu1))),'+...
1691                                       '*((double *) u+((*nu1)*(*nu2)+k+l*(*nu1))));'
1692                 '            }'
1693                 '          }'
1694                 '          break;'
1695                 ''
1696                 '        case 81 :'
1697                 '          for (l=0;l<*nu2;l++) {'
1698                 '            for (k=0;k<*nu1;k++) {'
1699                 '              printf(""Actuator: time=%f, '+...
1700                                   'u(%d,%d) of actuator %d is %i '+...
1701                                   '\n"", \'
1702                 '                     *t, k, l, *nport,'+...
1703                                       '*((char *) u+(k+l*(*nu1))));'
1704                 '            }'
1705                 '          }'
1706                 '          break;'
1707                 ''
1708                 '        case 82 :'
1709                 '          for (l=0;l<*nu2;l++) {'
1710                 '            for (k=0;k<*nu1;k++) {'
1711                 '              printf(""Actuator: time=%f, '+...
1712                                   'u(%d,%d) of actuator %d is %hd '+...
1713                                   '\n"", \'
1714                 '                     *t, k, l, *nport,'+...
1715                                       '*((short *) u+(k+l*(*nu1))));'
1716                 '            }'
1717                 '          }'
1718                 '          break;'
1719                 ''
1720                 '        case 84 :'
1721                 '          for (l=0;l<*nu2;l++) {'
1722                 '            for (k=0;k<*nu1;k++) {'
1723                 '              printf(""Actuator: time=%f, '+...
1724                                   'u(%d,%d) of actuator %d is %ld '+...
1725                                   '\n"", \'
1726                 '                     *t, k, l, *nport,'+...
1727                                       '*((long *) u+(k+l*(*nu1))));'
1728                 '            }'
1729                 '          }'
1730                 '          break;'
1731                 ''
1732                 '        case 811 :'
1733                 '          for (l=0;l<*nu2;l++) {'
1734                 '            for (k=0;k<*nu1;k++) {'
1735                 '              printf(""Actuator: time=%f, '+...
1736                                   'u(%d,%d) of actuator %d is %d '+...
1737                                   '\n"", \'
1738                 '                     *t, k, l, *nport,'+...
1739                                       '*((unsigned char *) u+(k+l*(*nu1))));'
1740                 '            }'
1741                 '          }'
1742                 '          break;'
1743                 ''
1744                 '        case 812 :'
1745                 '          for (l=0;l<*nu2;l++) {'
1746                 '            for (k=0;k<*nu1;k++) {'
1747                 '              printf(""Actuator: time=%f, '+...
1748                                   'u(%d,%d) of actuator %d is %hu '+...
1749                                   '\n"", \'
1750                 '                     *t, k, l, *nport,'+...
1751                                       '*((unsigned short *) u+(k+l*(*nu1))));'
1752                 '            }'
1753                 '          }'
1754                 '          break;'
1755                 ''
1756                 '        case 814 :'
1757                 '          for (l=0;l<*nu2;l++) {'
1758                 '            for (k=0;k<*nu1;k++) {'
1759                 '              printf(""Actuator: time=%f, '+...
1760                                   'u(%d,%d) of actuator %d is %lu '+...
1761                                   '\n"", \'
1762                 '                     *t, k, l, *nport,'+...
1763                                       '*((unsigned long *) u+(k+l*(*nu1))));'
1764                 '            }'
1765                 '          }'
1766                 '          break;'
1767                 '        }'
1768                 '      /*} */'
1769                 '      break;'
1770                 '    case 4 : /* actuator initialisation */'
1771                 '      /* do whatever you want to initialize the actuator */'
1772                 '      break;'
1773                 '    case 5 : /* actuator ending */'
1774                 '      /* do whatever you want to end the actuator */'
1775                 '      break;'
1776                 '    }']
1777   else
1778     a_actuator=[]
1779   end
1780
1781   // pour fprintf
1782   nc=size(act,'*') // Alan : d'o? viens act ?????
1783                    // reponse : de do_compile_superblock!
1784   typ=['""%f ']; //time
1785   for i=1:nc
1786     typ($)=typ($)+'"" \'
1787     typ=[typ;'""'];
1788     for j=1:sum(actt(i,3)*actt(i,4))
1789       //typ=typ+'%f ';
1790       typ($)=typ($)+scs_c_n2c_fmt(actt(i,5))+' ';
1791     end
1792   end
1793   typ($)=typ($)+'\n"", \'
1794   typ(1)='    fprintf(fprw,'+typ(1);
1795   bl    ='                 ';
1796   if size(typ,1) <> 1 then
1797     typ(2:$) = bl+typ(2:$);
1798   end
1799   //Code1='    fprintf(fprw, '"'+typ+' \n'",*t'
1800   Code1=[typ;bl+'*t'];
1801   //actt=[i uk nuk_1 nuk_2 uk_t bllst(i).ipar]
1802   for i=1:size(actt,1)
1803     ni=actt(i,3)*actt(i,4) // dimension of ith output
1804     Code1($)=Code1($)+','
1805     Code1=[Code1;bl];
1806     for j=1:ni
1807       if actt(i,5)<>11 then
1808         Code1($)=Code1($)+...
1809                   '*((('+scs_c_n2c_typ(actt(i,5))+' *)('+...
1810                    rdnom+'_block_outtbptr+'+string(actt(i,2)-1)+'))'+...
1811                    '+'+string(j-1)+')';
1812       else //CAS CMPLX
1813         Code1($)=Code1($)+...
1814                   '*((('+scs_c_n2c_typ(actt(i,5))+' *)('+...
1815                    rdnom+'_block_outtbptr+'+string(actt(i,2)-1)+'))'+...
1816                    '+'+string((j-1))+'), '+...
1817                   '*((('+scs_c_n2c_typ(actt(i,5))+' *)('+...
1818                    rdnom+'_block_outtbptr+'+string(actt(i,2)-1)+'))'+...
1819                    '+'+string(ni+(j-1))+')';
1820       end
1821       if j<>ni then
1822        Code1($)=Code1($)+', ';
1823       end
1824     end
1825   end
1826   Code1($)=Code1($)+');'
1827
1828   Code=[]
1829
1830   if nc==1|~standalone then
1831     Code=[Call
1832           comments
1833           dcl
1834           '  if (flag1 == 0) {'
1835           a_actuator
1836           '  }'
1837           '  else if (flag1 == 1) {'
1838           '    if (*flag == 4 && *nport == 1) {'
1839           '      fprw=fopen(output,'"wt'");'
1840           '      if( fprw == NULL )'
1841           '        {'
1842           '          printf('"Error opening file: %s\n'", output);'
1843           '          return;'
1844           '        }'
1845           '    }else if (*flag == 2 /* && *nevprt>0 */) {'
1846           Code1
1847           '    }else if (*flag == 5 && *nport == 1) {'
1848           '      fclose(fprw);'
1849           '    }'
1850           '  }'
1851           '}']
1852   elseif nc>1 then
1853     S='  switch (*nport) {'
1854     for k=1:nc
1855       S=[S;
1856          '  case '+string(k)+' :/* Port number '+string(k)+' ----------*/'
1857          '  '+a_actuator
1858          '  break;']
1859     end
1860     S=[S;'  }']
1861
1862     Code=[Code
1863           Call
1864           comments
1865           dcl
1866           '  if (flag1 == 0){'
1867           S
1868           '  }'
1869           '  else if (flag1 == 1) {'
1870           '    if (*flag == 4 && *nport == 1) {'
1871           '      fprw=fopen(output,'"wt'");'
1872           '      if( fprw == NULL ) {'
1873           '        printf('"Error opening file: %s\n'", output);'
1874           '        return;'
1875           '        }'
1876           '    }'
1877           '    else if (*flag == 2 /*&& *nevprt>0*/ ) {'
1878           Code1
1879           '    }'
1880           '    else if (*flag == 5 && *nport == 1) {'
1881           '      fclose(fprw);'
1882           '    }'
1883           '  }'
1884           '}']
1885   end
1886 endfunction
1887
1888 //** Generates the scicos computational function
1889 //   associated with the block
1890 //12/07/07 Alan Layec
1891 function Code=make_computational42()
1892   z=cpr.state.z;
1893   oz=cpr.state.oz;
1894   outtb=cpr.state.outtb;
1895   tevts=cpr.state.tevts;
1896   evtspt=cpr.state.evtspt;
1897   outptr=cpr.sim.outptr;
1898   funtyp=cpr.sim.funtyp;
1899   clkptr=cpr.sim.clkptr;
1900   ordptr=cpr.sim.ordptr;
1901   pointi=cpr.state.pointi;
1902   ztyp=cpr.sim.ztyp;
1903   zcptr=cpr.sim.zcptr;
1904   zptr=cpr.sim.zptr;
1905   ozptr=cpr.sim.ozptr;
1906   opptr=cpr.sim.opptr;
1907   opar=cpr.sim.opar;
1908   rpptr=cpr.sim.rpptr;
1909   ipptr=cpr.sim.ipptr;
1910   inpptr=cpr.sim.inpptr;
1911   funs=cpr.sim.funs;
1912   xptr=cpr.sim.xptr;
1913   modptr=cpr.sim.modptr;
1914   inplnk=cpr.sim.inplnk;
1915   nblk=cpr.sim.nb;
1916   outlnk=cpr.sim.outlnk;
1917   oord=cpr.sim.oord;
1918   zord=cpr.sim.zord;
1919   iord=cpr.sim.iord;
1920   noord=size(cpr.sim.oord,1);
1921   nzord=size(cpr.sim.zord,1);
1922   niord=size(cpr.sim.iord,1);
1923
1924   Indent='  ';
1925   Indent2=Indent+Indent;
1926   BigIndent='          ';
1927
1928   nZ=size(z,'*'); //** index of work in z
1929   nO=lstsize(oz); //** index of outtb in oz
1930
1931   stalone=%f
1932
1933   Code=['/* SCILAB Computational function  */'
1934         '/*     Copyright INRIA */'
1935         '/*     Copyright DIGITEO - 2010 */'
1936         '/*     Generated by Code_Generation toolbox of Xcos with '+ ..
1937         getversion()+' */';
1938         '/*     date : '+date()+' */'
1939         ''
1940         '/* ---- Headers ---- */'
1941         '#include <stdio.h>'
1942         '#include <stdlib.h>'
1943         '#include <memory.h>'
1944         '#include <string.h>'
1945         '#include ""machine.h"" '
1946         '#include ""scicos.h"" '
1947         '#include ""scicos_malloc.h"" '
1948         '#include ""scicos_free.h"" '
1949         '']
1950
1951   if getos() == 'Windows' then
1952
1953    Code=[Code;
1954          ' '
1955          '#define max(a,b) ((a) >= (b) ? (a) : (b))'
1956          '#define min(a,b) ((a) <= (b) ? (a) : (b))'
1957          ' '
1958         ]
1959   end
1960
1961   Code=[Code;
1962         Protos
1963         '']
1964
1965   Code=[Code;
1966         '/* Table of constant values */'
1967         'static int nrd_'+string(0:maxtotal)'+' = '+string(0:maxtotal)'+';']
1968
1969   if maxtotal<10 then
1970     Code=[Code;
1971           'static int nrd_10 = 10;']
1972   end
1973   if maxtotal<11 then
1974     Code=[Code;
1975           'static int nrd_11 = 11;']
1976   end
1977
1978   if maxtotal<81 then
1979     Code=[Code;
1980           'static int nrd_81 = 81;']
1981   end
1982   if maxtotal<82 then
1983     Code=[Code;
1984           'static int nrd_82 = 82;']
1985   end
1986   if maxtotal<84 then
1987     Code=[Code;
1988           'static int nrd_84 = 84;']
1989   end
1990   if maxtotal<811 then
1991     Code=[Code;
1992           'static int nrd_811 = 811;']
1993   end
1994   if maxtotal<812 then
1995     Code=[Code;
1996           'static int nrd_812 = 812;']
1997   end
1998   if maxtotal<814 then
1999     Code=[Code;
2000           'static int nrd_814 = 814;']
2001   end
2002
2003   Code=[Code;
2004         ''
2005         '/* Some general static variables */'
2006         'static double zero=0;'
2007         'static double w[1];'
2008         'static int aaa=0, bbb=0;']
2009
2010   Code=[Code;
2011         ''
2012         '/*'+part('-',ones(1,40))+' Block Computational function */ ';
2013         'int  '+rdnom+'(scicos_block *block, int flag)'
2014         '{'
2015         '  /* declaration of local variables for that block struct */'
2016         '  double* z      = block->z;'
2017         '  void **ozptr   = block->ozptr;'
2018         '  void **oparptr = block->oparptr;'
2019         '  int nopar      = block->nopar;'
2020         '  double* x      = block->x;'
2021         '  double* xd     = block->xd;'
2022         '  double* res    = block->res;'
2023         '  void** u       = block->inptr;'
2024         '  void** y       = block->outptr;'
2025         '  int nevprt     = block->nevprt;'
2026         '  double* rpar   = block->rpar;'
2027         '  int nrpar      = block->nrpar;'
2028         '  int* ipar      = block->ipar;'
2029         '  int nipar      = block->nipar;'
2030         '  double* g      = block->g;'
2031         '  int* mode      = block->mode;'
2032         '  void **work    = block->work;'
2033         ''
2034         '  double t     = get_scicos_time();'
2035         '  int    phase = get_phase_simulation();'
2036         ''
2037         '  int kf = 0;'
2038         '  int i = 0;'
2039         '  int* reentryflag = NULL;'
2040         ''
2041         '  double *args[100];'
2042         '  int local_flag;'
2043         '  int nport;'
2044         '  void **'+rdnom+'_block_outtbptr;'
2045         '  scicos_block *block_'+rdnom+';'
2046         ''
2047         '  /*  work of blocks are catenated at the end of z */'
2048         '  work = (void **)(z+'+string(nZ)+');'
2049         ''
2050         '  /*  '+rdnom+'_block_outtbptr is catenated at the end of oz */'
2051         '  '+rdnom+'_block_outtbptr = (void **)(ozptr+'+string(nO)+');'
2052         ''
2053         '  /* struct of all blocks are stored in work of that block struct */'
2054         '  block_'+rdnom+'=(scicos_block*) *block->work;'
2055         ''];
2056
2057   Code=[Code;
2058         '  /* Copy inputs in the block outtb */'];
2059
2060   for i=1:size(capt,1)
2061     ni=capt(i,3)*capt(i,4); //** dimension of ith input
2062     if capt(i,5)<>11 then
2063       Code=[Code;
2064             '  memcpy(*('+rdnom+'_block_outtbptr+'+string(capt(i,2)-1)+'),'+...
2065             '*(u+'+string(capt(i,6)-1)+'),'+...
2066              string(ni)+'*sizeof('+mat2c_typ(capt(i,5))+'));']
2067     else //** Cas cmplx
2068       Code=[Code;
2069             '  memcpy(*('+rdnom+'_block_outtbptr+'+string(capt(i,2)-1)+'),'+...
2070             '*(u+'+string(capt(i,6)-1)+'),'+...
2071              string(2*ni)+'*sizeof('+mat2c_typ(capt(i,5))+'));']
2072     end
2073   end
2074
2075   Code=[Code;
2076         ''
2077         '  if (flag != 4 && flag != 6 && flag != 5){'
2078         '    reentryflag=(int*) ((scicos_block *)(*block->work)+'+string(nblk)+');'
2079         '    if (*reentryflag==0){'
2080         '      *reentryflag=1;']
2081
2082   for kf=1:nblk
2083     nin=inpptr(kf+1)-inpptr(kf);  //** number of input ports
2084     nout=outptr(kf+1)-outptr(kf); //** number of output ports
2085     nx=xptr(kf+1)-xptr(kf);
2086     ng=zcptr(kf+1)-zcptr(kf);
2087     nmode=modptr(kf+1)-modptr(kf);
2088
2089     //** add comment
2090     txt=[get_comment('set_blk',list(funs(kf),funtyp(kf),kf));]
2091
2092     Code=[Code;
2093           ''
2094           '      '+txt];
2095
2096     for k=1:nin
2097       lprt=inplnk(inpptr(kf)-1+k);
2098       Code=[Code;
2099             '      block_'+rdnom+'['+string(kf-1)+'].inptr['+string(k-1)+']  = '+...
2100             rdnom+'_block_outtbptr['+string(lprt-1)+'];']
2101     end
2102     for k=1:nout
2103        lprt=outlnk(outptr(kf)-1+k);
2104        Code=[Code
2105              '      block_'+rdnom+'['+string(kf-1)+'].outptr['+string(k-1)+'] = '+...
2106              rdnom+'_block_outtbptr['+string(lprt-1)+'];']
2107     end
2108     Code=[Code
2109           '      block_'+rdnom+'['+string(kf-1)+'].z         = &(z['+...
2110           string(zptr(kf)-1)+']);']
2111     if nx <> 0 then
2112       Code=[Code;
2113             '      block_'+rdnom+'['+string(kf-1)+'].x         = &(x['+...
2114             string(xptr(kf)-1)+']);']
2115     else
2116       Code=[Code;
2117             '      block_'+rdnom+'['+string(kf-1)+'].x         = &(zero);'
2118             '      block_'+rdnom+'['+string(kf-1)+'].xd        = w;']
2119     end
2120     if ng <> 0 then
2121       Code=[Code;
2122             '      block_'+rdnom+'['+string(kf-1)+'].g         = &(g['+...
2123             string(zcptr(kf)-1)+']);']
2124     else
2125       Code=[Code;
2126             '      block_'+rdnom+'['+string(kf-1)+'].g         = &(zero);';]
2127     end
2128     if nmode <> 0 then
2129       Code=[Code;
2130             '      block_'+rdnom+'['+string(kf-1)+'].mode      = &(mode['+...
2131             string(modptr(kf)-1)+']);']
2132     end
2133     if (part(funs(kf),1:7) ~= 'capteur' &...
2134         part(funs(kf),1:10) ~= 'actionneur' &...
2135         funs(kf) ~= 'bidon' &...
2136         funs(kf) ~= 'bidon2') then
2137       //** rpar **//
2138       if (rpptr(kf+1)-rpptr(kf)>0) then
2139         Code=[Code;
2140               '      block_'+rdnom+'['+string(kf-1)+'].rpar      = &(rpar['+...
2141               string(rpptr(kf)-1)+']);']
2142       end
2143       //** ipar **//
2144       if (ipptr(kf+1)-ipptr(kf)>0) then
2145          Code=[Code;
2146                '      block_'+rdnom+'['+string(kf-1)+'].ipar      = &(ipar['+...
2147                string(ipptr(kf)-1)+']);']
2148       end
2149       //** opar **//
2150       if (opptr(kf+1)-opptr(kf)>0) then
2151         nopar = opptr(kf+1)-opptr(kf);
2152         for k=1:nopar
2153           Code=[Code;
2154                 '      block_'+rdnom+'['+string(kf-1)+'].oparptr['+string(k-1)+...
2155                 '] = oparptr['+string(opptr(kf)-1+k-1)+'];'];
2156         end
2157       end
2158       //** oz **//
2159       if (ozptr(kf+1)-ozptr(kf)>0) then
2160         noz = ozptr(kf+1)-ozptr(kf);
2161         for k=1:noz
2162           Code=[Code;
2163                 '      block_'+rdnom+'['+string(kf-1)+'].ozptr['+string(k-1)+...
2164                 ']  = ozptr['+string(ozptr(kf)-1+k-1)+'];'];
2165         end
2166       end
2167     end
2168     Code=[Code;
2169           '      block_'+rdnom+'['+string(kf-1)+'].work      ='+...
2170           ' (void **)(((double *)work)+'+string(kf-1)+');']
2171   end
2172   Code=[Code
2173         '    }'
2174         '  }'
2175         ''
2176        ]
2177
2178   /////////////////////////////////////////////
2179
2180
2181   //** find activation number
2182   blks=find(funtyp>-1);
2183   evs=[];
2184
2185   for blk=blks
2186     for ev=clkptr(blk):clkptr(blk+1)-1
2187       if funs(blk)=='bidon' then
2188         if ev > clkptr(howclk) -1
2189          evs=[evs,ev];
2190         end
2191       end
2192     end
2193   end
2194
2195   //** flag 0
2196   flag = 0;
2197
2198   block_has_output=%f
2199   txt   = [];
2200   txt22 = [];
2201
2202   for kf=1:nblk
2203      nx=xptr(kf+1)-xptr(kf);
2204      if nx <> 0 then
2205           txt=[txt;
2206                '    block_'+rdnom+'['+string(kf-1)+'].xd=&(xd['+...
2207                 string(xptr(kf)-1)+']);']
2208      end
2209      if part(funs(kf),1:10) == 'actionneur' then
2210        block_has_output=%t
2211      end
2212   end
2213   if txt<>[] then
2214     txt22=[txt22;
2215            '    '+get_comment('update_xd',list())
2216            txt
2217            ''
2218           ]
2219   end
2220   txt22=[txt22;
2221          write_code_odoit(1) //** first pass
2222          write_code_odoit(0) //** second pass
2223         ]
2224
2225   if txt22<>[] then
2226     Code=[Code;
2227           '  if (flag == 0) { '+get_comment('flag',list(flag))
2228           txt22
2229           '  }'];
2230   end
2231
2232   //** flag 1,2,3
2233   for flag=[1,2,3]
2234
2235     txt3=[]
2236
2237     //** continuous time blocks must be activated
2238     //** for flag 1
2239     if flag==1 then
2240       txt = write_code_cdoit(flag);
2241
2242       if txt <> [] then
2243         txt3=[txt3;
2244              Indent+'  switch (nevprt) {'
2245             ];
2246         txt3=[txt3;
2247               Indent2+'  case '+string(0)+' : '+...
2248               get_comment('ev',list(0))
2249               '    '+txt;
2250              ];
2251         txt3=[txt3;'      break;';'']
2252       end
2253     else
2254       txt=[];
2255     end
2256
2257     //** blocks with input discrete event must be activated
2258     //** for flag 1, 2 and 3
2259     if size(evs,2)>=1 then
2260       txt4=[]
2261       //**
2262       for ev=evs
2263         txt2=write_code_doit(ev,flag);
2264         if txt2<>[] then
2265           //** adjust event number because of bidon block
2266           new_ev=ev-(clkptr(howclk)-1)
2267           //**
2268           txt4=[txt4;
2269                 Indent2+['  case '+string(new_ev)+' : '+...
2270                 get_comment('ev',list(new_ev))
2271                    txt2];
2272                 '      break;';'']
2273         end
2274       end
2275
2276       //**
2277       if txt == [] then
2278         if txt4 <> [] then
2279           txt3=[txt3;
2280                 Indent+'  switch (nevprt) {'
2281                 txt4
2282                 '    }'];
2283         end
2284       else
2285         txt3=[txt3;
2286               txt4]
2287       end
2288     end
2289
2290     //**
2291     if txt <> [] then
2292       txt3=[txt3;
2293             '    }'];
2294     end
2295
2296     //**
2297     if txt3<>[] then
2298       if flag==1 & txt22==[] then
2299         Code=[Code;
2300               '  if (flag == '+string(flag)+') { '+...
2301               get_comment('flag',list(flag))
2302               txt3
2303               '  }'];
2304       else
2305         Code=[Code;
2306               '  else if (flag == '+string(flag)+') { '+...
2307               get_comment('flag',list(flag))
2308               txt3
2309               '  }'];
2310       end
2311     end
2312   end
2313
2314   //** flag 9
2315   ng=zcptr($)-1;
2316   if (ng ~= 0) then
2317     flag = 9;
2318     Code=[Code;
2319           '  else if (flag == '+string(flag)+') { '+...
2320            get_comment('flag',list(flag))
2321          ];
2322
2323     txt=[]
2324     for kf=1:nblk
2325       if zcptr(kf+1)-zcptr(kf) <> 0 then
2326          txt=[txt;
2327               '    block_'+rdnom+'['+string(kf-1)+'].g='+...
2328               '&(g['+string(zcptr(kf)-1)+']);']
2329       end
2330     end
2331
2332     Code=[Code;
2333           '    '+get_comment('update_g',list())
2334           txt
2335           ''
2336           write_code_zdoit()
2337          ]
2338
2339     Code=[Code;
2340           '  }'];
2341   end
2342
2343   //** flag 4
2344   Code=[Code;
2345         '  else if (flag == 4) { '+get_comment('flag',list(4))
2346         '    if ((*block->work=scicos_malloc(sizeof(scicos_block)*'+...
2347          string(nblk)+'+sizeof(int)))== NULL) return 0;';
2348         '    reentryflag=(int*) ((scicos_block *)(*block->work)+'+string(nblk)+');'
2349         '    *reentryflag=0;'
2350         '    block_'+rdnom+'=(scicos_block*) *block->work;'];
2351
2352   for kf=1:nblk
2353     nin=inpptr(kf+1)-inpptr(kf);  //* number of input ports */
2354     nout=outptr(kf+1)-outptr(kf); //* number of output ports */
2355     nx=xptr(kf+1)-xptr(kf);
2356     ng=zcptr(kf+1)-zcptr(kf);
2357     nmode=modptr(kf+1)-modptr(kf);
2358
2359     //** add comment
2360     txt=[get_comment('set_blk',list(funs(kf),funtyp(kf),kf));]
2361
2362     Code=[Code;
2363           ''
2364           '    '+txt];
2365
2366     Code=[Code;
2367           '    block_'+rdnom+'['+string(kf-1)+'].type   = '+...
2368             string(funtyp(kf))+';';
2369           '    block_'+rdnom+'['+string(kf-1)+'].ztyp   = '+...
2370             string(ztyp(kf))+';';
2371           '    block_'+rdnom+'['+string(kf-1)+'].ng     = '+...
2372             string(zcptr(kf+1)-zcptr(kf))+';']
2373
2374     if nx <> 0 then
2375       Code=[Code;
2376             '    block_'+rdnom+'['+string(kf-1)+'].nx     = '+...
2377              string(nx)+';';
2378             '    block_'+rdnom+'['+string(kf-1)+'].x      = &(x['+...
2379              string(xptr(kf)-1)+']);']
2380     else
2381       Code=[Code;
2382             '    block_'+rdnom+'['+string(kf-1)+'].nx     = 1;';
2383             '    block_'+rdnom+'['+string(kf-1)+'].x      = &(zero);'
2384             '    block_'+rdnom+'['+string(kf-1)+'].xd     = w;']
2385     end
2386
2387     if ng <> 0 then
2388       Code=[Code;
2389             '    block_'+rdnom+'['+string(kf-1)+'].g      = &(g['+...
2390             string(zcptr(kf)-1)+']);']
2391     else
2392       Code=[Code;
2393             '    block_'+rdnom+'['+string(kf-1)+'].g      = &(zero);';]
2394     end
2395     if nmode <> 0 then
2396       Code=[Code;
2397             '    block_'+rdnom+'['+string(kf-1)+'].mode   = &(mode['+...
2398             string(modptr(kf)-1)+']);']
2399     end
2400     Code=[Code;
2401           '    block_'+rdnom+'['+string(kf-1)+'].nz     = '+...
2402             string(zptr(kf+1)-zptr(kf))+';';
2403           '    block_'+rdnom+'['+string(kf-1)+'].noz    = '+...
2404             string(ozptr(kf+1)-ozptr(kf))+';';
2405           '    block_'+rdnom+'['+string(kf-1)+'].nrpar  = '+...
2406             string(rpptr(kf+1)-rpptr(kf))+';';
2407           '    block_'+rdnom+'['+string(kf-1)+'].nopar  = '+...
2408             string(opptr(kf+1)-opptr(kf))+';';
2409           '    block_'+rdnom+'['+string(kf-1)+'].nipar  = '+...
2410             string(ipptr(kf+1)-ipptr(kf))+';'
2411           '    block_'+rdnom+'['+string(kf-1)+'].nin    = '+...
2412             string(inpptr(kf+1)-inpptr(kf))+';';
2413           '    block_'+rdnom+'['+string(kf-1)+'].nout   = '+...
2414             string(outptr(kf+1)-outptr(kf))+';';
2415           '    block_'+rdnom+'['+string(kf-1)+'].nevout = '+...
2416             string(clkptr(kf+1)-clkptr(kf))+';';
2417           '    block_'+rdnom+'['+string(kf-1)+'].nmode  = '+...
2418             string(modptr(kf+1)-modptr(kf))+';'];
2419
2420     Code=[Code;
2421           '    if ((block_'+rdnom+'['+string(kf-1)+'].evout  = '+...
2422           'calloc(block_'+rdnom+'['+string(kf-1)+'].nevout,sizeof(double)))== NULL) return 0;'];
2423
2424     //***************************** input port *****************************//
2425     //** alloc insz/inptr **//
2426     Code=[Code;
2427           '    if ((block_'+rdnom+'['+string(kf-1)+'].insz   = '+...
2428           'malloc(3*sizeof(int)*block_'+rdnom+'['+string(kf-1)+'].nin))== NULL) return 0;';
2429           '    if ((block_'+rdnom+'['+string(kf-1)+'].inptr  = '+...
2430           'malloc(sizeof(void *)*block_'+rdnom+'['+string(kf-1)+'].nin))== NULL) return 0;'];
2431
2432     //** inptr **//
2433     for k=1:nin
2434        lprt=inplnk(inpptr(kf)-1+k);
2435        Code=[Code
2436              '    block_'+rdnom+'['+string(kf-1)+'].inptr['+string(k-1)+']  = '+...
2437              rdnom+'_block_outtbptr['+string(lprt-1)+'];']
2438     end
2439
2440     //** 1st dim **//
2441     for k=1:nin
2442        lprt=inplnk(inpptr(kf)-1+k);
2443        Code=[Code
2444              '    block_'+rdnom+'['+string(kf-1)+'].insz['+string((k-1))+']   = '+...
2445               string(size(outtb(lprt),1))+';']
2446     end
2447
2448     //** 2dn dim **//
2449     for k=1:nin
2450        lprt=inplnk(inpptr(kf)-1+k);
2451        Code=[Code
2452              '    block_'+rdnom+'['+string(kf-1)+'].insz['+string((k-1)+nin)+']   = '+...
2453               string(size(outtb(lprt),2))+';']
2454     end
2455
2456     //** typ **//
2457     for k=1:nin
2458        lprt=inplnk(inpptr(kf)-1+k);
2459        Code=[Code
2460              '    block_'+rdnom+'['+string(kf-1)+'].insz['+string((k-1)+2*nin)+']   = '+...
2461               mat2scs_c_typ(outtb(lprt))+';'];
2462     end
2463     //**********************************************************************//
2464
2465     //***************************** output port *****************************//
2466     //** alloc outsz/outptr **//
2467     Code=[Code
2468           '    if ((block_'+rdnom+'['+string(kf-1)+'].outsz  = '+...
2469            'malloc(3*sizeof(int)*block_'+rdnom+'['+string(kf-1)+'].nout))== NULL) return 0;';
2470           '    if ((block_'+rdnom+'['+string(kf-1)+'].outptr = '+...
2471            'malloc(sizeof(void*)*block_'+rdnom+'['+string(kf-1)+'].nout))== NULL) return 0;'];
2472
2473     //** outptr **//
2474     for k=1:nout
2475        lprt=outlnk(outptr(kf)-1+k);
2476        Code=[Code
2477              '    block_'+rdnom+'['+string(kf-1)+'].outptr['+string(k-1)+'] = '+...
2478               rdnom+'_block_outtbptr['+string(lprt-1)+'];']
2479     end
2480
2481     //** 1st dim **//
2482     for k=1:nout
2483        lprt=outlnk(outptr(kf)-1+k);
2484        Code=[Code
2485              '    block_'+rdnom+'['+string(kf-1)+'].outsz['+string((k-1))+...
2486              ']  = '+string(size(outtb(lprt),1))+';']
2487     end
2488
2489     //** 2dn dim **//
2490     for k=1:nout
2491        lprt=outlnk(outptr(kf)-1+k);
2492        Code=[Code
2493              '    block_'+rdnom+'['+string(kf-1)+'].outsz['+string((k-1)+nout)+...
2494              ']  = '+string(size(outtb(lprt),2))+';']
2495     end
2496
2497     //** typ **//
2498     for k=1:nout
2499        lprt=outlnk(outptr(kf)-1+k);
2500        Code=[Code
2501              '    block_'+rdnom+'['+string(kf-1)+'].outsz['+string((k-1)+2*nout)+...
2502              ']  = '+mat2scs_c_typ(outtb(lprt))+';'];
2503     end
2504     //**********************************************************************//
2505
2506     Code=[Code
2507           '    block_'+rdnom+'['+string(kf-1)+'].z         = &(z['+...
2508           string(zptr(kf)-1)+']);']
2509
2510     //***************************** object state *****************************//
2511     if (ozptr(kf+1)-ozptr(kf)>0) then
2512       noz = ozptr(kf+1)-ozptr(kf);
2513       Code=[Code
2514             '    if ((block_'+rdnom+'['+string(kf-1)+'].ozptr = '+...
2515             'malloc(sizeof(void *)*block_'+rdnom+'['+string(kf-1)+'].noz))== NULL) return 0;';
2516             '    if ((block_'+rdnom+'['+string(kf-1)+'].ozsz  = '+...
2517             'malloc(2*sizeof(int)*block_'+rdnom+'['+string(kf-1)+'].noz))== NULL) return 0;';
2518             '    if ((block_'+rdnom+'['+string(kf-1)+'].oztyp = '+...
2519             'malloc(sizeof(int)*block_'+rdnom+'['+string(kf-1)+'].noz))== NULL) return 0;';]
2520
2521       //** ozptr **//
2522       for k=1:noz
2523         Code=[Code;
2524               '    block_'+rdnom+'['+string(kf-1)+'].ozptr['+string(k-1)+...
2525               ']  = ozptr['+string(ozptr(kf)-1+k-1)+'];'];
2526       end
2527
2528       //** 1st dim **//
2529       for k=1:noz
2530         Code=[Code;
2531               '    block_'+rdnom+'['+string(kf-1)+'].ozsz['+string(k-1)+...
2532               ']   = '+string(size(oz(ozptr(kf)-1+k),1))+';'];
2533       end
2534
2535       //** 2nd dim **//
2536       for k=1:noz
2537         Code=[Code;
2538               '    block_'+rdnom+'['+string(kf-1)+'].ozsz['+string(k-1)+...
2539               ']   = '+string(size(oz(ozptr(kf)-1+k),2))+';'];
2540       end
2541
2542       //** typ **//
2543       for k=1:noz
2544         Code=[Code;
2545               '    block_'+rdnom+'['+string(kf-1)+'].oztyp['+string(k-1)+...
2546               ']  = '+mat2scs_c_typ(oz(ozptr(kf)-1+k))+';'];
2547       end
2548     end
2549     //************************************************************************//
2550
2551     if (part(funs(kf),1:7) ~= 'capteur' &...
2552         part(funs(kf),1:10) ~= 'actionneur' &...
2553         funs(kf) ~= 'bidon' &...
2554         funs(kf) ~= 'bidon2') then
2555       if (rpptr(kf+1)-rpptr(kf)>0) then
2556         Code=[Code;
2557               '    block_'+rdnom+'['+string(kf-1)+...
2558               '].rpar      = &(rpar['+string(rpptr(kf)-1)+']);']
2559       end
2560       if (ipptr(kf+1)-ipptr(kf)>0) then
2561         Code=[Code;
2562               '    block_'+rdnom+'['+string(kf-1)+...
2563               '].ipar      = &(ipar['+string(ipptr(kf)-1)+']);']
2564       end
2565       //** opar
2566       if (opptr(kf+1)-opptr(kf)>0) then
2567         Code=[Code;
2568               '    if ((block_'+rdnom+'['+string(kf-1)+'].oparptr = '+...
2569                'malloc(sizeof(void *)*block_'+rdnom+'['+string(kf-1)+'].nopar))== NULL) return 0;';
2570               '    if ((block_'+rdnom+'['+string(kf-1)+'].oparsz  = '+...
2571                'malloc(2*sizeof(int)*block_'+rdnom+'['+string(kf-1)+'].nopar))== NULL) return 0;';
2572               '    if ((block_'+rdnom+'['+string(kf-1)+'].opartyp = '+...
2573                'malloc(sizeof(int)*block_'+rdnom+'['+string(kf-1)+'].nopar))== NULL) return 0;';
2574               ]
2575         nopar = opptr(kf+1)-opptr(kf);
2576         //** oparptr **//
2577         for k=1:nopar
2578           Code=[Code;
2579                 '    block_'+rdnom+'['+string(kf-1)+'].oparptr['+string(k-1)+...
2580                  ']  = oparptr['+string(opptr(kf)-1+k-1)+'];'];
2581         end
2582         //** 1st dim **//
2583         for k=1:nopar
2584           Code=[Code;
2585                 '    block_'+rdnom+'['+string(kf-1)+'].oparsz['+string(k-1)+...
2586                  ']   = '+string(size(opar(opptr(kf)-1+k),1))+';'];
2587         end
2588         //** 2dn dim **//
2589         for k=1:nopar
2590           Code=[Code;
2591                 '    block_'+rdnom+'['+string(kf-1)+'].oparsz['+string(nopar+(k-1))+...
2592                  ']   = '+string(size(opar(opptr(kf)-1+k),2))+';'];
2593         end
2594         //** typ **//
2595         for k=1:nopar
2596           Code=[Code;
2597                 '    block_'+rdnom+'['+string(kf-1)+'].opartyp['+string(k-1)+...
2598                  ']  = '+mat2scs_c_typ(opar(opptr(kf)-1+k))+';'];
2599         end
2600       end
2601     end
2602
2603     Code=[Code;
2604           '    block_'+rdnom+'['+string(kf-1)+...
2605            '].work      = (void **)(((double *)work)+'+string(kf-1)+');'
2606           '    block_'+rdnom+'['+string(kf-1)+...
2607            '].nevprt    = nevprt;']
2608
2609   end //for kf=1:nblk
2610
2611   //** init
2612   for kf=1:nblk
2613 //     if or(kf==act) | or(kf==cap) then
2614 //       if stalone then
2615 //         txt = call_block42(kf,0,4);
2616 //         if txt <> [] then
2617 //           Code=[Code;
2618 //                 '';
2619 //                 '    '+txt];
2620 //         end
2621 //       end
2622 //     else
2623       txt = call_block42(kf,0,4);
2624       if txt <> [] then
2625         Code=[Code;
2626               '';
2627               '    '+txt];
2628       end
2629 //     end
2630   end
2631
2632   //** cst blocks and it's dep
2633   txt=write_code_idoit()
2634
2635   if txt<>[] then
2636     Code=[Code;
2637           ''
2638           '    /* initial blocks must be called with flag 1 */'
2639           txt];
2640   end
2641 //   for kf=iord(:,1)'
2642 // //     if or(kf==act) then
2643 // //       if stalone then
2644 // //         txt = call_block42(kf,0,1);
2645 // //         if txt <> [] then
2646 // //           Code=[Code;
2647 // //                 '';
2648 // //                 '    '+txt];
2649 // //         end
2650 // //       end
2651 // //     else
2652 //       txt = call_block42(kf,0,1);
2653 //       if txt <> [] then
2654 //         Code=[Code;
2655 //               '';
2656 //               '    '+txt];
2657 //       end
2658 // //     end
2659 //   end
2660
2661   Code=[Code;
2662         '  }'];
2663
2664   //** flag 5
2665   Code=[Code;
2666         '  else if (flag == 5) { '+get_comment('flag',list(5))
2667         '    block_'+rdnom+'=*block->work;']
2668
2669   for kf=1:nblk
2670      nin=inpptr(kf+1)-inpptr(kf);  //* number of input ports */
2671      nout=outptr(kf+1)-outptr(kf); //* number of output ports */
2672
2673      //** add comment
2674      txt=[get_comment('set_blk',list(funs(kf),funtyp(kf),kf));]
2675
2676      Code=[Code;
2677            ''
2678            '    '+txt];
2679
2680      for k=1:nin
2681         lprt=inplnk(inpptr(kf)-1+k);
2682          Code=[Code;
2683                '    block_'+rdnom+'['+string(kf-1)+'].inptr['+string(k-1)+...
2684                ']  = '+rdnom+'_block_outtbptr['+string(lprt-1)+'];']
2685      end
2686      for k=1:nout
2687         lprt=outlnk(outptr(kf)-1+k);
2688         Code=[Code
2689               '    block_'+rdnom+'['+string(kf-1)+'].outptr['+string(k-1)+...
2690               '] = '+rdnom+'_block_outtbptr['+string(lprt-1)+'];']
2691      end
2692      Code=[Code
2693            '    block_'+rdnom+'['+string(kf-1)+'].z=&(z['+...
2694             string(zptr(kf)-1)+']);']
2695      if (part(funs(kf),1:7) ~= 'capteur' &...
2696           part(funs(kf),1:10) ~= 'actionneur' &...
2697            funs(kf) ~= 'bidon' &...
2698             funs(kf) ~= 'bidon2') then
2699        //** rpar **//
2700        if (rpptr(kf+1)-rpptr(kf)>0) then
2701          Code=[Code;
2702                '    block_'+rdnom+'['+string(kf-1)+...
2703                 '].rpar=&(rpar['+string(rpptr(kf)-1)+']);']
2704        end
2705        //** ipar **//
2706        if (ipptr(kf+1)-ipptr(kf)>0) then
2707          Code=[Code;
2708                '    block_'+rdnom+'['+string(kf-1)+...
2709                 '].ipar=&(ipar['+string(ipptr(kf)-1)+']);']
2710        end
2711        //** opar **//
2712        if (opptr(kf+1)-opptr(kf)>0) then
2713          nopar = opptr(kf+1)-opptr(kf);
2714          for k=1:nopar
2715            Code=[Code;
2716                  '    block_'+rdnom+'['+string(kf-1)+'].oparptr['+string(k-1)+...
2717                  ']  = oparptr['+string(opptr(kf)-1+k-1)+'];'];
2718          end
2719        end
2720        //** oz **//
2721        if (ozptr(kf+1)-ozptr(kf)>0) then
2722          noz = ozptr(kf+1)-ozptr(kf);
2723          for k=1:noz
2724            Code=[Code;
2725                  '    block_'+rdnom+'['+string(kf-1)+'].ozptr['+string(k-1)+...
2726                 ']  = ozptr['+string(ozptr(kf)-1+k-1)+'];'];
2727          end
2728        end
2729      end
2730
2731      Code=[Code;
2732            '    block_'+rdnom+'['+string(kf-1)+...
2733             '].work=(void **)(((double *)work)+'+string(kf-1)+');']
2734   end
2735
2736   for kf=1:nblk
2737 //     if or(kf==act) | or(kf==cap) then
2738 //       if stalone then
2739 //         txt = call_block42(kf,0,5);
2740 //         if txt <> [] then
2741 //           Code=[Code;
2742 //                 '';
2743 //                 '    '+txt];
2744 //         end
2745 //       end
2746 //     else
2747       txt = call_block42(kf,0,5);
2748       if txt <> [] then
2749         Code=[Code;
2750               '';
2751               '    '+txt];
2752       end
2753 //     end
2754   end
2755
2756   Code=[Code;
2757         ''
2758         '    for (kf = 0; kf < '+string(nblk)+'; ++kf) {'
2759         '      if (block_'+rdnom+'[kf].insz!=NULL) {'
2760         '        free(block_'+rdnom+'[kf].insz);'
2761         '      }else {'
2762         '        break;'
2763         '      }'
2764         '      if (block_'+rdnom+'[kf].outsz!=NULL){'
2765         '        free(block_'+rdnom+'[kf].outsz);'
2766         '      }else {'
2767         '        break;'
2768         '      }'
2769         '      if (block_'+rdnom+'[kf].nopar!=0){'
2770         '        if (block_'+rdnom+'[kf].oparptr!=NULL){'
2771         '          free(block_'+rdnom+'[kf].oparptr);'
2772         '        }else {'
2773         '          break;'
2774         '        }'
2775         '        if (block_'+rdnom+'[kf].oparsz!=NULL){'
2776         '          free(block_'+rdnom+'[kf].oparsz);'
2777         '        }else {'
2778         '          break;'
2779         '        }'
2780         '        if (block_'+rdnom+'[kf].opartyp!=NULL){'
2781         '          free(block_'+rdnom+'[kf].opartyp);'
2782         '        }else {'
2783         '          break;'
2784         '        }'
2785         '      }'
2786         '      if (block_'+rdnom+'[kf].noz!=0){'
2787         '        if (block_'+rdnom+'[kf].ozptr!=NULL){'
2788         '          free(block_'+rdnom+'[kf].ozptr);'
2789         '        }else {'
2790         '          break;'
2791         '        }'
2792         '        if (block_'+rdnom+'[kf].ozsz!=NULL){'
2793         '          free(block_'+rdnom+'[kf].ozsz);'
2794         '        }else {'
2795         '          break;'
2796         '        }'
2797         '        if (block_'+rdnom+'[kf].oztyp!=NULL){'
2798         '          free(block_'+rdnom+'[kf].oztyp);'
2799         '        }else {'
2800         '          break;'
2801         '        }'
2802         '      }'
2803         '      if (block_'+rdnom+'[kf].evout!=NULL){'
2804         '        free(block_'+rdnom+'[kf].evout);'
2805         '      }else {'
2806         '        break;'
2807         '      }'
2808         '    }'
2809         '    scicos_free(block_'+rdnom+');'
2810         '  }'
2811         ''];
2812
2813   for i=1:size(actt,1)
2814     ni=actt(i,3)*actt(i,4); // dimension of ith input
2815     if actt(i,5)<>11 then
2816       Code=[Code;
2817             '  memcpy(*(y+'+string(actt(i,6)-1)+'),'+...
2818             '*('+rdnom+'_block_outtbptr+'+string(actt(i,2)-1)+'),'+...
2819              string(ni)+'*sizeof('+mat2c_typ(actt(i,5))+'));']
2820     else //** Cas cmplx
2821       Code=[Code;
2822             '  memcpy(*(y+'+string(actt(i,6)-1)+'),'+...
2823             '*('+rdnom+'_block_outtbptr+'+string(actt(i,2)-1)+'),'+...
2824              string(2*ni)+'*sizeof('+mat2c_typ(actt(i,5))+'));']
2825     end
2826   end
2827
2828   //**
2829   Code=[Code;
2830         '  return 0;'
2831         ''
2832         '} /* '+rdnom+' */']
2833
2834 endfunction
2835
2836 //generates skeleton of external world events handling function
2837 function Code=make_outevents()
2838   z='0'
2839   if szclkIN==[] then
2840     newszclkIN=0;
2841   else
2842     newszclkIN=szclkIN;
2843   end
2844
2845   Code=['/*'+part('-',ones(1,40))+'  External events handling function */';
2846          'void '+rdnom+'_events(int *nevprt,double *t)';
2847          '{'
2848          '/*  set next event time and associated events ports'
2849          ' *  nevprt has binary expression b1..b'+string(newszclkIN)+' where bi is a bit'
2850          ' *  bi is set to 1 if an activation is received by port i. Note that'
2851          ' *  more than one activation can be received simultaneously'
2852          ' *  Caution: at least one bi should be equal to one */'
2853          '']
2854
2855   if (newszclkIN <> 0) then
2856     Code=[Code;
2857           '    int i,p,b[]={'+strcat(z(ones(1,newszclkIN)),',')+'};'
2858           ''
2859           '/* this is an example for the activation of events ports */'
2860           '    b[0]=1;']
2861
2862     if newszclkIN>1 then
2863       for bb=2:newszclkIN
2864         Code($+1)='    b['+string(bb-1)+']=1;'
2865       end
2866     end
2867
2868     Code=[Code;
2869           ''
2870           '/* definition of the step time  */'
2871           '    *t = *t + 0.1;'
2872           ''
2873           '/* External events handling process */'
2874           '    *nevprt=0;p=1;'
2875           '    for (i=0;i<'+string(newszclkIN)+';i++) {'
2876           '      *nevprt=*nevprt+b[i]*p;'
2877           '      p=p*2;'
2878           '    }'
2879           '}']
2880   else
2881     Code=[Code;
2882           '';
2883           '/* definition of the step time  */'
2884           '    *t = *t + 0.1;'
2885           '}']
2886   end
2887 endfunction
2888
2889 //Generating the routine for sensors interfacing
2890 //
2891 //
2892 //Author : R. Djenidi, R. Nikoukhah, A. Layec
2893 //
2894 function Code=make_sensor(standalone)
2895   Call=['/*'+part('-',ones(1,40))+' Sensor */';
2896         'void '+rdnom+'_sensor(flag,nport,nevprt,t,y,ny1,ny2,yt,flag1)']
2897
2898   comments=['     /*'
2899             '      * To be customized for standalone execution';
2900             '      * flag  : specifies the action to be done'
2901             '      * nport : specifies the  index of the Super Bloc'
2902             '      *         regular input (The input ports are numbered'
2903             '      *         from the top to the bottom )'
2904             '      * nevprt: indicates if an activation had been received'
2905             '      *         0 = no activation'
2906             '      *         1 = activation'
2907             '      * t     : the current time value'
2908             '      * y     : the vector outputs value'
2909             '      * ny1   : the output size 1'
2910             '      * ny2   : the output size 2'
2911             '      * yt    : the output type'
2912             '      * flag1 : learn mode (0 from terminal,1 from input file'
2913             '      */']
2914
2915   dcl=['     int *flag,*nevprt,*nport;'
2916        '     int *ny1,*ny2,*yt,flag1;'
2917        ''
2918        '     double *t;'
2919        '     void *y;'
2920        '{'
2921        '  int j,k,l;'
2922        '  double temps;']
2923
2924   if standalone then
2925
2926     a_sensor=['    switch (*flag) {'
2927               '    case 1 : /* set the output value */'
2928               '      printf(""Require outputs of sensor number %d\n"", *nport);'
2929               '      printf(""time is: %f\n"", *t);'
2930               '      printf(""sizes of the sensor output is: %d,%d\n"", *ny1,*ny2);'
2931               '      switch (*yt) {'
2932               '      case 10 :'
2933               '        printf(""type of the sensor output is: %d (double) \n"", *yt);'
2934               '        puts(""Please set the sensor output values"");'
2935               '        for (l=0;l<*ny2;l++) {'
2936               '          for (k=0;k<*ny1;k++) {'
2937               '            printf(""y(%d,%d) : "",k,l);'
2938               '            scanf(""%lf"", (double *) y+(k+l*(*ny1)));'
2939               '          }'
2940               '        }'
2941               '        break;'
2942               ''
2943               '      case 11 :'
2944               '        printf(""type of the sensor output is: %d (complex) \n"", *yt);'
2945               '        puts(""Please set the sensor output values"");'
2946               '        for (l=0;l<*ny2;l++) {'
2947               '          for (k=0;k<*ny1;k++) {'
2948               '            printf(""y(%d,%d) real part : "",k,l);'
2949               '            scanf(""%lf"", (double *) y+(k+l*(*ny1)));'
2950               '            printf(""y(%d,%d) imag part : "",k,l);'
2951               '            scanf(""%lf"", (double *) y+((*ny1)*(*ny2)+k+l*(*ny1)));'
2952               '          }'
2953               '        }'
2954               '        break;'
2955               ''
2956               '      case 81 :'
2957               '        printf(""type of the sensor output is: %d (char) \n"", *yt);'
2958               '        puts(""Please set the sensor output values"");'
2959               '        for (l=0;l<*ny2;l++) {'
2960               '          for (k=0;k<*ny1;k++) {'
2961               '            printf(""y(%d,%d) : "",k,l);'
2962               '            scanf(""%i"", (char *) y+(k+l*(*ny1)));'
2963               '          }'
2964               '        }'
2965               '        break;'
2966               ''
2967               '      case 82 :'
2968               '        printf(""type of the sensor output is: %d (char) \n"", *yt);'
2969               '        puts(""Please set the sensor output values"");'
2970               '        for (l=0;l<*ny2;l++) {'
2971               '          for (k=0;k<*ny1;k++) {'
2972               '            printf(""y(%d,%d) : "",k,l);'
2973               '            scanf(""%hd"", (short *) y+(k+l*(*ny1)));'
2974               '          }'
2975               '        }'
2976               '        break;'
2977               ''
2978               '      case 84 :'
2979               '        printf(""type of the sensor output is: %d (long) \n"", *yt);'
2980               '        puts(""Please set the sensor output values"");'
2981               '        for (l=0;l<*ny2;l++) {'
2982               '          for (k=0;k<*ny1;k++) {'
2983               '            printf(""y(%d,%d) : "",k,l);'
2984               '            scanf(""%ld"", (long *) y+(k+l*(*ny1)));'
2985               '          }'
2986               '        }'
2987               '        break;'
2988               ''
2989               '      case 811 :'
2990               '        printf(""type of the sensor output is: %d (unsigned char) \n"", *yt);'
2991               '        puts(""Please set the sensor output values"");'
2992               '        for (l=0;l<*ny2;l++) {'
2993               '          for (k=0;k<*ny1;k++) {'
2994               '            printf(""y(%d,%d) : "",k,l);'
2995               '            scanf(""%d"", (unsigned char *) y+(k+l*(*ny1)));'
2996               '          }'
2997               '        }'
2998               '        break;'
2999               ''
3000               '      case 812 :'
3001               '        printf(""type of the sensor output is: %d (unsigned short) \n"", *yt);'
3002               '        puts(""Please set the sensor output values"");'
3003               '        for (l=0;l<*ny2;l++) {'
3004               '          for (k=0;k<*ny1;k++) {'
3005               '            printf(""y(%d,%d) : "",k,l);'
3006               '            scanf(""%hu"", (unsigned short *) y+(k+l*(*ny1)));'
3007               '          }'
3008               '        }'
3009               '        break;'
3010               ''
3011               '      case 814 :'
3012               '        printf(""type of the sensor output is: %d (unsigned long) \n"", *yt);'
3013               '        puts(""Please set the sensor output values"");'
3014               '        for (l=0;l<*ny2;l++) {'
3015               '          for (k=0;k<*ny1;k++) {'
3016               '            printf(""y(%d,%d) : "",k,l);'
3017               '            scanf(""%lu"", (unsigned long *) y+(k+l*(*ny1)));'
3018               '          }'
3019               '        }'
3020               '        break;'
3021               ''
3022               '      }'
3023               '      break;'
3024               '    case 4 : /* sensor initialisation */'
3025               '      /* do whatever you want to initialize the sensor */'
3026               '      break;'
3027               '    case 5 : /* sensor ending */'
3028               '      /* do whatever you want to end the sensor */'
3029               '      break;'
3030               '    }']
3031   else
3032     a_sensor=[]
3033   end
3034
3035   nc=size(cap,'*')
3036
3037   // pour fscanf
3038   typ=['""%lf ']; //temps
3039   for i=1:nc
3040     typ($)=typ($)+'"" \'
3041     typ=[typ;'""'];
3042     for j=1:sum(capt(i,3)*capt(i,4))
3043       //typ=typ+'%f ';
3044       typ($)=typ($)+scs_c_n2c_fmt(capt(i,5))+' ';
3045     end
3046   end
3047   typ($)=typ($)+'\n"", \'
3048   typ=strsubst(typ,'%f','%lf');
3049   typ(1)='    fscanf(fprr,'+typ(1);
3050   bl    ='                ';
3051   if size(typ,1) <> 1 then
3052     typ(2:$) = bl+typ(2:$);
3053   end
3054   //Code1=['      fscanf( fprr, '"'+typ+' \n'",&temps']
3055   Code1=[typ;bl+'&temps'];
3056   for i=1:size(capt,1)
3057     ni=capt(i,3)*capt(i,4); // dimension of ith input
3058     Code1($)=Code1($)+',';
3059     Code1=[Code1;bl];
3060     for j=1:ni
3061       if capt(i,5)<>11 then
3062         Code1($)=Code1($)+...
3063                   '('+scs_c_n2c_typ(capt(i,5))+' *)('+...
3064                    rdnom+'_block_outtbptr+'+string(capt(i,2)-1)+')'+...
3065                    '+'+string(j-1)+'';
3066       else //CAS CMPLX
3067         Code1($)=Code1($)+...
3068                   '('+scs_c_n2c_typ(capt(i,5))+' *)('+...
3069                    rdnom+'_block_outtbptr+'+string(capt(i,2)-1)+')'+...
3070                    '+'+string((j-1))+', '+...
3071                   '('+scs_c_n2c_typ(capt(i,5))+' *)('+...
3072                    rdnom+'_block_outtbptr+'+string(capt(i,2)-1)+')'+...
3073                    '+'+string(ni+(j-1))+'';
3074       end
3075       if j<>ni then
3076        Code1($)=Code1($)+', ';
3077       end
3078     end
3079   end
3080   Code1($)=Code1($)+');'
3081
3082   Code=[]
3083   if nc==1|~standalone then
3084     Code=[Code;
3085           Call
3086           comments
3087           dcl
3088           '  if (flag1 == 0) {'
3089           a_sensor;
3090           '  } '
3091           '  else if (flag1 == 1) {'
3092           '    if (*flag == 4 && *nport == 1) {'
3093           '      fprr=fopen(input,'"r'");'
3094           '      if( fprr == NULL ) {'
3095           '        printf('"Error opening file: %s\n'", input);'
3096           '        return;'
3097           '      }'
3098           '    }'
3099           '    else if (*flag == 1) {'
3100           Code1
3101           '    }'
3102           '    else if (*flag == 5 && *nport == 1) {'
3103           '      fclose(fprr);'
3104           '    }'
3105           '  }'
3106           '}'];
3107
3108   elseif nc>1 then
3109     S='  switch (*nport) {'
3110     for k=1:nc
3111       S=[S;
3112          '  case '+string(k)+' : /* Port number '+string(k)+' ----------*/'
3113          '  '+a_sensor
3114          '  break;']
3115     end
3116     S=[S;'  }']
3117
3118     Code=[Code
3119           Call
3120           comments
3121           dcl
3122           '  if (flag1 == 0) {'
3123           S
3124           '  }'
3125           '  else if (flag1 == 1){'
3126           '    if (*flag == 4 && *nport == 1) {'
3127           '      fprr=fopen(input,'"r'");'
3128           '      if( fprr == NULL ) {'
3129           '        printf('"Error opening file: %s\n'", input);'
3130           '        return ;'
3131           '      }'
3132           '    }'
3133           '    else if (*flag == 1) {'
3134           Code1
3135           '    }'
3136           '    else if (*flag == 5 && *nport == 1) {'
3137           '      fclose(fprr);'
3138           '    }'
3139           '  }'
3140           '}']
3141   end
3142 endfunction
3143
3144 //generates code of the standalone simulation procedure
3145 //
3146 //
3147 // rmq : La fonction zdoit n'est pas utilis?e pour le moment
3148 function Code=make_standalone42()
3149   x=cpr.state.x;
3150   modptr=cpr.sim.modptr;
3151   rpptr=cpr.sim.rpptr;
3152   ipptr=cpr.sim.ipptr;
3153   opptr=cpr.sim.opptr;
3154   rpar=cpr.sim.rpar;
3155   ipar=cpr.sim.ipar;
3156   opar=cpr.sim.opar;
3157   oz=cpr.state.oz;
3158   ordptr=cpr.sim.ordptr;
3159   oord=cpr.sim.oord;
3160   zord=cpr.sim.zord;
3161   iord=cpr.sim.iord;
3162   tevts=cpr.state.tevts;
3163   evtspt=cpr.state.evtspt;
3164   zptr=cpr.sim.zptr;
3165   clkptr=cpr.sim.clkptr;
3166   ordptr=cpr.sim.ordptr;
3167   pointi=cpr.state.pointi;
3168   funs=cpr.sim.funs;
3169   noord=size(cpr.sim.oord,1);
3170   nzord=size(cpr.sim.zord,1);
3171   niord=size(cpr.sim.iord,1);
3172
3173   Indent='  ';
3174   Indent2=Indent+Indent;
3175   BigIndent='          ';
3176
3177   work=zeros(nblk,1)
3178   Z=[z;zeros(lstsize(outtb),1);work]';
3179   nX=size(x,'*');
3180   nztotal=size(z,1);
3181
3182   stalone = %t;
3183
3184   Code=['/* Code prototype for standalone use  */'
3185         '/*     Generated by Code_Generation toolbox of Scicos with '+ ..
3186         getversion()+' */'
3187         '/*     date : '+date()+' */'
3188         ''
3189         '/* To learn how to use the standalone code, type '"./standalone -h'" */'
3190         ''
3191         '/* ---- Headers ---- */'
3192         '#include <stdio.h>'
3193         '#include <stdlib.h>'
3194         '#include <math.h>'
3195         '#include <string.h>'
3196         '#include <memory.h>'
3197         '#include '"scicos_block4.h'"'
3198         '#include '"machine.h'"'
3199         ''
3200         '/* ---- Internals functions declaration ---- */'
3201         'int '+rdnom+'_sim(double, double, double, int);'
3202         Protostalone
3203         '']
3204
3205   if getos() == 'Windows' then
3206    Code=[Code;
3207          ' '
3208          '#define max(a,b) ((a) >= (b) ? (a) : (b))'
3209          '#define min(a,b) ((a) <= (b) ? (a) : (b))'
3210          ' '
3211         ]
3212   end
3213
3214
3215   if x<>[] then
3216     Code=[Code
3217           '/* Code prototype for standalone use  */'
3218           'int C2F('+rdnom+'simblk)(double , double *, double *);'
3219           'extern  int C2F(dset)();'
3220           'int ode1();'
3221           'int ode2();'
3222           'int ode4();'
3223           '']
3224   end
3225
3226   Code=[Code;
3227         '/* Table of constant values */'
3228         'static int nrd_'+string(0:maxtotal)'+' = '+string(0:maxtotal)'+';']
3229
3230   if maxtotal<10 then
3231     Code=[Code;
3232           'static int nrd_10 = 10;']
3233   end
3234   if maxtotal<11 then
3235     Code=[Code;
3236           'static int nrd_11 = 11;']
3237   end
3238
3239   if maxtotal<81 then
3240     Code=[Code;
3241           'static int nrd_81 = 81;']
3242   end
3243   if maxtotal<82 then
3244     Code=[Code;
3245           'static int nrd_82 = 82;']
3246   end
3247   if maxtotal<84 then
3248     Code=[Code;
3249           'static int nrd_84 = 84;']
3250   end
3251   if maxtotal<811 then
3252     Code=[Code;
3253           'static int nrd_811 = 811;']
3254   end
3255   if maxtotal<812 then
3256     Code=[Code;
3257           'static int nrd_812 = 812;']
3258   end
3259   if maxtotal<814 then
3260     Code=[Code;
3261           'static int nrd_814 = 814;']
3262   end
3263
3264   Code=[Code;
3265         ''
3266         '/* Some general static variables */'
3267         'static double zero=0;'
3268         'static double w[1];'
3269         'static int aaa=0, bbb=0;'
3270         'void **'+rdnom+'_block_outtbptr;'] //** !!
3271
3272   Code=[Code;
3273         make_static_standalone42()]
3274
3275   Code=[Code;
3276         'static void usage();'
3277         ''
3278         '/* Main program */'
3279         'int main(int argc, char *argv[])'
3280         '{'
3281         '  double tf=30,dt=0.1,h=0.001;'
3282         '  int solver=3;'
3283         '  char * progname = argv[0];'
3284         '  int c;'
3285         '  strcpy(input,'"'");'
3286         '  strcpy(output,'"'");'
3287         '  while ((c = getopt(argc , argv, '"i:o:d:t:e:s:hv'")) != -1)'
3288         '    switch (c) {'
3289         '    case ''i'':'
3290         '      strcpy(input,argv[optind-1]);'
3291         '      break;'
3292         '    case ''o'':'
3293         '      strcpy(output,argv[optind-1]);'
3294         '      break;'
3295         '    case ''d'':'
3296         '      strcpy(s,argv[optind-1]);'
3297         '      dt=strtod(s,p);'
3298         '      break;'
3299         '    case ''t'':'
3300         '      strcpy(sf,argv[optind-1]);'
3301         '      tf=strtod(sf,p);'
3302         '      break;'
3303         '    case ''e'':'
3304         '      strcpy(se,argv[optind-1]);'
3305         '      h=strtod(se,p);'
3306         '      break;'
3307         '    case ''s'':'
3308         '      strcpy(ss,argv[optind-1]);'
3309         '      solver=(int) strtod(ss,p);'
3310         '      break;'
3311         '    case ''h'':'
3312         '      usage(progname);'
3313         '      printf(""Options : \n'");'
3314         '      printf(""     -h for the help  \n"");'
3315         '      printf(""     -v for printing the Scilab Version \n"");'
3316         '      printf(""     -i for input file name, by default is Terminal \n"");'
3317         '      printf(""     -o for output file name, by default is Terminal \n"");'
3318         '      printf(""     -d for the clock period, by default is 0.1 \n"");'
3319         '      printf(""     -t for the final time, by default is 30 \n"");'
3320         '      printf(""     -e for the solvers step size, by default is 0.001 \n"");'
3321         '      printf(""     -s integer parameter for select the numerical solver : \n"");'
3322         '      printf(""        1 for Euler''s method \n"");'
3323         '      printf(""        2 for Heun''s method \n"");'
3324         '      printf(""        3 (default value) for the Fourth-Order Runge-Kutta'+...
3325          ' (RK4) Formula \n"");'
3326         '      return 0;'
3327         '      break;'
3328         '    case ''v'':'
3329         '      printf(""Generated by Code_Generation toolbox of Scicos ""'
3330         '             ""with '+getversion()+' version \n"");'
3331         '      return 0;'
3332         '      break;'
3333         '    case ''?'':'
3334         '      errflg++;'
3335         '      break;'
3336         '    }'
3337         '    if (errflg){'
3338         '      usage(progname);'
3339         '      return 0;'
3340         '    }'
3341         ' '
3342         '  '+rdnom+'_sim(tf,dt,h,solver);'
3343         '  return 0;'
3344         '}'
3345         ''
3346         'static void usage(prog)'
3347         '       char *prog;'
3348         '{'
3349         '  fprintf(stderr, ""Usage: %s [-h] [-v] [-i arg] [-o arg] ""'
3350         '                  ""[-d arg] [-t arg] [-e arg] [-s arg]\n"", prog);'
3351         '}'
3352         '']
3353
3354   Code=[Code
3355         '/*'+part('-',ones(1,40))+'  External simulation function */'
3356         'int '+rdnom+'_sim(tf,dt,h,solver)'
3357         ''
3358         '   double tf,dt,h;'
3359         '   int solver;'
3360         '{'
3361         '  double t;'
3362         '  int nevprt=1;'
3363         '  int local_flag;'
3364         '  int nport;'
3365         '  int i;'
3366         '  double *args[100];'
3367         '']
3368
3369   if (x <> []) then
3370     Code=[Code
3371           '  double tout;'
3372           '  double he=0.1;'
3373           '']
3374   end
3375
3376   Code=[Code
3377         '  /* Initial values */'
3378         ''
3379         '  /* Note that z[]=[z_initial_condition;outtbptr;work]'
3380         cformatline('     z_initial_condition={'+...
3381           strcat(string(z),",")+'};',70)
3382         cformatline('     outtbptr={'+...
3383           strcat(string(zeros(lstsize(outtb),1)),"," )+'};',70)
3384         cformatline('     work= {'+...
3385           strcat(string(work),"," )+'};',70)
3386         '  */'
3387         ''
3388         cformatline('  double z[]={'+strcat(string(Z),',')+'};',70)]
3389
3390   if size(z,1) <> 0 then
3391     for i=1:(length(zptr)-1)
3392       if zptr(i+1)-zptr(i)>0 then
3393         if size(corinv(i),'*')==1 then
3394           OO=scs_m.objs(corinv(i))
3395         else
3396           path=list('objs')
3397           for l=cpr.corinv(i)(1:$-1)
3398             path($+1)=l;path($+1)='model'
3399             path($+1)='rpar'
3400             path($+1)='objs'
3401           end
3402           path($+1)=cpr.corinv(i)($)
3403           OO=scs_m(path)
3404         end
3405         aaa=OO.gui
3406         bbb=emptystr(3,1);
3407         if and(aaa+bbb~=['INPUTPORTEVTS';'OUTPUTPORTEVTS';'EVTGEN_f']) then
3408           Code($+1)='';
3409           Code($+1)='  /* Routine name of block: '+strcat(string(cpr.sim.funs(i)));
3410           Code($+1)='     Gui name of block: '+strcat(string(OO.gui));
3411           //Code($+1)='/* Name block: '+strcat(string(cpr.sim.funs(i)));
3412           //Code($+1)='Object number in diagram: '+strcat(string(cpr.corinv(i)));
3413           Code($+1)='     Compiled structure index: '+strcat(string(i));
3414           if stripblanks(OO.model.label)~=emptystr() then
3415             Code=[Code;
3416                   cformatline('     Label: '+strcat(string(OO.model.label)),70)]
3417           end
3418           if stripblanks(OO.graphics.exprs(1))~=emptystr() then
3419             Code=[Code;
3420                   cformatline('     Exprs: '+strcat(OO.graphics.exprs(1),","),70)]
3421           end
3422           if stripblanks(OO.graphics.id)~=emptystr() then
3423             Code=[Code;
3424                   cformatline('     Identification: '+..
3425                      strcat(string(OO.graphics.id)),70)]
3426           end
3427           Code=[Code;
3428                 cformatline('     z={'+...
3429                 strcat(string(z(zptr(i):zptr(i+1)-1)),",")+'};',70)]
3430           Code($+1)=' */';
3431         end
3432       end
3433     end
3434   end
3435
3436   //** declaration of oz
3437   Code_oz = [];
3438   for i=1:lstsize(oz)
3439     if mat2scs_c_nb(oz(i)) <> 11 then
3440       Code_oz=[Code_oz;
3441                cformatline('  '+mat2c_typ(oz(i))+...
3442                            ' oz_'+string(i)+'[]={'+...
3443                            strcat(string(oz(i)(:)),',')+'};',70)]
3444     else //** cmplx test
3445       Code_oz=[Code_oz;
3446                cformatline('  '+mat2c_typ(oz(i))+...
3447                            ' oz_'+string(i)+'[]={'+...
3448                            strcat(string([real(oz(i)(:));
3449                                           imag(oz(i)(:))]),',')+'};',70)]
3450     end
3451   end
3452
3453   if Code_oz <> [] then
3454     Code=[Code;
3455           '  /* oz declaration */'
3456           Code_oz]
3457   end
3458
3459   //** declaration of outtb
3460   Code_outtb = [];
3461   for i=1:lstsize(outtb)
3462     if mat2scs_c_nb(outtb(i)) <> 11 then
3463       Code_outtb=[Code_outtb;
3464                   cformatline('  '+mat2c_typ(outtb(i))+...
3465                               ' outtb_'+string(i)+'[]={'+...
3466                               strcat(string(outtb(i)(:)),',')+'};',70)]
3467     else //** cmplx test
3468       Code_outtb=[Code_outtb;
3469                   cformatline('  '+mat2c_typ(outtb(i))+...
3470                               ' outtb_'+string(i)+'[]={'+...
3471                               strcat(string([real(outtb(i)(:));
3472                                              imag(outtb(i)(:))]),',')+'};',70)]
3473     end
3474   end
3475
3476   if Code_outtb<>[] then
3477     Code=[Code
3478           ''
3479           '  /* outtb declaration */'
3480           Code_outtb
3481           '']
3482   end
3483
3484   Code_outtbptr=[];
3485   for i=1:lstsize(outtb)
3486     Code_outtbptr=[Code_outtbptr;
3487                    '  '+rdnom+'_block_outtbptr['+...
3488                     string(i-1)+'] = (void *) outtb_'+string(i)+';'];
3489   end
3490
3491   //** declaration of work
3492   Code=[Code
3493         '  /* work ptr declaration */'
3494         '  void **work;'
3495         '']
3496
3497   //## affectation of work
3498   Code=[Code
3499         '  /* Get work ptr of blocks */'
3500         '  work = (void **)(z+'+string(size(z,'*')+lstsize(outtb))+');'
3501         '']
3502
3503   //## affection of outtbptr
3504   if Code_outtb<>[] then
3505     Code=[Code
3506           '  /* Get outtbptr ptr of blocks */'
3507           '  '+rdnom+'_block_outtbptr = (void **)(z+'+string(nztotal)+');'
3508           '']
3509   end
3510   if Code_outtbptr<>[] then
3511     Code=[Code;
3512           Code_outtbptr
3513           '']
3514   end
3515
3516   for kf=1:nblk
3517     nx=xptr(kf+1)-xptr(kf);       //** number of continuous state
3518     nin=inpptr(kf+1)-inpptr(kf);  //** number of input ports
3519     nout=outptr(kf+1)-outptr(kf); //** number of output ports
3520
3521     //** add comment
3522     txt=[get_comment('set_blk',list(funs(kf),funtyp(kf),kf));]
3523
3524     Code=[Code;
3525           ''
3526           '  '+txt];
3527
3528     Code=[Code;
3529           '  block_'+rdnom+'['+string(kf-1)+'].type   = '+string(funtyp(kf))+';';
3530           '  block_'+rdnom+'['+string(kf-1)+'].ztyp   = '+string(ztyp(kf))+';';
3531           '  block_'+rdnom+'['+string(kf-1)+'].ng     = '+string(zcptr(kf+1)-zcptr(kf))+';';
3532           '  block_'+rdnom+'['+string(kf-1)+'].nz     = '+string(zptr(kf+1)-zptr(kf))+';';
3533           '  block_'+rdnom+'['+string(kf-1)+'].noz    = '+string(ozptr(kf+1)-ozptr(kf))+';';
3534           '  block_'+rdnom+'['+string(kf-1)+'].nrpar  = '+string(rpptr(kf+1)-rpptr(kf))+';';
3535           '  block_'+rdnom+'['+string(kf-1)+'].nopar  = '+string(opptr(kf+1)-opptr(kf))+';';
3536           '  block_'+rdnom+'['+string(kf-1)+'].nipar  = '+string(ipptr(kf+1)-ipptr(kf))+';'
3537           '  block_'+rdnom+'['+string(kf-1)+'].nin    = '+string(inpptr(kf+1)-inpptr(kf))+';';
3538           '  block_'+rdnom+'['+string(kf-1)+'].nout   = '+string(outptr(kf+1)-outptr(kf))+';';
3539           '  block_'+rdnom+'['+string(kf-1)+'].nevout = '+string(clkptr(kf+1)-clkptr(kf))+';';
3540           '  block_'+rdnom+'['+string(kf-1)+'].nmode  = '+string(modptr(kf+1)-modptr(kf))+';';]
3541
3542     if nx <> 0 then
3543       Code=[Code;
3544             '  block_'+rdnom+'['+string(kf-1)+'].nx = '+string(nx)+';';
3545             '  block_'+rdnom+'['+string(kf-1)+'].x  = &(x['+string(xptr(kf)-1)+']);'
3546             '  block_'+rdnom+'['+string(kf-1)+'].xd = &(xd['+string(xptr(kf)-1)+']);']
3547     end
3548
3549     Code=[Code;
3550           '  if ((block_'+rdnom+'['+string(kf-1)+'].evout  = '+...
3551           'calloc(block_'+rdnom+'['+string(kf-1)+'].nevout,sizeof(double)))== NULL) return 0;'];
3552
3553     //***************************** input port *****************************//
3554     //** alloc insz/inptr **//
3555     Code=[Code;
3556           '  if ((block_'+rdnom+'['+string(kf-1)+'].inptr  = '+...
3557           'malloc(sizeof(double*)*block_'+rdnom+'['+string(kf-1)+'].nin))== NULL) return 0;';
3558           '  if ((block_'+rdnom+'['+string(kf-1)+'].insz   = '+...
3559           'malloc(3*sizeof(int)*block_'+rdnom+'['+string(kf-1)+'].nin))== NULL) return 0;'];
3560
3561     //** inptr **//
3562     for k=1:nin
3563        lprt=inplnk(inpptr(kf)-1+k);
3564        Code=[Code
3565              '  block_'+rdnom+'['+string(kf-1)+'].inptr['+string(k-1)+...
3566              ']  = '+rdnom+'_block_outtbptr['+string(lprt-1)+'];']
3567     end
3568
3569     //** 1st dim **//
3570     for k=1:nin
3571        lprt=inplnk(inpptr(kf)-1+k);
3572        Code=[Code
3573              '  block_'+rdnom+'['+string(kf-1)+'].insz['+string((k-1))+...
3574              ']   = '+string(size(outtb(lprt),1))+';']
3575     end
3576
3577     //** 2dn dim **//
3578     for k=1:nin
3579        lprt=inplnk(inpptr(kf)-1+k);
3580        Code=[Code
3581              '  block_'+rdnom+'['+string(kf-1)+'].insz['+string((k-1)+nin)+...
3582              ']   = '+string(size(outtb(lprt),2))+';']
3583     end
3584
3585     //** typ **//
3586     for k=1:nin
3587        lprt=inplnk(inpptr(kf)-1+k);
3588        Code=[Code
3589              '  block_'+rdnom+'['+string(kf-1)+'].insz['+string((k-1)+2*nin)+...
3590              ']   = '+mat2scs_c_typ(outtb(lprt))+';'];
3591     end
3592     //**********************************************************************//
3593
3594     //***************************** output port *****************************//
3595     //** alloc outsz/outptr **//
3596     Code=[Code
3597           '  if ((block_'+rdnom+'['+string(kf-1)+'].outsz  = '+...
3598           'malloc(3*sizeof(int)*block_'+rdnom+'['+string(kf-1)+'].nout))== NULL) return 0;';
3599           '  if ((block_'+rdnom+'['+string(kf-1)+'].outptr = '+...
3600           'malloc(sizeof(double*)*block_'+rdnom+'['+string(kf-1)+'].nout))== NULL) return 0;'];
3601
3602     //** outptr **//
3603     for k=1:nout
3604        lprt=outlnk(outptr(kf)-1+k);
3605        Code=[Code
3606              '  block_'+rdnom+'['+string(kf-1)+'].outptr['+string(k-1)+...
3607              '] = '+rdnom+'_block_outtbptr['+string(lprt-1)+'];']
3608     end
3609
3610     //** 1st dim **//
3611     for k=1:nout
3612        lprt=outlnk(outptr(kf)-1+k);
3613        Code=[Code
3614              '  block_'+rdnom+'['+string(kf-1)+'].outsz['+string((k-1))+...
3615              ']  = '+string(size(outtb(lprt),1))+';']
3616     end
3617
3618     //** 2dn dim **//
3619     for k=1:nout
3620        lprt=outlnk(outptr(kf)-1+k);
3621        Code=[Code
3622              '  block_'+rdnom+'['+string(kf-1)+'].outsz['+string((k-1)+nout)+...
3623              ']  = '+string(size(outtb(lprt),2))+';']
3624     end
3625
3626     //** typ **//
3627     for k=1:nout
3628        lprt=outlnk(outptr(kf)-1+k);
3629        Code=[Code
3630              '  block_'+rdnom+'['+string(kf-1)+'].outsz['+string((k-1)+2*nout)+...
3631              ']  = '+mat2scs_c_typ(outtb(lprt))+';']
3632     end
3633     //**********************************************************************//
3634
3635     Code=[Code
3636           '  block_'+rdnom+'['+string(kf-1)+...
3637           '].z = &(z['+string(zptr(kf)-1)+']);']
3638
3639     if (part(funs(kf),1:7) ~= 'capteur' &...
3640         part(funs(kf),1:10) ~= 'actionneur' &...
3641         funs(kf) ~= 'bidon') then
3642       //** rpar **//
3643       if (rpptr(kf+1)-rpptr(kf)>0) then
3644         Code=[Code;
3645               '  block_'+rdnom+'['+string(kf-1)+...
3646               '].rpar=&(RPAR1['+string(rpptr(kf)-1)+']);']
3647       end
3648       //** ipar **//
3649       if (ipptr(kf+1)-ipptr(kf)>0) then
3650         Code=[Code;
3651               '  block_'+rdnom+'['+string(kf-1)+...
3652               '].ipar=&(IPAR1['+string(ipptr(kf)-1)+']);']
3653       end
3654       //** opar **//
3655       if (opptr(kf+1)-opptr(kf)>0) then
3656         Code=[Code;
3657               '  if ((block_'+rdnom+'['+string(kf-1)+'].oparptr = '+...
3658                'malloc(sizeof(void *)*block_'+rdnom+'['+string(kf-1)+'].nopar))== NULL ) return 0;';
3659               '  if ((block_'+rdnom+'['+string(kf-1)+'].oparsz  = '+...
3660                'malloc(2*sizeof(int)*block_'+rdnom+'['+string(kf-1)+'].nopar))== NULL ) return 0;';
3661               '  if ((block_'+rdnom+'['+string(kf-1)+'].opartyp = '+...
3662                'malloc(sizeof(int)*block_'+rdnom+'['+string(kf-1)+'].nopar))== NULL ) return 0;';
3663               ]
3664         nopar = opptr(kf+1)-opptr(kf);
3665         //** oparptr **//
3666         for k=1:nopar
3667           Code=[Code;
3668                 '  block_'+rdnom+'['+string(kf-1)+'].oparptr['+string(k-1)+...
3669                  ']   = (void *) OPAR_'+string(opptr(kf)-1+k)+';'];
3670         end
3671         //** 1st dim **//
3672         for k=1:nopar
3673           Code=[Code;
3674                 '  block_'+rdnom+'['+string(kf-1)+'].oparsz['+string(k-1)+...
3675                  ']    = '+string(size(opar(opptr(kf)-1+k),1))+';'];
3676         end
3677         //** 2dn dim **//
3678         for k=1:nopar
3679           Code=[Code;
3680                 '  block_'+rdnom+'['+string(kf-1)+'].oparsz['+string(nopar+(k-1))+...
3681                  ']    = '+string(size(opar(opptr(kf)-1+k),2))+';'];
3682         end
3683         //** typ **//
3684         for k=1:nopar
3685           Code=[Code;
3686                 '  block_'+rdnom+'['+string(kf-1)+'].opartyp['+string(k-1)+...
3687                 ']   = '+mat2scs_c_typ(opar(opptr(kf)-1+k))+';'];
3688         end
3689       end
3690       //** oz **//
3691       if (ozptr(kf+1)-ozptr(kf)>0) then
3692         noz = ozptr(kf+1)-ozptr(kf);
3693         Code=[Code
3694               '  if ((block_'+rdnom+'['+string(kf-1)+'].ozptr = '+...
3695                'malloc(sizeof(void *)*block_'+rdnom+'['+string(kf-1)+'].noz))== NULL) return 0;';
3696               '  if ((block_'+rdnom+'['+string(kf-1)+'].ozsz  = '+...
3697                'malloc(2*sizeof(int)*block_'+rdnom+'['+string(kf-1)+'].noz))== NULL) return 0;';
3698               '  if ((block_'+rdnom+'['+string(kf-1)+'].oztyp = '+...
3699                'malloc(sizeof(int)*block_'+rdnom+'['+string(kf-1)+'].noz))== NULL) return 0;';]
3700         //** ozptr **//
3701         for k=1:noz
3702           Code=[Code;
3703                 '  block_'+rdnom+'['+string(kf-1)+'].ozptr['+string(k-1)+...
3704                  ']  = (void *) oz_'+string(ozptr(kf)-1+k)+';'];
3705         end
3706         //** 1st dim **//
3707         for k=1:noz
3708           Code=[Code;
3709                 '  block_'+rdnom+'['+string(kf-1)+'].ozsz['+string(k-1)+...
3710                  ']  = '+string(size(oz(ozptr(kf)-1+k),1))+';'];
3711         end
3712         //** 2nd dim **//
3713         for k=1:noz
3714           Code=[Code;
3715                 '  block_'+rdnom+'['+string(kf-1)+'].ozsz['+string(noz+(k-1))+...
3716                  ']  = '+string(size(oz(ozptr(kf)-1+k),2))+';'];
3717         end
3718         //** typ **//
3719         for k=1:noz
3720           Code=[Code;
3721                 '  block_'+rdnom+'['+string(kf-1)+'].oztyp['+string(k-1)+...
3722                  ']  = '+mat2scs_c_typ(oz(ozptr(kf)-1+k))+';'];
3723         end
3724       end
3725     end
3726     Code=[Code;
3727           '  block_'+rdnom+'['+string(kf-1)+'].work = '+...
3728            '(void **)(((double *)work)+'+string(kf-1)+');']
3729   end
3730
3731   Code=[Code;
3732         '  if (strlen(input) > 0)'
3733         '    aaa=1;'
3734         '  if (strlen(output)> 0)'
3735         '    bbb=1;'
3736         '']
3737
3738   Code=[Code;
3739         '  /* set initial time */'
3740         '  t=0.0;'
3741         '']
3742
3743   //** init
3744   Code=[Code;
3745         '  '+get_comment('flag',list(4))]
3746
3747   for kf=1:nblk
3748     if or(kf==act) | or(kf==cap) then
3749         txt = call_block42(kf,0,4);
3750         if txt <> [] then
3751           Code=[Code;
3752                 '';
3753                 '  '+txt];
3754         end
3755     else
3756       txt = call_block42(kf,0,4);
3757       if txt <> [] then
3758         Code=[Code;
3759               '';
3760               '  '+txt];
3761       end
3762     end
3763   end
3764
3765   //** cst blocks and it's dep
3766   txt=write_code_idoit()
3767
3768   if txt<>[] then
3769     Code=[Code;
3770           ''
3771           '    /* Initial blocks must be called with flag 1 */'
3772           txt];
3773   end
3774
3775   //** begin input main loop on time
3776   Code=[Code;
3777         ''
3778         '  while (t<=tf) {';
3779         '    /* */'
3780         '    sci_time=t;'
3781         '']
3782
3783   //** find source activation number
3784   blks=find(funtyp>-1);
3785   evs=[];
3786
3787   for blk=blks
3788     for ev=clkptr(blk):clkptr(blk+1)-1
3789       if funs(blk)=='bidon' then
3790         if ev > clkptr(howclk) -1
3791          evs=[evs,ev];
3792         end
3793       end
3794     end
3795   end
3796
3797   //** flag 1,2,3
3798   for flag=[1,2,3]
3799
3800     txt3=[]
3801
3802     //** continuous time blocks must be activated
3803     //** for flag 1
3804     if flag==1 then
3805       txt = write_code_cdoit(flag);
3806
3807       if txt <> [] then
3808         txt3=[''
3809               '    '+get_comment('ev',list(0))
3810               txt;
3811              ];
3812       end
3813     end
3814
3815     //** blocks with input discrete event must be activated
3816     //** for flag 1, 2 and 3
3817     if size(evs,2)>=1 then
3818       txt4=[]
3819       //**
3820       for ev=evs
3821         txt2=write_code_doit(ev,flag);
3822         if txt2<>[] then
3823           //** adjust event number because of bidon block
3824           new_ev=ev-(clkptr(howclk)-1)
3825           //**
3826           txt4=[txt4;
3827                 Indent2+['  case '+string(new_ev)+' : '+...
3828                 get_comment('ev',list(new_ev))
3829                    txt2];
3830                 '      break;';'']
3831         end
3832       end
3833
3834       //**
3835       if txt4 <> [] then
3836         txt3=[txt3;
3837               Indent+'  /* Discrete activations */'
3838               Indent+'  switch (nevprt) {'
3839               txt4
3840               '    }'];
3841       end
3842     end
3843
3844     //**
3845     if txt3<>[] then
3846       Code=[Code;
3847             '    '+get_comment('flag',list(flag))
3848             txt3];
3849     end
3850   end
3851
3852   if x<>[] then
3853     Code=[Code
3854           ''
3855           '    tout=t;'
3856           ''
3857           '   /* integrate until the cumulative add of the integration'
3858           '    * time step doesn''t cross the sample time step'
3859           '    */'
3860           '    while (tout+h<t+dt){'
3861           '      switch (solver) {'
3862           '      case 1:'
3863           '        ode1(C2F('+rdnom+'simblk),tout,h);'
3864           '        break;'
3865           '      case 2:'
3866           '        ode2(C2F('+rdnom+'simblk),tout,h);'
3867           '        break;'
3868           '      case 3:'
3869           '        ode4(C2F('+rdnom+'simblk),tout,h);'
3870           '        break;'
3871           '      default :'
3872           '        ode4(C2F('+rdnom+'simblk),tout,h);'
3873           '        break;'
3874           '        }'
3875           '       tout=tout+h;'
3876           '    }'
3877           ''
3878           '    /* integration for the remainder piece of time */'
3879           '    he=t+dt-tout;'
3880           '    switch (solver) {'
3881           '    case 1:'
3882           '      ode1(C2F('+rdnom+'simblk),tout,he);'
3883           '      break;'
3884           '    case 2:'
3885           '      ode2(C2F('+rdnom+'simblk),tout,he);'
3886           '      break;'
3887           '    case 3:'
3888           '      ode4(C2F('+rdnom+'simblk),tout,he);'
3889           '      break;'
3890           '    default :'
3891           '      ode4(C2F('+rdnom+'simblk),tout,he);'
3892           '      break;'
3893           '    }']
3894   end
3895
3896   //** fix bug provided by Roberto Bucher
3897   //** Alan, 13/10/07
3898   if nX <> 0 then
3899     Code=[Code;
3900           ''
3901           '    /* update ptrs of continuous array */']
3902     for kf=1:nblk
3903       nx=xptr(kf+1)-xptr(kf);  //** number of continuous state
3904       if nx<>0 then
3905         Code=[Code;
3906               '    block_'+rdnom+'['+string(kf-1)+'].nx = '+...
3907                 string(nx)+';';
3908               '    block_'+rdnom+'['+string(kf-1)+'].x  = '+...
3909                '&(x['+string(xptr(kf)-1)+']);'
3910               '    block_'+rdnom+'['+string(kf-1)+'].xd = '+...
3911                '&(xd['+string(xptr(kf)-1)+']);']
3912       end
3913     end
3914   end
3915
3916   Code=[Code
3917         ''
3918         '    /* update current time */'
3919         '    t=t+dt;'
3920         '  }']
3921
3922   //** flag 5
3923   Code=[Code;
3924         ''
3925         '  '+get_comment('flag',list(5))]
3926
3927   for kf=1:nblk
3928     if or(kf==act) | or(kf==cap) then
3929         txt = call_block42(kf,0,5);
3930         if txt <> [] then
3931           Code=[Code;
3932                 '';
3933                 '  '+txt];
3934         end
3935     else
3936       txt = call_block42(kf,0,5);
3937       if txt <> [] then
3938         Code=[Code;
3939               '';
3940               '  '+txt];
3941       end
3942     end
3943   end
3944
3945   Code=[Code
3946         ''
3947         '  return 0;'
3948         '}'
3949         ''
3950         '/*'+part('-',ones(1,40))+'  Lapack messag function */';
3951         'void C2F(xerbla)(SRNAME,INFO,L)'
3952         '     char *SRNAME;'
3953         '     int *INFO;'
3954         '     long int L;'
3955         '{'
3956         '  printf(""** On entry to %s, parameter number %d""'
3957         '         ""  had an illegal value\n"",SRNAME,*INFO);'
3958         '}'
3959         '']
3960
3961   Code=[Code;
3962         'void set_block_error(int err)'
3963         '{'
3964         '  return;'
3965         '}'
3966         ''
3967         'int get_phase_simulation()'
3968         '{'
3969         '  return 1;'
3970         '}'
3971         ''
3972         'void * scicos_malloc(size_t size)'
3973         '{'
3974         '  return malloc(size);'
3975         '}'
3976         ''
3977         'void scicos_free(void *p)'
3978         '{'
3979         '  free(p);'
3980         '}'
3981         ''
3982         'double get_scicos_time()'
3983         '{'
3984           '  return sci_time;'
3985         '}'
3986         ''
3987         'void do_cold_restart()'
3988         '{'
3989         '  return;'
3990         '}'
3991         ''
3992         'void sciprint (char *fmt)'
3993         '{'
3994         '  return;'
3995         '}'
3996         ''
3997         'int getopt (int argc, char *argv[], char *optstring)'
3998         '{'
3999         '  char *group, option, *sopt;'
4000         '  int len;'
4001         '  option = -1;'
4002         '  optarg = NULL;'
4003         '  while ( optind < argc )'
4004         '    { '
4005         '      group = argv[optind];'
4006         '      if ( *group != ''-'' )'
4007         '        {'
4008         '         option = -1;'
4009         '         optarg = group;'
4010         '         optind++;'
4011         '         break;'
4012         '        }'
4013         '      len = strlen (group);'
4014         '      group = group + offset;'
4015         '      if ( *group == ''-'' )'
4016         '        {'
4017         '         group++;'
4018         '         offset += 2;'
4019         '        }'
4020         '      else'
4021         '        offset++ ;'
4022         '      option = *group ;'
4023         '      sopt = strchr ( optstring, option ) ;'
4024         '      if ( sopt != NULL )'
4025         '        {'
4026         '         sopt++ ;'
4027         '         if ( *sopt == '':'' )'
4028         '           {'
4029         '             optarg = group + 1;'
4030         '             if ( *optarg == ''\0'' )'
4031         '                optarg = argv[++optind];'
4032         '             if ( *optarg == ''-'' )'
4033         '                {'
4034         '                 fprintf ( stderr, '"\n%s: illegal option -- %c'",'
4035         '                           argv[0], option );'
4036         '                 option = ''?'';'
4037         '                 break;'
4038         '                }'
4039         '             else'
4040         '                {'
4041         '                 optind++;'
4042         '                 offset = 0;'
4043         '                 break;'
4044         '                }'
4045         '           }'
4046         '         if ( offset >= len )'
4047         '           {'
4048         '             optind++;'
4049         '             offset = 0;'
4050         '           }'
4051         '         break;'
4052         '        }'
4053         '      else'
4054         '        {'
4055         '         fprintf ( stderr, '"\n%s: illegal option -- %c'", argv[0], option );'
4056         '         option = ''?'';'
4057         '         break;'
4058         '        }'
4059         '    }'
4060         '  return ( option );'
4061         '}'
4062         '']
4063
4064   if (x <> []) then
4065     Code=[Code;
4066           'int C2F('+rdnom+'simblk)(t, x, xd)'
4067           ''
4068           '   double t, *x, *xd;'
4069           ''
4070           '     /*'
4071           '      *  !purpose'
4072           '      *  compute state derivative of the continuous part'
4073           '      *  !calling sequence'
4074           '      *  neq   : integer the size of the  continuous state'
4075           '      *  t     : current time'
4076           '      *  x     : double precision vector whose contains the continuous state'
4077           '      *  xd    : double precision vector, contain the computed derivative'
4078           '      *  of the state'
4079           '      */'
4080           '{'
4081           '  int phase=2;'
4082           '  int local_flag;'
4083           '  int nport;'
4084           '  int nevprt=1;'
4085           '  double *args[100];'
4086           '  C2F(dset)(&neq, &c_b14,xd , &c__1);'
4087           '']
4088
4089     Code=[Code;
4090           '    '+get_comment('update_xd',list())]
4091
4092     for kf=1:nblk
4093       if (xptr(kf+1)-xptr(kf)) > 0 then
4094         Code=[Code;
4095               '    block_'+rdnom+'['+string(kf-1)+'].x='+...
4096                 '&(x['+string(xptr(kf)-1)+']);'
4097               '    block_'+rdnom+'['+string(kf-1)+'].xd='+...
4098                 '&(xd['+string(xptr(kf)-1)+']);']
4099       end
4100     end
4101
4102     Code=[Code;
4103           ''
4104           write_code_odoit(1)
4105           write_code_odoit(0)
4106          ]
4107
4108     Code=[Code
4109           ''
4110           '  return 0;'
4111           '}'
4112           ''
4113           '/* Euler''s Method */'
4114           'int ode1(f,t,h)'
4115           '  int (*f) ();'
4116           '  double t, h;'
4117           '{'
4118           '  int i;'
4119           ''
4120           '  /**/'
4121           '  (*f)(t,x, xd);'
4122           ''
4123           '  for (i=0;i<neq;i++) {'
4124           '   x[i]=x[i]+h*xd[i];'
4125           '  }'
4126           ''
4127           '  return 0;'
4128           '}'
4129           ''
4130           '/* Heun''s Method */'
4131           'int ode2(f,t,h)'
4132           '  int (*f) ();'
4133           '  double t, h;'
4134           '{'
4135           '  int i;'
4136           '  double y['+string(nX)+'],yh['+string(nX)+'],temp,f0['+string(nX)+'],th;'
4137           ''
4138           '  /**/'
4139           '  memcpy(y,x,neq*sizeof(double));'
4140           '  memcpy(f0,xd,neq*sizeof(double));'
4141           ''
4142           '  /**/'
4143           '  (*f)(t,y, f0);'
4144           ''
4145           '  /**/'
4146           '  for (i=0;i<neq;i++) {'
4147           '    x[i]=y[i]+h*f0[i];'
4148           '  }'
4149           '  th=t+h;'
4150           '  for (i=0;i<neq;i++) {'
4151           '    yh[i]=y[i]+h*f0[i];'
4152           '  }'
4153           '  (*f)(th,yh, xd);'
4154           ''
4155           '  /**/'
4156           '  temp=0.5*h;'
4157           '  for (i=0;i<neq;i++) {'
4158           '    x[i]=y[i]+temp*(f0[i]+xd[i]);'
4159           '  }'
4160           ''
4161           '  return 0;'
4162           '}'
4163           ''
4164           '/* Fourth-Order Runge-Kutta (RK4) Formula */'
4165           'int ode4(f,t,h)'
4166           '  int (*f) ();'
4167           '  double t, h;'
4168           '{'
4169           '  int i;'
4170           '  double y['+string(nX)+'],yh['+string(nX)+'],'+...
4171             'temp,f0['+string(nX)+'],th,th2,'+...
4172             'f1['+string(nX)+'],f2['+string(nX)+'];'
4173           ''
4174           '  /**/'
4175           '  memcpy(y,x,neq*sizeof(double));'
4176           '  memcpy(f0,xd,neq*sizeof(double));'
4177           ''
4178           '  /**/'
4179           '  (*f)(t,y, f0);'
4180           ''
4181           '  /**/'
4182           '  for (i=0;i<neq;i++) {'
4183           '    x[i]=y[i]+h*f0[i];'
4184           '  }'
4185           '  th2=t+h/2;'
4186           '  for (i=0;i<neq;i++) {'
4187           '    yh[i]=y[i]+(h/2)*f0[i];'
4188           '  }'
4189           '  (*f)(th2,yh, f1);'
4190           ''
4191           '  /**/'
4192           '  temp=0.5*h;'
4193           '  for (i=0;i<neq;i++) {'
4194           '    x[i]=y[i]+temp*f1[i];'
4195           '  }'
4196           '  for (i=0;i<neq;i++) {'
4197           '    yh[i]=y[i]+(h/2)*f1[i];'
4198           '  }'
4199           '  (*f)(th2,yh, f2);'
4200           ''
4201           '  /**/'
4202           '  for (i=0;i<neq;i++) {'
4203           '    x[i]=y[i]+h*f2[i];'
4204           '  }'
4205           '  th=t+h;'
4206           '  for (i=0;i<neq;i++) {'
4207           '    yh[i]=y[i]+h*f2[i];'
4208           '  }'
4209           '  (*f)(th2,yh, xd);'
4210           ''
4211           '  /**/'
4212           '  temp=h/6;'
4213           '  for (i=0;i<neq;i++) {'
4214           '    x[i]=y[i]+temp*(f0[i]+2.0*f1[i]+2.0*f2[i]+xd[i]);'
4215           '  }'
4216           ''
4217           'return 0;'
4218           '}']
4219   end
4220 endfunction
4221
4222 //generates  static table definitions
4223 //
4224 //Author : Rachid Djenidi, Alan Layec
4225 function txt=make_static_standalone42()
4226   txt=[];
4227
4228   //*** Continuous state ***//
4229   if x <> [] then
4230    txt=[txt;
4231         '/* def continuous state */'
4232         cformatline('double x[]={'+strcat(string(x),',')+'};',70)
4233         cformatline('double xd[]={'+strcat(string(x),',')+'};',70)
4234         'static int c__1 = 1;'
4235         'static double c_b14 = 0.;'
4236         'static int neq='+string(nX)+';'
4237         '']
4238   end
4239   //************************//
4240
4241   txt=[txt;
4242        'char input[50], output[50],s[1],sf[1],se[1],ss[1],**p;'
4243        'static double sci_time;'
4244        'static int errflg = 0;'
4245        'static char *optarg = NULL ;'
4246        'static int optind = 1, offset = 0 ;'
4247        'scicos_block block_'+rdnom+'['+string(nblk)+'];'
4248        ''];
4249
4250   //*** Real parameters ***//
4251   if size(rpar,1) <> 0 then
4252     txt=[txt;
4253          '/* def real parameters */'
4254          'static double RPAR1[ ] = {'];
4255
4256     for i=1:(length(rpptr)-1)
4257       if rpptr(i+1)-rpptr(i)>0  then
4258
4259         if size(corinv(i),'*')==1 then
4260           OO=scs_m.objs(corinv(i));
4261         else
4262           path=list('objs');
4263           for l=cpr.corinv(i)(1:$-1)
4264             path($+1)=l;
4265             path($+1)='model';
4266             path($+1)='rpar';
4267             path($+1)='objs';
4268           end
4269           path($+1)=cpr.corinv(i)($);
4270           OO=scs_m(path);
4271         end
4272
4273         //** Add comments **//
4274         txt($+1)='/* Routine name of block: '+strcat(string(cpr.sim.funs(i)));
4275         txt($+1)=' * Gui name of block: '+strcat(string(OO.gui));
4276         txt($+1)=' * Compiled structure index: '+strcat(string(i));
4277
4278         if stripblanks(OO.model.label)~=emptystr() then
4279           txt=[txt;cformatline(' * Label: '+strcat(string(OO.model.label)),70)];
4280         end
4281         if stripblanks(OO.graphics.exprs(1))~=emptystr() then
4282           txt=[txt;cformatline(' * Exprs: '+strcat(OO.graphics.exprs(1),","),70)];
4283         end
4284         if stripblanks(OO.graphics.id)~=emptystr() then
4285           txt=[txt;
4286                cformatline(' * Identification: '+strcat(string(OO.graphics.id)),70)];
4287         end
4288         txt=[txt;' * rpar='];
4289         txt($+1)=' */';
4290         //******************//
4291
4292         txt=[txt;
4293              cformatline(strcat(msprintf('%.16g,\n',rpar(rpptr(i):rpptr(i+1)-1))),70);
4294              '']
4295
4296       end
4297     end
4298     txt=[txt;
4299          '};'
4300          '']
4301
4302   else
4303     txt($+1)='static double RPAR1[1];';
4304   end
4305   //***********************//
4306
4307   //*** Integer parameters ***//
4308   if size(ipar,1) <> 0 then
4309     txt=[txt;
4310          '/* def integer parameters */'
4311          'static int IPAR1[ ] = {'];
4312
4313     for i=1:(length(ipptr)-1)
4314       if ipptr(i+1)-ipptr(i)>0  then
4315         if size(corinv(i),'*')==1 then
4316           OO=scs_m.objs(corinv(i));
4317         else
4318           path=list('objs');
4319           for l=cpr.corinv(i)(1:$-1)
4320             path($+1)=l
4321             path($+1)='model'
4322             path($+1)='rpar'
4323             path($+1)='objs'
4324           end
4325           path($+1)=cpr.corinv(i)($);
4326           OO=scs_m(path);
4327         end
4328
4329         //** Add comments **//
4330         txt($+1)='/* Routine name of block: '+strcat(string(cpr.sim.funs(i)));
4331         txt($+1)=' * Gui name of block: '+strcat(string(OO.gui));
4332         txt($+1)=' * Compiled structure index: '+strcat(string(i));
4333         if stripblanks(OO.model.label)~=emptystr() then
4334           txt=[txt;cformatline(' * Label: '+strcat(string(OO.model.label)),70)];
4335         end
4336
4337         if stripblanks(OO.graphics.exprs(1))~=emptystr() then
4338           txt=[txt;
4339                cformatline(' * Exprs: '+strcat(OO.graphics.exprs(1),","),70)];
4340         end
4341         if stripblanks(OO.graphics.id)~=emptystr() then
4342           txt=[txt;
4343                cformatline(' * Identification: '+strcat(string(OO.graphics.id)),70)];
4344         end
4345         txt=[txt;
4346              cformatline(' * ipar= {'+strcat(string(ipar(ipptr(i):ipptr(i+1)-1)),",")+'};',70)];
4347         txt($+1)=' */';
4348         //******************//
4349
4350         txt=[txt;cformatline(strcat(string(ipar(ipptr(i):ipptr(i+1)-1))+','),70)];
4351         txt($+1)='';
4352       end
4353     end
4354     txt=[txt;
4355          '};'
4356          '']
4357   else
4358     txt($+1)='static int IPAR1[1];';
4359   end
4360   //**************************//
4361
4362   //Alan added opar (27/06/07)
4363   //*** Object parameters ***//
4364   if lstsize(opar)<>0 then
4365     txt=[txt;
4366           '/* def object parameters */']
4367     for i=1:(length(opptr)-1)
4368       if opptr(i+1)-opptr(i)>0  then
4369
4370         if size(corinv(i),'*')==1 then
4371           OO=scs_m.objs(corinv(i));
4372         else
4373           path=list('objs');
4374           for l=cpr.corinv(i)(1:$-1)
4375             path($+1)=l;
4376             path($+1)='model';
4377             path($+1)='rpar';
4378             path($+1)='objs';
4379           end
4380           path($+1)=cpr.corinv(i)($);
4381           OO=scs_m(path);
4382         end
4383
4384         //** Add comments **//
4385         txt($+1)='';
4386         txt($+1)='/* Routine name of block: '+strcat(string(cpr.sim.funs(i)));
4387         txt($+1)=' * Gui name of block: '+strcat(string(OO.gui));
4388         txt($+1)=' * Compiled structure index: '+strcat(string(i));
4389         if stripblanks(OO.model.label)~=emptystr() then
4390           txt=[txt;cformatline(' * Label: '+strcat(string(OO.model.label)),70)];
4391         end
4392         if stripblanks(OO.graphics.id)~=emptystr() then
4393           txt=[txt;
4394                cformatline(' * Identification: '+strcat(string(OO.graphics.id)),70)];
4395         end
4396         txt($+1)=' */';
4397         //******************//
4398
4399         for j=1:opptr(i+1)-opptr(i)
4400           txt =[txt;
4401                 cformatline('static '+mat2c_typ(opar(opptr(i)+j-1)) +...
4402                             ' OPAR_'+string(opptr(i)+j-1) + '[] = {'+...
4403                             strcat(string(opar(opptr(i)+j-1)),',')+'};',70)]
4404         end
4405       end
4406     end
4407   end
4408   //*************************//
4409
4410   txt=[txt;
4411        '']
4412 endfunction
4413
4414 //utilitary fonction used to format long C instruction
4415 //t : a string containing a C instruction
4416 //l : max line length allowed
4417
4418 //Author : Rachid Djenidi
4419 function t1=cformatline(t ,l)
4420
4421   sep=[',','+']
4422   l1=l-2
4423   t1=[]
4424   kw=strindex(t,' ')
4425   nw=0
4426   if kw<>[] then
4427     if kw(1)==1 then // there is leading blanks
4428       k1=find(kw(2:$)-kw(1:$-1)<>1)
4429       if k1==[] then // there is a single blank
4430     nw=1
4431       else
4432     nw=kw(k1(1))
4433       end
4434     end
4435   end
4436   t=part(t,nw+1:length(t));
4437   bl=part(' ',ones(1,nw))
4438   l1=l-nw;first=%t
4439   while %t
4440     if length(t)<=l then t1=[t1;bl+t],return,end
4441     k=strindex(t,sep);
4442     if k==[] then t1=[t1;bl+t],return,end
4443     k($+1)=length(t)+1 // positions of the commas
4444     i=find(k(1:$-1)<=l&k(2:$)>l) //nearest left comma (reltively to l)
4445     if i==[] then i=1,end
4446     t1=[t1;bl+part(t,1:k(i))]
4447     t=part(t,k(i)+1:length(t))
4448     if first then l1=l1-2;bl=bl+'  ';first=%f;end
4449   end
4450 endfunction
4451
4452 //used in do_compile_superblock
4453 function vec=codebinaire(v,szclkIN)
4454   vec=zeros(1,szclkIN)
4455   for i=1:szclkIN
4456     w=v/2;
4457     vec(i)=v-2*int(w);
4458     v=int(w);
4459   end
4460 endfunction
4461
4462 function t=filetype(m)
4463   m=int32(m)
4464   filetypes=['Directory','Character device','Block device',...
4465              'Regular file','FIFO','Symbolic link','Socket']
4466   bits=[16384,8192,24576,32768,4096,40960,49152]
4467   m=int32(m)&int32(61440)
4468   t=filetypes(find(m==int32(bits)))
4469 endfunction
4470
4471 //get_blank : return blanks with a length
4472 //            of the given input string
4473 //
4474 //input : str : a string
4475 //
4476 //output : txt : blanks
4477 //
4478 //16/06/07 Author : A.Layec
4479 function [txt] = get_blank(str)
4480  txt='';
4481  for i=1:length(str)
4482      txt=txt+' ';
4483  end
4484 endfunction
4485
4486 // get_comment : return a C comment
4487 //               for generated code
4488 //
4489 //input : typ : a string
4490 //        param : a list
4491 //
4492 //output : a C comment
4493 //
4494 //16/06/07 Author : A.Layec
4495 function [txt]=get_comment(typ,param)
4496   txt = [];
4497   select typ
4498     //** main flag
4499     case 'flag' then
4500         select param(1)
4501           case 0 then
4502              txt = '/* Continuous state computation */'
4503           case 1 then
4504              txt = '/* Output computation */'
4505           case 2 then
4506              txt = '/* Discrete state computation */'
4507           case 3 then
4508              txt = '/* Output Event computation */'
4509           case 4 then
4510              txt = '/* Initialization */'
4511           case 5 then
4512              txt = '/* Ending */'
4513           case 9 then
4514              txt = '/* Update zero crossing surfaces */'
4515         end
4516     //** blocks activated on event number
4517     case 'ev' then
4518        txt = '/* Blocks activated on the event number '+string(param(1))+' */'
4519
4520     //** blk calling sequence
4521     case 'call_blk' then
4522         txt = ['/* Call of '''+param(1) + ...
4523                ''' (type '+string(param(2))+' - blk nb '+...
4524                     string(param(3))];
4525         if ztyp(param(3)) then
4526           txt=txt+' - with zcross) */';
4527         else
4528           txt=txt+') */';
4529         end
4530     //** proto calling sequence
4531     case 'proto_blk' then
4532         txt = ['/* prototype of '''+param(1) + ...
4533                ''' (type '+string(param(2))];
4534         if ztyp(param(3)) then
4535           txt=txt+' - with zcross) */';
4536         else
4537           txt=txt+') */';
4538         end
4539     //** ifthenelse calling sequence
4540     case 'ifthenelse_blk' then
4541         txt = ['/* Call of ''if-then-else'' blk (blk nb '+...
4542                     string(param(1))+') */']
4543     //** eventselect calling sequence
4544     case 'evtselect_blk' then
4545         txt = ['/* Call of ''event-select'' blk (blk nb '+...
4546                     string(param(1))+') */']
4547     //** set block structure
4548     case 'set_blk' then
4549         txt = ['/* set blk struc. of '''+param(1) + ...
4550                ''' (type '+string(param(2))+' - blk nb '+...
4551                     string(param(3))+') */'];
4552     //** Update xd vector ptr
4553     case 'update_xd' then
4554         txt = ['/* Update xd vector ptr */'];
4555     //** Update g vector ptr
4556     case 'update_g' then
4557         txt = ['/* Update g vector ptr */'];
4558     else
4559       break;
4560   end
4561 endfunction
4562
4563 //mat2c_typ : matrix to C type
4564 //sci2c_ttyp : get the C string of a scicos type
4565 //
4566 //input : outtb : a matrix
4567 //
4568 //output : txt : the string of the C scicos type
4569 //               of the data of outtb
4570 //
4571 //16/06/07 Author : A.Layec
4572 function [txt]=mat2c_typ(outtb)
4573  select type(outtb)
4574    //real matrix
4575    case 1 then
4576       if isreal(outtb) then
4577         txt = "double"
4578       else
4579         txt = "double"
4580       end
4581    //integer matrix
4582    case 8 then
4583       select typeof(outtb)
4584          case 'int32' then
4585            txt = "long"
4586          case 'int16' then
4587            txt = "short"
4588          case 'int8' then
4589            txt = "char"
4590          case 'uint32' then
4591            txt = "unsigned long"
4592          case 'uint16' then
4593            txt = "unsigned short"
4594          case 'uint8' then
4595            txt = "unsigned char"
4596       end
4597    else
4598      break;
4599  end
4600 endfunction
4601
4602 //mat2scs_c_nb  matrix to scicos C number (sci2sci_n)
4603 //
4604 //input : outtb : a matrix
4605 //
4606 //output : c_nb : the scicos C number
4607 //
4608 //16/06/07 Author : A.Layec
4609 function [c_nb]=mat2scs_c_nb(outtb)
4610  select type(outtb)
4611    //real matrix
4612    case 1 then
4613       if isreal(outtb) then
4614         c_nb = 10
4615       else
4616         c_nb = 11
4617       end
4618    //integer matrix
4619    case 8 then
4620       select typeof(outtb)
4621          case 'int32' then
4622            c_nb = 84
4623          case 'int16' then
4624            c_nb = 82
4625          case 'int8' then
4626            c_nb = 81
4627          case 'uint32' then
4628            c_nb = 814
4629          case 'uint16' then
4630            c_nb = 812
4631          case 'uint8' then
4632            c_nb = 811
4633       end
4634    else
4635      break;
4636  end
4637 endfunction
4638
4639 //mat2scs_c_ptr matrix to scicos C ptr (sci2c_typ)
4640 //
4641 //input : outtb : a matrix
4642 //
4643 //output : txt : the string of the C scicos type
4644 //               of the data of outtb
4645 //
4646 //16/06/07 Author : A.Layec
4647 function [txt]=mat2scs_c_ptr(outtb)
4648  select type(outtb)
4649    //real matrix
4650    case 1 then
4651       if isreal(outtb) then
4652         txt = "SCSREAL_COP"
4653       else
4654         txt = "SCSCOMPLEX_COP"
4655       end
4656    //integer matrix
4657    case 8 then
4658       select typeof(outtb)
4659          case 'int32' then
4660            txt = "SCSINT32_COP"
4661          case 'int16' then
4662            txt = "SCSINT16_COP"
4663          case 'int8' then
4664            txt = "SCSINT8_COP"
4665          case 'uint32' then
4666            txt = "SCSUINT32_COP"
4667          case 'uint16' then
4668            txt = "SCSUINT16_COP"
4669          case 'uint8' then
4670            txt = "SCSUINT8_COP"
4671       end
4672    else
4673      break;
4674  end
4675 endfunction
4676
4677 //mat2scs_c_typ matrix to scicos C type
4678 //
4679 //input : outtb : a matrix
4680 //
4681 //output : txt : the string of the C scicos type
4682 //               of the data of outtb
4683 //
4684 //16/06/07 Author : A.Layec
4685 function [txt]=mat2scs_c_typ(outtb)
4686  select type(outtb)
4687    //real matrix
4688    case 1 then
4689       if isreal(outtb) then
4690         txt = "SCSREAL_N"
4691       else
4692         txt = "SCSCOMPLEX_N"
4693       end
4694    //integer matrix
4695    case 8 then
4696       select typeof(outtb)
4697          case 'int32' then
4698            txt = "SCSINT32_N"
4699          case 'int16' then
4700            txt = "SCSINT16_N"
4701          case 'int8' then
4702            txt = "SCSINT8_N"
4703          case 'uint32' then
4704            txt = "SCSUINT32_N"
4705          case 'uint16' then
4706            txt = "SCSUINT16_N"
4707          case 'uint8' then
4708            txt = "SCSUINT8_N"
4709       end
4710    else
4711      break;
4712  end
4713 endfunction
4714
4715 //scs_c_n2c_fmt : scicos C number to C format
4716 //
4717 //input : c_nb : a C scicos type
4718 //
4719 //output : txt : the string of the C format string
4720 //               of the data of outtb
4721 //
4722 //16/06/07 Author : A.Layec
4723 function [txt]=scs_c_n2c_fmt(c_nb)
4724  select c_nb
4725    //real matrix
4726    case 10 then
4727      txt = '%f';
4728    //complex matrix
4729    case 11 then
4730      txt = '%f,%f';
4731    //int8 matrix
4732    case 81 then
4733      txt = '%d';
4734    //int16 matrix
4735    case 82 then
4736      txt = '%d';
4737    //int32 matrix
4738    case 84 then
4739      txt = '%d';
4740    //uint8 matrix
4741    case 811 then
4742      txt = '%d';
4743    //uint16 matrix
4744    case 812 then
4745      txt = '%d';
4746    //uint32 matrix
4747    case 814 then
4748      txt = '%d';
4749    else
4750      txt='%f'
4751      break;
4752  end
4753 endfunction
4754
4755 //scs_c_n2c_typ scicos C number to C type
4756 //
4757 //input : c_nb : a C scicos number
4758 //
4759 //output : txt : the string of the C format string
4760 //               of the data of outtb
4761 //
4762 //16/06/07 Author : A.Layec
4763 function [txt]=scs_c_n2c_typ(c_nb)
4764  select c_nb
4765    //real matrix
4766    case 10 then
4767      txt = 'double';
4768    //complex matrix
4769    case 11 then
4770      txt = 'double';
4771    //int8 matrix
4772    case 81 then
4773      txt = 'char';
4774    //int16 matrix
4775    case 82 then
4776      txt = 'short';
4777    //int32 matrix
4778    case 84 then
4779      txt = 'long';
4780    //uint8 matrix
4781    case 811 then
4782      txt = 'unsigned char';
4783    //uint16 matrix
4784    case 812 then
4785      txt = 'unsigned short';
4786    //uint32 matrix
4787    case 814 then
4788      txt = 'unsigned long';
4789    else
4790      txt='double'
4791      break;
4792  end
4793 endfunction
4794
4795 //scs_c_nb2scs_nb : scicos C number to scicos number
4796 //
4797 //input : c_nb  : the scicos C number type
4798 //
4799 //output : scs_nb : the scilab number type
4800 //
4801 //16/06/07 Author : A.Layec
4802 function [scs_nb]=scs_c_nb2scs_nb(c_nb)
4803  scs_nb=zeros(size(c_nb,1),size(c_nb,2));
4804  for i=1:size(c_nb,1)
4805    for j=1:size(c_nb,2)
4806      select (c_nb(i,j))
4807        case 10 then
4808          scs_nb(i,j) = 1
4809        case 11 then
4810          scs_nb(i,j) = 2
4811        case 81 then
4812          scs_nb(i,j) = 5
4813        case 82 then
4814          scs_nb(i,j) = 4
4815        case 84 then
4816          scs_nb(i,j) = 3
4817        case 811 then
4818          scs_nb(i,j) = 8
4819        case 812 then
4820          scs_nb(i,j) = 7
4821        case 814 then
4822          scs_nb(i,j) = 6
4823        else
4824          scs_nb(i,j) = 1
4825      end
4826    end
4827  end
4828 endfunction
4829
4830 //used in do_compile_superblock
4831 function XX=update_block(XX)
4832   execstr('o='+rdnom+'_c(''define'')')
4833   XX.model=o.model
4834   XX.gui=rdnom+'_c';
4835   XX.graphics.gr_i=o.graphics.gr_i
4836 endfunction
4837
4838 //write_code_cdoit : generate body of the code for
4839 //                   for all time dependant blocks
4840 //
4841 //input : flag : flag number for block's call
4842 //
4843 //output : txt for cord blocks
4844 //
4845 //12/07/07 Alan Layec
4846 function [txt]=write_code_cdoit(flag)
4847   txt=[];
4848
4849   for j=1:ncord
4850     bk=cord(j,1);
4851     pt=cord(j,2);
4852     //** blk
4853     if funtyp(bk)>-1 then
4854       if or(bk==act) | or(bk==cap) then
4855         if stalone then
4856           txt2=call_block42(bk,pt,flag);
4857           if txt2<>[] then
4858             txt=[txt;
4859                  '    '+txt2
4860                  ''];
4861           end
4862         end
4863       else
4864         txt2=call_block42(bk,pt,flag);
4865         if txt2<>[] then
4866           txt=[txt;
4867                '    '+txt2
4868                ''];
4869         end
4870       end
4871     //** ifthenelse blk
4872     elseif funtyp(bk)==-1 then
4873       ix=-1+inplnk(inpptr(bk));
4874       TYPE=mat2c_typ(outtb(ix+1)); //** scilab index start from 1
4875       thentxt=write_code_doit(clkptr(bk),flag);
4876       elsetxt=write_code_doit(clkptr(bk)+1,flag);
4877       if thentxt<>[] | elsetxt<>[] then
4878         txt=[txt;
4879              '    '+get_comment('ifthenelse_blk',list(bk));]
4880         //** C **//
4881         tmp_='*(('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(ix)+'])'
4882         txt=[txt;
4883              '    if('+tmp_+'>0) {']
4884         //*******//
4885         txt=[txt;
4886              Indent+thentxt];
4887         if elsetxt<>[] then
4888           //** C **//
4889           txt=[txt;
4890                '    }';
4891                '    else {';]
4892           //*******//
4893           txt=[txt;
4894                Indent+elsetxt];
4895         end
4896         //** C **//
4897         txt=[txt;
4898              '    }']
4899         //*******//
4900       end
4901     //** eventselect blk
4902     elseif funtyp(bk)==-2 then
4903       Noutport=clkptr(bk+1)-clkptr(bk);
4904       ix=-1+inplnk(inpptr(bk));
4905       TYPE=mat2c_typ(outtb(ix+1)); //** scilab index start from 1
4906       II=[];
4907       switchtxt=list()
4908       for i=1: Noutport
4909         switchtxt(i)=write_code_doit(clkptr(bk)+i-1,flag);
4910         if switchtxt(i)<>[] then II=[II i];end
4911       end
4912       if II<>[] then
4913         txt=[txt;
4914              '    '+get_comment('evtselect_blk',list(bk));]
4915         //** C **//
4916         tmp_='*(('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(ix)+'])'
4917         txt=[txt;
4918              '    i=max(min((int) '+...
4919               tmp_+',block_'+rdnom+'['+string(bk-1)+'].evout),1);'
4920              '    switch(i)'
4921              '    {']
4922         //*******//
4923         for i=II
4924          //** C **//
4925          txt=[txt;
4926               '     case '+string(i)+' :';]
4927          //*******//
4928          txt=[txt;
4929               BigIndent+write_code_doit(clkptr(bk)+i-1,flag);]
4930          //** C **//
4931          txt=[txt;
4932               BigIndent+'break;']
4933          //*******//
4934         end
4935         //** C **//
4936         txt=[txt;
4937              '    }'];
4938         //*******//
4939       end
4940     //** Unknown block
4941     else
4942       error('Unknown block type '+string(bk));
4943     end
4944   end
4945
4946 endfunction
4947
4948 //write_code_doit : generate body of the code for
4949 //                  ordering calls of blocks during
4950 //                  flag 1,2 & flag 3
4951 //
4952 //input : ev  : evt number for block's call
4953 //       flag : flag number for block's call
4954 //
4955 //output : txt for flag 1 or 2, or flag 3
4956 //
4957 //12/07/07 Alan Layec
4958 function [txt]=write_code_doit(ev,flag)
4959   txt=[];
4960
4961   for j=ordptr(ev):ordptr(ev+1)-1
4962     bk=ordclk(j,1);
4963     pt=ordclk(j,2);
4964     //** blk
4965     if funtyp(bk)>-1 then
4966       if or(bk==act) | or(bk==cap) then
4967         if stalone then
4968           txt2=call_block42(bk,pt,flag);
4969           if txt2<>[] then
4970             txt=[txt;
4971                  '    '+txt2
4972                  ''];
4973           end
4974         end
4975       else
4976         txt2=call_block42(bk,pt,flag);
4977         if txt2<>[] then
4978           txt=[txt;
4979                '    '+txt2
4980                ''];
4981         end
4982       end
4983     //** ifthenelse blk
4984     elseif funtyp(bk)==-1 then
4985       ix=-1+inplnk(inpptr(bk));
4986       TYPE=mat2c_typ(outtb(ix+1)); //** scilab index start from 1
4987       thentxt=write_code_doit(clkptr(bk),flag);
4988       elsetxt=write_code_doit(clkptr(bk)+1,flag);
4989       if thentxt<>[] | elsetxt<>[] then
4990         txt=[txt;
4991              '    '+get_comment('ifthenelse_blk',list(bk));]
4992         //** C **//
4993         tmp_ = '*(('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(ix)+'])'
4994         txt=[txt;
4995              '    if('+tmp_+'>0) {']
4996         //*******//
4997         txt=[txt;
4998              Indent+thentxt]
4999         if elsetxt<>[] then
5000            //** C **//
5001            txt=[txt;
5002                 '    }';
5003                 '    else {';]
5004            //*******//
5005            txt=[txt;
5006                 Indent+elsetxt];
5007         end
5008         //** C **//
5009         txt=[txt;
5010              '    }']
5011         //*******//
5012       end
5013     //** eventselect blk
5014     elseif funtyp(bk)==-2 then
5015       Noutport=clkptr(bk+1)-clkptr(bk);
5016       ix=-1+inplnk(inpptr(bk));
5017       TYPE=mat2c_typ(outtb(ix+1)); //** scilab index start from 1
5018       II=[];
5019       switchtxt=list()
5020       for i=1: Noutport
5021         switchtxt(i)=write_code_doit(clkptr(bk)+i-1,flag);
5022         if switchtxt(i)<>[] then II=[II i];end
5023       end
5024       if II<>[] then
5025         txt=[txt;
5026              '    '+get_comment('evtselect_blk',list(bk));]
5027         tmp_='*(('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(ix)+'])'
5028         //** C **//
5029         txt=[txt;
5030              '    i=max(min((int) '+...
5031               tmp_+',block_'+rdnom+'['+string(bk-1)+'].evout),1);'
5032              '    switch(i)'
5033              '    {']
5034         //*******//
5035         for i=II
5036           //** C **//
5037           txt=[txt;
5038                '     case '+string(i)+' :';]
5039           //*******//
5040           txt=[txt;
5041                BigIndent+write_code_doit(clkptr(bk)+i-1,flag);]
5042           //** C **//
5043           txt=[txt;
5044                BigIndent+'break;']
5045           //*******//
5046         end
5047         //** C **//
5048         txt=[txt;
5049              '    }']
5050         //*******//
5051       end
5052     //** Unknown block
5053     else
5054       error('Unknown block type '+string(bk));
5055     end
5056   end
5057
5058 endfunction
5059
5060 //write_code_idoit : generate body of the code for
5061 //                   ordering calls of initial
5062 //                   called blocks
5063 //
5064 //input : nothing (blocks are called with flag 1)
5065 //
5066 //output : txt for iord
5067 //
5068 //15/07/07 Alan Layec
5069 function [txt]=write_code_idoit()
5070   txt=[];
5071
5072   for j=1:niord
5073     bk=iord(j,1);
5074     pt=iord(j,2);
5075     //** blk
5076     if funtyp(bk)>-1 then
5077       if or(bk==act) then
5078         if stalone then
5079           txt2=call_block42(bk,pt,1);
5080           if txt2<>[] then
5081             txt=[txt;
5082                  '    '+txt2
5083                  ''];
5084           end
5085         end
5086       else
5087         txt2=call_block42(bk,pt,1);
5088         if txt2<>[] then
5089           txt=[txt;
5090                '    '+txt2
5091                ''];
5092         end
5093       end
5094     //** ifthenelse blk
5095     elseif funtyp(bk)==-1 then
5096       ix=-1+inplnk(inpptr(bk));
5097       TYPE=mat2c_typ(outtb(ix+1)); //** scilab index start from 1
5098       thentxt=write_code_doit(clkptr(bk),1);
5099       elsetxt=write_code_doit(clkptr(bk)+1,1);
5100       if thentxt<>[] | elsetxt<>[] then
5101         txt=[txt;
5102              '    '+get_comment('ifthenelse_blk',list(bk));]
5103         //** C **//
5104         tmp_ = '*(('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(ix)+'])'
5105         txt=[txt;
5106              '    if('+tmp_+'>0) {']
5107         //*******//
5108         txt=[txt;
5109              Indent+thentxt];
5110         if elsetxt<>[] then
5111            //** C **//
5112            txt=[txt;
5113                 '    }';
5114                 '    else {';]
5115            //*******//
5116            txt=[txt;
5117                 Indent+elsetxt];
5118         end
5119         //** C **//
5120         txt=[txt;
5121              '    }']
5122         //*******//
5123       end
5124     //** eventselect blk
5125     elseif funtyp(bk)==-2 then
5126       Noutport=clkptr(bk+1)-clkptr(bk);
5127       ix=-1+inplnk(inpptr(bk));
5128       TYPE=mat2c_typ(outtb(ix+1)); //** scilab index start from 1
5129       II=[];
5130       switchtxt=list()
5131       for i=1: Noutport
5132         switchtxt(i)=write_code_doit(clkptr(bk)+i-1,1);
5133         if switchtxt(i)<>[] then II=[II i];end
5134       end
5135       if II<>[] then
5136         txt=[txt;
5137              '    '+get_comment('evtselect_blk',list(bk));]
5138         //** C **//
5139         tmp_='*(('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(ix)+'])'
5140         txt=[txt;
5141              '    i=max(min((int) '+...
5142               tmp_+',block_'+rdnom+'['+string(bk-1)+'].evout),1);']
5143         txt=[txt;
5144              '    switch(i)'
5145              '    {']
5146         //*******//
5147         for i=II
5148           //** C **//
5149           txt=[txt;
5150                '     case '+string(i)+' :';]
5151           //*******//
5152           txt=[txt;
5153                BigIndent+write_code_doit(clkptr(bk)+i-1,1);]
5154           //** C **//
5155           txt=[txt;
5156                BigIndent+'break;']
5157           //*******//
5158         end
5159         //** C **//
5160         txt=[txt;
5161              '    }'];
5162         //*******//
5163       end
5164     //** Unknown block
5165     else
5166       error('Unknown block type '+string(bk));
5167     end
5168   end
5169
5170 endfunction
5171
5172 //write_code_odoit : generate body of the code for
5173 //                   ordering calls of blocks before
5174 //                   continuous time integration
5175 //
5176 //input : flag : flag number for block's call
5177 //
5178 //output : txt for flag 0
5179 //
5180 //12/07/07 Alan Layec
5181 function [txt]=write_code_odoit(flag)
5182   txt=[];
5183
5184   for j=1:noord
5185     bk=oord(j,1);
5186     pt=oord(j,2);
5187     //** blk
5188     if funtyp(bk)>-1 then
5189       txt2=call_block42(bk,pt,flag);
5190       if txt2<>[] then
5191         txt=[txt;
5192              '    '+txt2
5193              ''];
5194       end
5195     //** ifthenelse blk
5196     elseif funtyp(bk)==-1 then
5197       ix=-1+inplnk(inpptr(bk));
5198       TYPE=mat2c_typ(outtb(ix+1)); //** scilab index start from 1
5199       thentxt=write_code_ozdoit(clkptr(bk),flag);
5200       elsetxt=write_code_ozdoit(clkptr(bk)+1,flag);
5201       if thentxt<>[] | elsetxt<>[] then
5202         txt=[txt;
5203              '    '+get_comment('ifthenelse_blk',list(bk));]
5204         //** C **//
5205         tmp_='*(('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(ix)+'])'
5206         txt=[txt;
5207              '    if ((block_'+rdnom+'['+string(bk-1)+'].nmode<0'+...
5208               ' && '+tmp_+'>0)'+...
5209               ' || \'
5210              '        (block_'+rdnom+'['+string(bk-1)+'].nmode>0'+...
5211               ' && block_'+rdnom+'['+string(bk-1)+'].mode[0]==1)) {']
5212         //*******//
5213         txt=[txt;
5214              Indent+thentxt]
5215         //** C **//
5216         txt=[txt;
5217              '    }'];
5218         //*******//
5219         if elsetxt<>[] then
5220           //** C **//
5221           txt=[txt;
5222                '    else if  ((block_'+rdnom+'['+string(bk-1)+'].nmode<0'+...
5223                 ' && '+tmp_+'<=0)'+...
5224                 ' || \'
5225                '              (block_'+rdnom+'['+string(bk-1)+'].nmode>0'+...
5226                 ' && block_'+rdnom+'['+string(bk-1)+'].mode[0]==2)) {';]
5227           //*******//
5228           txt=[txt;
5229                Indent+elsetxt]
5230           //** C **//
5231           txt=[txt;
5232                '    }'];
5233           //*******//
5234         end
5235       end
5236     //** eventselect blk
5237     elseif funtyp(bk)==-2 then
5238       Noutport=clkptr(bk+1)-clkptr(bk);
5239       ix=-1+inplnk(inpptr(bk));
5240       TYPE=mat2c_typ(outtb(ix+1)); //** scilab index start from 1
5241       II=[];
5242       switchtxt=list()
5243       for i=1: Noutport
5244         switchtxt(i)=write_code_ozdoit(clkptr(bk)+i-1,flag);
5245         if switchtxt(i)<>[] then II=[II i];end
5246       end
5247       if II<>[] then
5248         txt=[txt;
5249              '    '+get_comment('evtselect_blk',list(bk));]
5250         //** C **//
5251         tmp_='*(('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(ix)+'])'
5252         txt=[txt;
5253              '    if (block_'+rdnom+'['+string(bk-1)+'].nmode<0) {';
5254              '      i=max(min((int) '+...
5255                 tmp_+',block_'+rdnom+'['+string(bk-1)+'].evout),1);'
5256              '    }'
5257              '    else {'
5258              '      i=block_'+rdnom+'['+string(bk-1)+'].mode[0];'
5259              '    }']
5260         txt=[txt;
5261              '    switch(i)'
5262              '    {'];
5263         //*******//
5264         for i=II
5265           //** C **//
5266           txt=[txt;
5267                '     case '+string(i)+' :';]
5268           //*******//
5269           txt=[txt;
5270                BigIndent+write_code_ozdoit(clkptr(bk)+i-1,flag);]
5271           //** C **//
5272           txt=[txt;
5273                BigIndent+'break;']
5274           //*******//
5275         end
5276         //** C **//
5277         txt=[txt;
5278              '    }'];
5279         //*******//
5280       end
5281     //** Unknown block
5282     else
5283       error('Unknown block type '+string(bk));
5284     end
5285   end
5286
5287 endfunction
5288
5289 //write_code_ozdoit : generate body of the code for both
5290 //                    flag 0 & flag 9
5291 //
5292 //input: ev  : evt number for block's call
5293 //      flag : flag number for block's call
5294 //
5295 //output : txt for flag 0 or flag 9
5296 //
5297 //12/07/07 Alan Layec
5298 function [txt]=write_code_ozdoit(ev,flag)
5299   txt=[];
5300
5301   for j=ordptr(ev):ordptr(ev+1)-1
5302     bk=ordclk(j,1);
5303     pt=ordclk(j,2);
5304     //** blk
5305     if funtyp(bk)>-1 then
5306       if (or(bk==act) | or(bk==cap)) & (flag==1) then
5307         if stalone then
5308           txt=[txt;
5309                '    '+call_block42(bk,pt,flag)
5310                ''];
5311         end
5312       else
5313         txt2=call_block42(bk,pt,flag);
5314         if txt2<>[] then
5315           txt=[txt;
5316                '    '+txt2
5317                ''];
5318         end
5319       end
5320     //** ifthenelse blk
5321     elseif funtyp(bk)==-1 then
5322       ix=-1+inplnk(inpptr(bk));
5323       TYPE=mat2c_typ(outtb(ix+1)); //** scilab index start from 1
5324       thentxt=write_code_ozdoit(clkptr(bk),flag);
5325       elsetxt=write_code_ozdoit(clkptr(bk)+1,flag);
5326       if thentxt<>[] | elsetxt<>[] then
5327         txt=[txt;
5328              '    '+get_comment('ifthenelse_blk',list(bk));]
5329         //** C **//
5330         tmp_ = '*(('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(ix)+'])'
5331         txt=[txt;
5332              '    if (((phase==1'+...
5333               ' || block_'+rdnom+'['+string(bk-1)+'].nmode==0)'+...
5334               ' && '+tmp_+'>0)'+...
5335               ' || \'
5336              '        ((phase!=1'+...
5337               ' && block_'+rdnom+'['+string(bk-1)+'].nmode!=0)'+...
5338               ' && block_'+rdnom+'['+string(bk-1)+'].mode[0]==1)) {']
5339         //*******//
5340         txt=[txt;
5341              Indent+thentxt]
5342         //** C **//
5343         txt=[txt;
5344              '    }'];
5345         //*******//
5346         if elsetxt<>[] then
5347            //** C **//
5348            txt=[txt;
5349                 '      else if (((phase==1'+...
5350                  ' || block_'+rdnom+'['+string(bk-1)+'].nmode==0)'+...
5351                  ' && '+tmp_+'<=0)'+...
5352                  ' || \'
5353                 '               ((phase!=1'+...
5354                  ' && block_'+rdnom+'['+string(bk-1)+'].nmode!=0)'+...
5355                  ' && block_'+rdnom+'['+string(bk-1)+'].mode[0]==2)) {';]
5356           //*******//
5357           txt=[txt;
5358                Indent+elsetxt]
5359           //** C **//
5360           txt=[txt;
5361                 '    }'];
5362           //*******//
5363         end
5364       end
5365     //** eventselect blk
5366     elseif funtyp(bk)==-2 then
5367       Noutport=clkptr(bk+1)-clkptr(bk);
5368       ix=-1+inplnk(inpptr(bk));
5369       TYPE=mat2c_typ(outtb(ix+1)); //** scilab index start from 1
5370       II=[];
5371       switchtxt=list()
5372       for i=1: Noutport
5373         switchtxt(i)=write_code_ozdoit(clkptr(bk)+i-1,flag);
5374         if switchtxt(i)<>[] then II=[II i];end
5375       end
5376       if II<>[] then
5377         txt=[txt;
5378              '    '+get_comment('evtselect_blk',list(bk));]
5379         //** C **//
5380         tmp_='*(('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(ix)+'])'
5381         txt=[txt;
5382              '    if (phase==1 || block_'+rdnom+'['+string(bk-1)+'].nmode==0) {';
5383              '      i=max(min((int) '+...
5384               tmp_+',block_'+rdnom+'['+string(bk-1)+'].evout),1);'
5385              '    }'
5386              '    else {'
5387              '      i=block_'+rdnom+'['+string(bk-1)+'].mode[0];'
5388              '    }']
5389         txt=[txt;
5390              '    switch(i)'
5391              '    {'];
5392         //*******//
5393         for i=II
5394           //** C **//
5395           txt=[txt;
5396                '     case '+string(i)+' :';]
5397           //*******//
5398           txt=[txt;
5399                BigIndent+write_code_ozdoit(clkptr(bk)+i-1,flag);]
5400           //** C **//
5401           txt=[txt;
5402                BigIndent+'break;']
5403           //*******//
5404         end
5405         //** C **//
5406         txt=[txt;
5407              '    }'];
5408         //*******//
5409       end
5410     //** Unknown block
5411     else
5412       error('Unknown block type '+string(bk));
5413     end
5414   end
5415
5416 endfunction
5417
5418 //write_code_zdoit : generate body of the code for
5419 //                   ordering calls of blocks before
5420 //                   continuous time zero crossing
5421 //                   detection
5422 //
5423 //input : noting
5424 //
5425 //output : txt for flag 9
5426 //
5427 //12/07/07 Alan Layec
5428 function [txt]=write_code_zdoit()
5429   txt=[];
5430
5431   //** first pass (flag 1)
5432   for j=1:nzord
5433     bk=zord(j,1);
5434     pt=zord(j,2);
5435     //** blk
5436     if funtyp(bk)>-1 then
5437       if or(bk==act) | or(bk==cap) then
5438         if stalone then
5439           txt=[txt;
5440                '    '+call_block42(bk,pt,1)
5441                ''];
5442         end
5443       else
5444         txt2=call_block42(bk,pt,1);
5445         if txt2<>[] then
5446           txt=[txt;
5447                '    '+txt2
5448                ''];
5449         end
5450       end
5451     //** ifthenelse blk
5452     elseif funtyp(bk)==-1 then
5453       ix=-1+inplnk(inpptr(bk));
5454       TYPE=mat2c_typ(outtb(ix+1)); //** scilab index start from 1
5455       thentxt=write_code_ozdoit(clkptr(bk),1);
5456       elsetxt=write_code_ozdoit(clkptr(bk)+1,1);
5457       if thentxt<>[] | elsetxt<>[] then
5458         txt=[txt;
5459              '    '+get_comment('ifthenelse_blk',list(bk));]
5460         //** C **//
5461         tmp_ = '*(('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(ix)+'])'
5462         txt=[txt;
5463              '    if (((phase==1'+...
5464               ' || block_'+rdnom+'['+string(bk-1)+'].nmode==0)'+...
5465               ' && '+tmp_+'>0)'+...
5466               ' || \'
5467              '        ((phase!=1'+...
5468               ' && block_'+rdnom+'['+string(bk-1)+'].nmode!=0)'+...
5469               ' && block_'+rdnom+'['+string(bk-1)+'].mode[0]==1)) {']
5470         //*******//
5471         txt=[txt;
5472              Indent+thentxt]
5473         //** C **//
5474         txt=[txt;
5475              '    }'];
5476         //*******//
5477         if elsetxt<>[] then
5478            //** C **//
5479            txt=[txt;
5480                 '      else if (((phase==1'+...
5481                  ' || block_'+rdnom+'['+string(bk-1)+'].nmode==0)'+...
5482                  ' && '+tmp_+'<=0)'+...
5483                  ' || \'
5484                 '               ((phase!=1'+...
5485                  ' && block_'+rdnom+'['+string(bk-1)+'].nmode!=0)'+...
5486                  ' && block_'+rdnom+'['+string(bk-1)+'].mode[0]==2)) {';]
5487           //*******//
5488           txt=[txt;
5489                Indent+elsetxt]
5490           //** C **//
5491           txt=[txt;
5492                '    }'];
5493           //*******//
5494         end
5495       end
5496     //** eventselect blk
5497     elseif funtyp(bk)==-2 then
5498       Noutport=clkptr(bk+1)-clkptr(bk);
5499       ix=-1+inplnk(inpptr(bk));
5500       TYPE=mat2c_typ(outtb(ix+1)); //** scilab index start from 1
5501       II=[];
5502       switchtxt=list()
5503       for i=1: Noutport
5504         switchtxt(i)=write_code_ozdoit(clkptr(bk)+i-1,1);
5505         if switchtxt(i)<>[] then II=[II i];end
5506       end
5507       if II<>[] then
5508         txt=[txt;
5509              '    '+get_comment('evtselect_blk',list(bk));]
5510         //** C **//
5511         tmp_='*(('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(ix)+'])'
5512         txt=[txt;
5513              '    if (phase==1 || block_'+rdnom+'['+string(bk-1)+'].nmode==0){';
5514              '      i=max(min((int) '+...
5515                tmp_+',block_'+rdnom+'['+string(bk-1)+'].evout),1);'
5516              '    else {'
5517              '      i=block_'+rdnom+'['+string(bk-1)+'].mode[0];'
5518              '    }']
5519         txt=[txt;
5520              '      switch(i)'
5521              '      {'];
5522         //*******//
5523         for i=II
5524           //** C **//
5525           txt=[txt;
5526                '       case '+string(i)+' :';]
5527           //*******//
5528           txt=[txt;
5529                BigIndent+write_code_ozdoit(clkptr(bk)+i-1,1);]
5530           //** C **//
5531           txt=[txt;
5532                BigIndent+'break;']
5533           //*******//
5534         end
5535         //** C **//
5536         txt=[txt;
5537              '      }'];
5538         //*******//
5539       end
5540     //** Unknown block
5541     else
5542       error('Unknown block type '+string(bk));
5543     end
5544   end
5545
5546   //** second pass (flag 9)
5547   for j=1:nzord
5548     bk=zord(j,1);
5549     pt=zord(j,2);
5550     //** blk
5551     if funtyp(bk)>-1 then
5552         if or(bk==act) | or(bk==cap) then
5553           if stalone then
5554             txt=[txt;
5555                  '    '+call_block42(bk,pt,9)
5556                  ''];
5557           end
5558         else
5559           txt2=call_block42(bk,pt,9);
5560           if txt2<>[] then
5561             txt=[txt;
5562                  '    '+txt2
5563                  ''];
5564           end
5565         end
5566
5567     //** ifthenelse blk
5568     elseif funtyp(bk)==-1 then
5569         ix=-1+inplnk(inpptr(bk));
5570         TYPE=mat2c_typ(outtb(ix+1)); //** scilab index start from 1
5571         //** C **//
5572         tmp_='*(('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(ix)+'])'
5573         //*******//
5574         thentxt=write_code_zzdoit(clkptr(bk),9);
5575         elsetxt=write_code_zzdoit(clkptr(bk)+1,9);
5576         txt=[txt;
5577              '    '+get_comment('ifthenelse_blk',list(bk));]
5578         //** C **//
5579         txt=[txt;
5580               '    g['+string(zcptr(bk)-1)+']=(double)'+tmp_+';']
5581         //*******//
5582         if thentxt<>[] | elsetxt<>[] then
5583            //** C **//
5584            txt=[txt;
5585                 '    if (g['+string(zcptr(bk)-1)+'] > 0.){']
5586            //*******//
5587            txt=[txt;
5588                 Indent+thentxt]
5589            //** C **//
5590            txt=[txt;
5591                 '      }']
5592            //*******//
5593            if elsetxt <> [] then
5594              //** C **//
5595              txt=[txt;
5596                   '      else {']
5597              //*******//
5598              txt=[txt;
5599                   Indent+elsetxt]
5600              //** C **//
5601              txt=[txt;
5602                   '      }']
5603              //*******//
5604            end
5605         end
5606         //** C **//
5607         txt=[txt;
5608               '    if(phase==1 && block_'+rdnom+'['+string(bk-1)+'].nmode > 0){'
5609               '      if (g['+string(zcptr(bk)-1)+'] > 0.){'
5610               '        block_'+rdnom+'['+string(bk-1)+'].mode[0] = 1;'
5611               '      }'
5612               '      else {'
5613               '        block_'+rdnom+'['+string(bk-1)+'].mode[0] = 2;'
5614               '      }'
5615               '    }']
5616         //*******//
5617     //** eventselect blk
5618     elseif funtyp(bk)==-2 then
5619         Noutport=clkptr(bk+1)-clkptr(bk);
5620         ix=-1+inplnk(inpptr(bk));
5621         TYPE=mat2c_typ(outtb(ix+1));  //** scilab index start from 1
5622         //** C **//
5623         tmp_='*(('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(ix)+'])'
5624         //*******//
5625         II=[];
5626         switchtxt=list()
5627         for i=1:Noutport
5628           switchtxt(i)=write_code_zzdoit(clkptr(bk)+i-1,9);
5629           if switchtxt(i)<>[] then II=[II i];end
5630         end
5631         txt=[txt;
5632              '    '+get_comment('evtselect_blk',list(bk));]
5633         if II<>[] then
5634           //** C **//
5635           txt=[txt;
5636                '    j=max(min((int) '+...
5637                 tmp_+',block_'+rdnom+'['+string(bk-1)+'].nevout),1);']
5638           txt=[txt;
5639                '    switch(j)'
5640                '    {'];
5641           //*******//
5642           for i=II
5643             //** C **//
5644             txt=[txt;
5645                  '     case '+string(j)+' :';]
5646             //*******//
5647             txt=[txt;
5648                  BigIndent+write_code_zzdoit(clkptr(bk)+i-1,9);]
5649             //** C **//
5650             txt=[txt;
5651                  BigIndent+'break;']
5652             //*******//
5653           end
5654           //** C **//
5655           txt=[txt;
5656                '    }'];
5657           //*******//
5658         end
5659         //** C **//
5660         txt=[txt;
5661              '  for (jj=0;jj<block_'+rdnom+'['+string(fun-1)+'].nevout-1;++jj) {'
5662              '    g['+string(zcptr(bk)-1)+'+jj]=(double)'+tmp_+'-(double)(jj+2);'
5663              '  }'
5664              '  if(phase==1 && block_'+rdnom+'['+string(bk-1)+'].nmode>0){'
5665              '    j=max(min((int) '+tmp_+','
5666              '              block_'+rdnom+'['+string(bk-1)+'].nevout),1);'
5667              '    block_'+rdnom+'['+string(bk-1)+'].mode[0]= j;'
5668              '  }']
5669         //*******//
5670     //** Unknown block
5671     else
5672       error('Unknown block type '+string(bk));
5673     end
5674   end
5675
5676 endfunction
5677
5678 //write_code_zzdoit : generate body of the code for
5679 //                    flag 9
5680 //
5681 //input: ev  : evt number for block's call
5682 //      flag : flag number for block's call
5683 //
5684 //output : txt for flag 9
5685 //
5686 //12/07/07 Alan Layec
5687 function [txt]=write_code_zzdoit(ev,flag)
5688   txt=[];
5689
5690   for j=ordptr(ev):ordptr(ev+1)-1
5691     bk=ordclk(j,1);
5692     pt=ordclk(j,2);
5693     //** blk
5694     if funtyp(bk)>-1 then
5695       if or(bk==act) | or(bk==cap) then
5696         if stalone then
5697           txt=[txt;
5698                '    '+call_block42(bk,pt,flag)
5699                ''];
5700         end
5701       else
5702         txt2=call_block42(bk,pt,flag);
5703         if txt2<>[] then
5704           txt=[txt;
5705                '    '+txt2
5706                ''];
5707         end
5708       end
5709     //** ifthenelse blk
5710     elseif funtyp(bk)==-1 then
5711         ix=-1+inplnk(inpptr(bk));
5712         TYPE=mat2c_typ(outtb(ix+1)); //** scilab index start from 1
5713         //** C **//
5714         tmp_='*(('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(ix)+'])'
5715         //*******//
5716         thentxt=write_code_zzdoit(clkptr(bk),9);
5717         elsetxt=write_code_zzdoit(clkptr(bk)+1,9);
5718         txt=[txt;
5719              '    '+get_comment('ifthenelse_blk',list(bk));]
5720         //** C **//
5721         txt=[txt;
5722               '    g['+string(zcptr(bk)-1)+']=(double)'+tmp_+';']
5723         //*******//
5724         if thentxt<>[] | elsetxt<>[] then
5725            //** C **//
5726            txt=[txt;
5727                 '    if (g['+string(zcptr(bk)-1)+'] > 0.){']
5728            //*******//
5729            txt=[txt;
5730                 Indent+thentxt]
5731            //** C **//
5732            txt=[txt;
5733                 '      }']
5734            //*******//
5735            if elsetxt <> [] then
5736              //** C **//
5737              txt=[txt;
5738                   '      else {']
5739              //*******//
5740              txt=[txt;
5741                   Indent+elsetxt]
5742              //** C **//
5743              txt=[txt;
5744                   '      }']
5745              //*******//
5746            end
5747         end
5748         //** C **//
5749         txt=[txt;
5750               '    if(phase==1 && block_'+rdnom+'['+string(bk-1)+'].nmode > 0){'
5751               '      if (g['+string(zcptr(bk)-1)+'] > 0.){'
5752               '        block_'+rdnom+'['+string(bk-1)+'].mode[0] = 1;'
5753               '      }'
5754               '      else {'
5755               '        block_'+rdnom+'['+string(bk-1)+'].mode[0] = 2;'
5756               '      }'
5757               '    }']
5758         //*******//
5759
5760     //** eventselect blk
5761     elseif funtyp(bk)==-2 then
5762         Noutport=clkptr(bk+1)-clkptr(bk);
5763         ix=-1+inplnk(inpptr(bk));
5764         TYPE=mat2c_typ(outtb(ix+1));  //** scilab index start from 1
5765         //** C **//
5766         tmp_='*(('+TYPE+' *)'+rdnom+'_block_outtbptr['+string(ix)+'])'
5767         //*******//
5768         II=[];
5769         switchtxt=list()
5770         for i=1:Noutport
5771           switchtxt(i)=write_code_zzdoit(clkptr(bk)+i-1,9);
5772           if switchtxt(i)<>[] then II=[II i];end
5773         end
5774         txt=[txt;
5775              '    '+get_comment('evtselect_blk',list(bk));]
5776         if II<>[] then
5777           //** C **//
5778           txt=[txt;
5779                '    j=max(min((int) '+...
5780                 tmp_+',block_'+rdnom+'['+string(bk-1)+'].nevout),1);']
5781           txt=[txt;
5782                '    switch(j)'
5783                '    {'];
5784           //*******//
5785           for i=II
5786             //** C **//
5787             txt=[txt;
5788                  '     case '+string(j)+' :';]
5789             //*******//
5790             txt=[txt;
5791                  BigIndent+write_code_zzdoit(clkptr(bk)+i-1,9);]
5792             //** C **//
5793             txt=[txt;
5794                  BigIndent+'break;']
5795             //*******//
5796           end
5797           //** C **//
5798           txt=[txt;
5799                '    }'];
5800           //*******//
5801         end
5802         //** C **//
5803         txt=[txt;
5804              '  for (jj=0;jj<block_'+rdnom+'['+string(fun-1)+'].nevout-1;++jj) {'
5805              '    g['+string(zcptr(bk)-1)+'+jj]=(double)'+tmp_+'-(double)(jj+2);'
5806              '  }'
5807              '  if(phase==1 && block_'+rdnom+'['+string(bk-1)+'].nmode>0){'
5808              '    j=max(min((int) '+tmp_+','
5809              '              block_'+rdnom+'['+string(bk-1)+'].nevout),1);'
5810              '    block_'+rdnom+'['+string(bk-1)+'].mode[0]= j;'
5811              '  }']
5812         //*******//
5813
5814     //** Unknown block
5815     else
5816       error('Unknown block type '+string(bk));
5817     end
5818   end
5819
5820 endfunction
5821
5822