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