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