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