1 /* Scicos 2 * 3 * Copyright (C) INRIA - METALAU Project <scicos@inria.fr> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or 8 * (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 18 * 19 * See the file ./license.txt 20 */ 21 22 #ifndef __SCICOS_BLOCK4_H__ 23 #define __SCICOS_BLOCK4_H__ 24 25 #ifndef NULL 26 #define NULL 0 27 #endif 28 29 #include <math.h> 30 #include <assert.h> 31 #include <stdlib.h> 32 33 #ifdef _MSC_VER 34 typedef void (*voidg) (); 35 #else 36 typedef void (*voidg) (void); 37 #endif 38 39 /* scicos_block structure definition 40 * WARNING: take care that this sructure is 41 * not the same as the one in scicos_block.h 42 * i.e same name but inptr and outptr are void ** 43 */ 44 typedef struct 45 { 46 int nevprt; // Binary coding of activation inputs, -1 for internal activation (zero crossings) 47 voidg funpt; // Pointer to the computational function 48 int type; // Type of the computational function, in this case type 4 49 void* scsptr; // Not used for C programming 50 int nz; // Size of discrete-time state vector 51 double *z; // Vector of discrete-time state 52 int noz; // Number of object states 53 int *ozsz; // Vector of sizes of object states 54 int *oztyp; // Vector of data types of object states 55 void **ozptr; // Table of pointers to object states 56 int nx; // Size of continuous-time state vector 57 double *x; // Vector of continuous-time state 58 double *xd; // Vector of the derivative of the continuous-state, same size nx 59 // (output for ODE solvers, output for DAE solvers) 60 double *res; // Vector of residuals, only used for internally implicit blocks, same size nx 61 // (output of equations for DAE solvers) 62 int *xprop; // Pointer to the continuous state properties register, only used for internally 63 // implicit blocks (-1 for algebraic states, 1 for differential states) 64 int nin; // Number of regular input ports 65 int *insz; // Vector of sizes of regular input ports 66 void **inptr; // Tables of pointer to the regular input ports 67 int nout; // Number of regular output ports 68 int *outsz; // Vector of sizes of regular output ports 69 void **outptr; // Tables of pointers to the regular output ports 70 int nevout; // Number of event output ports 71 double *evout; // Delay time of output events 72 int nrpar; // Size of real parameters vector 73 double *rpar; // Vector of real parameters 74 int nipar; // Size of integer parameters vector 75 int *ipar; // Vector of integer parameters 76 int nopar; // Number of object parameters 77 int *oparsz; // Vector of sizes of object parameters 78 int *opartyp; // Vector of data types of object parameters 79 void **oparptr; // Table of pointers to the object parameters 80 int ng; // Size of zero-crossing surfaces vector 81 double *g; // Vector of zero-crossing surfaces 82 int ztyp; // Boolean, True only if the block may have zero-crossing surfaces 83 int *jroot; // Vector of size ng indicates the presence and the direction of the crossing 84 char *label; // Block label 85 void **work; // Table of pointers to the block workspace (if allocation done by the block) 86 int nmode; // Size of modes vector 87 int *mode; // Vector of modes (used to handle discontinuities) 88 char *uid; 89 } scicos_block; 90 91 /** define scicos flag number */ 92 typedef enum 93 { 94 /* Should not be used directly, set through the API. */ 95 CosError = -5, 96 97 /* Valid simulation states */ 98 DerivativeState = 0, 99 OutputUpdate = 1, 100 StateUpdate = 2, 101 OutputEventTiming = 3, 102 Initialization = 4, 103 Ending = 5, 104 ReInitialization = 6, 105 ContinuousPropertiesUpdate = 7, 106 ZeroCrossing = 9, 107 Jacobian = 10 108 } scicos_flag; 109 110 /* utility function for block declaration */ 111 int get_block_error(void); 112 int *get_pointer_xproperty(void); 113 int get_npointer_xproperty(void); 114 double Get_Jacobian_cj(void); 115 double Get_Jacobian_ci(void); 116 double Get_Scicos_SQUR(void); 117 void Set_Jacobian_flag(int flag); 118 119 int Convert_number(char *, double *); 120 void homotopy(double *); 121 int hfjac_(double *, double *, int *); 122 int rhojac_(double *, double *, double *, double *, int *, double *, int *); 123 int rho_(double *, double *, double *, double *, double *, int *); 124 int fx_(double *, double *); 125 int read_xml_initial_states(int nvar, const char *xmlfile, char **ids, double *svars); 126 int write_xml_states(int, const char *, char **, double *); 127 128 /** Define scicos simulator data type number (_N) */ 129 typedef enum 130 { 131 SCSREAL_N = 10, 132 SCSCOMPLEX_N = 11, 133 SCSINT_N = 80, 134 SCSINT8_N = 81, 135 SCSINT16_N = 82, 136 SCSINT32_N = 84, 137 SCSUINT_N = 800, 138 SCSUINT8_N = 811, 139 SCSUINT16_N = 812, 140 SCSUINT32_N = 814, 141 SCSUNKNOW_N = -1 142 } scicos_datatype_number; 143 144 /* Define scicos simulator data type C operators (_COP) */ 145 #define SCSREAL_COP double 146 #define SCSCOMPLEX_COP double 147 #define SCSINT_COP int 148 #define SCSINT8_COP char 149 #define SCSINT16_COP short 150 #define SCSINT32_COP int 151 #define SCSUINT_COP unsigned int 152 #define SCSUINT8_COP unsigned char 153 #define SCSUINT16_COP unsigned short 154 #define SCSUINT32_COP unsigned int 155 #define SCSUNKNOW_COP double 156 157 /** \name Getters 158 * These macros should be used to ease programming and debugging of new blocks. 159 */ 160 ///@{ 161 162 /** 163 \brief Get number of regular input port. 164 */ 165 #define GetNin(blk) (blk->nin) 166 167 /** 168 \brief Get regular input port pointer of port number x. 169 */ 170 #define GetInPortPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), blk->inptr[(x)-1]) 171 172 /** 173 \brief Get number of regular output port. 174 */ 175 #define GetNout(blk) (blk->nout) 176 177 /** 178 \brief Get regular output port pointer of port number x. 179 */ 180 #define GetOutPortPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), blk->outptr[x-1]) 181 182 /** 183 \brief Get number of rows (first dimension) of regular input port number x. 184 */ 185 #define GetInPortRows(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), blk->insz[x-1]) 186 187 /** 188 \brief Get number of columns (second dimension) of regular input port number x. 189 */ 190 #define GetInPortCols(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), blk->insz[blk->nin+(x-1)]) 191 192 /** 193 \brief Get regular input port size number x. 194 * GetInPortSize(blk,x,1) : get first dimension of input port number x 195 * GetInPortSize(blk,x,2) : get second dimension of input port number x 196 */ 197 #define GetInPortSize(blk,x,y) (assert((x)>0), assert((x)<=(blk->nin)), \ 198 assert((y)>0), assert((y)<=2), blk->insz[(y-1)*blk->nin+(x-1)]) 199 200 /** 201 \brief Get type of regular input port number x. 202 */ 203 #define GetInType(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), \ 204 blk->insz[2*(blk->nin)+(x-1)]) 205 206 /** 207 \brief Get number of rows (first dimension) of regular output port number x. 208 */ 209 #define GetOutPortRows(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), blk->outsz[x-1]) 210 211 /** 212 \brief Get number of columns (second dimension) of regular output port number x. 213 */ 214 #define GetOutPortCols(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), blk->outsz[blk->nout+(x-1)]) 215 216 /** 217 \brief Get regular output port size number x. 218 * GetOutPortSize(blk,x,1) : get first dimension of output port number x 219 * GetOutPortSize(blk,x,2) : get second dimension of output port number x 220 */ 221 #define GetOutPortSize(blk,x,y) (assert((x)>0), assert((x)<=(blk->nout)), \ 222 assert((y)>0), assert((y)<=2), blk->outsz[(y-1)*blk->nout+(x-1)]) 223 224 /** 225 \brief Get type of regular output port number x. 226 */ 227 #define GetOutType(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), \ 228 blk->outsz[2*(blk->nout)+(x-1)]) 229 230 /** 231 \brief Get pointer of real part of regular input port number x. 232 */ 233 #define GetRealInPortPtrs(blk,x) (SCSREAL_COP *) GetInPortPtrs(blk,x) 234 235 /** 236 \brief Get pointer of imaginary part of regular input port number x. 237 */ 238 #define GetImagInPortPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), \ 239 (SCSREAL_COP *) ((SCSREAL_COP *)blk->inptr[x-1]+ \ 240 ((blk->insz[(x-1)])*(blk->insz[blk->nin+(x-1)])))) 241 242 /** 243 \brief Get pointer of real part of regular output port number x. 244 */ 245 #define GetRealOutPortPtrs(blk,x) (SCSREAL_COP *) GetOutPortPtrs(blk,x) 246 247 /** 248 \brief Get pointer of imaginary part of regular output port number x. 249 */ 250 #define GetImagOutPortPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), \ 251 (SCSREAL_COP *) ((SCSREAL_COP *)blk->outptr[x-1]+ \ 252 ((blk->outsz[(x-1)])*(blk->outsz[blk->nout+(x-1)])))) 253 254 /** 255 \brief Get pointer of int8 typed regular input port number x. 256 */ 257 #define Getint8InPortPtrs(blk,x) (SCSINT8_COP *) GetInPortPtrs(blk,x) 258 259 /** 260 \brief Get pointer of int16 typed regular input port number x. 261 */ 262 #define Getint16InPortPtrs(blk,x) (SCSINT16_COP *) GetInPortPtrs(blk,x) 263 264 /** 265 \brief Get pointer of int32 typed regular input port number x. 266 */ 267 #define Getint32InPortPtrs(blk,x) (SCSINT32_COP *) GetInPortPtrs(blk,x) 268 269 /** 270 \brief Get pointer of uint8 typed regular input port number x. 271 */ 272 #define Getuint8InPortPtrs(blk,x) (SCSUINT8_COP *) GetInPortPtrs(blk,x) 273 274 /** 275 \brief Get pointer of uint16 typed regular input port number x. 276 */ 277 #define Getuint16InPortPtrs(blk,x) (SCSUINT16_COP *) GetInPortPtrs(blk,x) 278 279 /** 280 \brief Get pointer of uint32 typed regular input port number x. 281 */ 282 #define Getuint32InPortPtrs(blk,x) (SCSUINT32_COP *) GetInPortPtrs(blk,x) 283 284 /** 285 \brief Get pointer of int8 typed regular output port number x. 286 */ 287 #define Getint8OutPortPtrs(blk,x) (SCSINT8_COP *) GetOutPortPtrs(blk,x) 288 289 /** 290 \brief Get pointer of int16 typed regular output port number x. 291 */ 292 #define Getint16OutPortPtrs(blk,x) (SCSINT16_COP *) GetOutPortPtrs(blk,x) 293 294 /** 295 \brief Get pointer of int32 typed regular output port number x. 296 */ 297 #define Getint32OutPortPtrs(blk,x) (SCSINT32_COP *) GetOutPortPtrs(blk,x) 298 299 /** 300 \brief Get pointer of uint8 typed regular output port number x. 301 */ 302 #define Getuint8OutPortPtrs(blk,x) (SCSUINT8_COP *) GetOutPortPtrs(blk,x) 303 304 /** 305 \brief Get pointer of uint16 typed regular output port number x. 306 */ 307 #define Getuint16OutPortPtrs(blk,x) (SCSUINT16_COP *) GetOutPortPtrs(blk,x) 308 309 /** 310 \brief Get pointer of uint32 typed regular output port number x. 311 */ 312 #define Getuint32OutPortPtrs(blk,x) (SCSUINT32_COP *) GetOutPortPtrs(blk,x) 313 314 /** 315 \brief Get number of integer parameters. 316 */ 317 #define GetNipar(blk) (blk->nipar) 318 319 /** 320 \brief Get pointer of the integer parameters register 321 */ 322 #define GetIparPtrs(blk) (blk->ipar) 323 324 /** 325 \brief Get number of real parameters. 326 */ 327 #define GetNrpar(blk) (blk->nrpar) 328 329 /** 330 \brief Get pointer of the real parameters register. 331 */ 332 #define GetRparPtrs(blk) (blk->rpar) 333 334 /** 335 \brief Get the pointer of the Work array. 336 */ 337 #define GetWorkPtrs(blk) (*(blk->work)) 338 339 /** 340 \brief Get number of continuous state. 341 */ 342 #define GetNstate(blk) (blk->nx) 343 344 /** 345 \brief Get pointer of the continuous state register. 346 */ 347 #define GetState(blk) (blk->x) 348 349 /** 350 \brief Get pointer of the derivative continuous state register. 351 */ 352 #define GetDerState(blk) (blk->xd) 353 354 /** 355 \brief Get pointer of the residual continuous state register. 356 */ 357 #define GetResState(blk) (blk->res) 358 359 /** 360 \brief Get pointer of continuous state properties register. 361 */ 362 #define GetXpropPtrs(blk) (blk->xprop) 363 364 /** 365 \brief Get number of discrete state. 366 */ 367 #define GetNdstate(blk) (blk->nz) 368 369 /** 370 \brief Get pointer of the discrete state register. 371 */ 372 #define GetDstate(blk) (blk->z) 373 374 /** 375 \brief Get the input event number. 376 */ 377 #define GetNevIn(blk) (blk->nevprt) 378 379 /** 380 \brief Get number of event output port. 381 */ 382 #define GetNevOut(blk) (blk->nevout) 383 384 /** 385 \brief Get pointer of event output register. 386 */ 387 #define GetNevOutPtrs(blk) (blk->evout) 388 389 /** 390 \brief Get number of object parameters. 391 */ 392 #define GetNopar(blk) (blk->nopar) 393 394 /** 395 \brief Get type of object parameters number x. 396 */ 397 #define GetOparType(blk,x) (assert(x>0), assert(x<=blk->nopar), blk->opartyp[x-1]) 398 399 /** 400 \brief Get size of object parameters number x. 401 * GetOparSize(blk,x,1) : get first dimension of opar 402 * GetOparSize(blk,x,2) : get second dimension of opar 403 */ 404 #define GetOparSize(blk,x,y) (assert((x)>0), assert(x<=blk->nopar), \ 405 assert((y)>0), assert((y)<=2), blk->oparsz[(y-1)*blk->nopar+(x-1)]) 406 407 /** 408 \brief Get pointer of object parameters number x. 409 */ 410 #define GetOparPtrs(blk,x) (assert((x)>0), assert((x)<=(blk)->nopar), (blk)->oparptr[(x)-1]) 411 412 /** 413 \brief Get pointer of real object parameters number x. 414 */ 415 #define GetRealOparPtrs(blk,x) (SCSREAL_COP *) GetOparPtrs(blk,x) 416 417 /** 418 \brief Get pointer of imaginary part of object parameters number x. 419 */ 420 #define GetImagOparPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nopar)), \ 421 (SCSREAL_COP *) ((SCSREAL_COP *)blk->oparptr[x-1]+ \ 422 ((blk->oparsz[x-1])*(blk->oparsz[blk->nopar+(x-1)]))) 423 424 /** 425 \brief Get pointer of int8 typed object parameters number x. 426 */ 427 #define Getint8OparPtrs(blk,x) (SCSINT8_COP *) GetOparPtrs(blk,x) 428 429 /** 430 \brief Get pointer of int16 typed object parameters number x. 431 */ 432 #define Getint16OparPtrs(blk,x) (SCSINT16_COP *) GetOparPtrs(blk,x) 433 434 /** 435 \brief Get pointer of int32 typed object parameters number x. 436 */ 437 #define Getint32OparPtrs(blk,x) (SCSINT32_COP *) GetOparPtrs(blk,x) 438 439 /** 440 \brief Get pointer of uint8 typed object parameters number x. 441 */ 442 #define Getuint8OparPtrs(blk,x) (SCSUINT8_COP *) GetOparPtrs(blk,x) 443 444 /** 445 \brief Get pointer of uint16 typed object parameters number x. 446 */ 447 #define Getuint16OparPtrs(blk,x) (SCSUINT16_COP *) GetOparPtrs(blk,x) 448 449 /** 450 \brief Get pointer of uint32 typed object parameters number x. 451 */ 452 #define Getuint32OparPtrs(blk,x) (SCSUINT32_COP *) GetOparPtrs(blk,x) 453 454 /** 455 \brief Get number of object state. 456 */ 457 #define GetNoz(blk) (blk->noz) 458 459 /** 460 \brief Get type of object state number x. 461 */ 462 #define GetOzType(blk,x) (assert((x)>0), assert((x)<=(blk)->noz), (blk)->oztyp[(x)-1]) 463 464 /** 465 \brief Get size of object state number x. 466 * GetOzSize(blk,x,1) : get first dimension of oz 467 * GetOzSize(blk,x,2) : get second dimension of oz 468 */ 469 #define GetOzSize(blk,x,y) (assert((x)>0), assert((x)<=(blk)->noz), \ 470 assert((y)>0), assert((y)<=2), (blk)->ozsz[((y)-1)*(blk)->noz+((x)-1)]) 471 472 /** 473 \brief Get pointer of object state number x. 474 */ 475 #define GetOzPtrs(blk,x) (assert((x)>0), assert((x)<=(blk)->noz), (blk)->ozptr[(x)-1]) 476 477 /** 478 \brief Get pointer of real object state number x. 479 */ 480 #define GetRealOzPtrs(blk,x) (SCSREAL_COP *) GetOzPtrs(blk,x) 481 482 /** 483 \brief Get pointer of imaginary part of object state number x. 484 */ 485 #define GetImagOzPtrs(blk,x) (assert((x)>0), assert((x)<=(blk)->noz), \ 486 (SCSREAL_COP *) ((SCSREAL_COP *)blk->ozptr[x-1]+ \ 487 ((blk->ozsz[x-1])*(blk->ozsz[blk->noz+(x-1)]))) 488 489 /** 490 \brief Get pointer of int8 typed object state number x. 491 */ 492 #define Getint8OzPtrs(blk,x) (SCSINT8_COP *) GetOzPtrs(blk,x) 493 494 /** 495 \brief Get pointer of int16 typed object state number x. 496 */ 497 #define Getint16OzPtrs(blk,x) (SCSINT16_COP *) GetOzPtrs(blk,x) 498 499 /** 500 \brief Get pointer of int32 typed object state number x. 501 */ 502 #define Getint32OzPtrs(blk,x) (SCSINT32_COP *) GetOzPtrs(blk,x) 503 504 /** 505 \brief Get pointer of uint8 typed object state number x. 506 */ 507 #define Getuint8OzPtrs(blk,x) (SCSUINT8_COP *) GetOzPtrs(blk,x) 508 509 /** 510 \brief Get pointer of uint16 typed object state number x. 511 */ 512 #define Getuint16OzPtrs(blk,x) (SCSUINT16_COP *) GetOzPtrs(blk,x) 513 514 /** 515 \brief Get pointer of uint32 typed object state number x. 516 */ 517 #define Getuint32OzPtrs(blk,x) (SCSUINT32_COP *) GetOzPtrs(blk,x) 518 519 /** 520 \brief Get the sizeof of the object state number x. 521 */ 522 #define GetSizeOfOz(blk,x) ((GetOzType(blk,x)==SCSREAL_N) ? (sizeof(SCSREAL_COP)) : \ 523 (GetOzType(blk,x)==SCSCOMPLEX_N) ? (2*sizeof(SCSCOMPLEX_COP)) : \ 524 ((GetOzType(blk,x)==SCSINT8_N)|(GetOzType(blk,x)==SCSUINT8_N)) ? (sizeof(SCSINT8_COP)) : \ 525 ((GetOzType(blk,x)==SCSINT16_N)|(GetOzType(blk,x)==SCSUINT16_N)) ? (sizeof(SCSINT16_COP)) : \ 526 ((GetOzType(blk,x)==SCSINT32_N)|(GetOzType(blk,x)==SCSUINT32_N)) ? (sizeof(SCSINT32_COP)) : 0) 527 528 /** 529 \brief Get the sizeof of the object parameters number x. 530 */ 531 #define GetSizeOfOpar(blk,x) ((GetOparType(blk,x)==SCSREAL_N) ? (sizeof(SCSREAL_COP)) : \ 532 (GetOparType(blk,x)==SCSCOMPLEX_N) ? (2*sizeof(SCSCOMPLEX_COP)) : \ 533 ((GetOparType(blk,x)==SCSINT8_N)|(GetOparType(blk,x)==SCSUINT8_N)) ? (sizeof(SCSINT8_COP)) : \ 534 ((GetOparType(blk,x)==SCSINT16_N)|(GetOparType(blk,x)==SCSUINT16_N)) ? (sizeof(SCSINT16_COP)) : \ 535 ((GetOparType(blk,x)==SCSINT32_N)|(GetOparType(blk,x)==SCSUINT32_N)) ? (sizeof(SCSINT32_COP)) : 0) 536 537 /** 538 \brief Get the sizeof of the regular output port number x. 539 */ 540 #define GetSizeOfOut(blk,x) ((GetOutType(blk,x)==SCSREAL_N) ? (sizeof(SCSREAL_COP)) : \ 541 (GetOutType(blk,x)==SCSCOMPLEX_N) ? (2*sizeof(SCSCOMPLEX_COP)) : \ 542 ((GetOutType(blk,x)==SCSINT8_N)|(GetOutType(blk,x)==SCSUINT8_N)) ? (sizeof(SCSINT8_COP)) : \ 543 ((GetOutType(blk,x)==SCSINT16_N)|(GetOutType(blk,x)==SCSUINT16_N)) ? (sizeof(SCSINT16_COP)) : \ 544 ((GetOutType(blk,x)==SCSINT32_N)|(GetOutType(blk,x)==SCSUINT32_N)) ? (sizeof(SCSINT32_COP)) : 0) 545 /** 546 \brief Get the sizeof of the regular input port number x. 547 */ 548 #define GetSizeOfIn(blk,x) ((GetInType(blk,x)==SCSREAL_N) ? (sizeof(SCSREAL_COP)) : \ 549 (GetInType(blk,x)==SCSCOMPLEX_N) ? (2*sizeof(SCSCOMPLEX_COP)) : \ 550 ((GetInType(blk,x)==SCSINT8_N)|(GetInType(blk,x)==SCSUINT8_N)) ? (sizeof(SCSINT8_COP)) : \ 551 ((GetInType(blk,x)==SCSINT16_N)|(GetInType(blk,x)==SCSUINT16_N)) ? (sizeof(SCSINT16_COP)) : \ 552 ((GetInType(blk,x)==SCSINT32_N)|(GetInType(blk,x)==SCSUINT32_N)) ? (sizeof(SCSINT32_COP)) : 0) 553 554 /** 555 \brief Get number of zero crossing surface. 556 */ 557 #define GetNg(blk) (blk->ng) 558 559 /** 560 \brief Get pointer of the zero crossing register. 561 */ 562 #define GetGPtrs(blk) (blk->g) 563 564 /** 565 \brief Get pointer of the direction of the zero crossing register. 566 */ 567 #define GetJrootPtrs(blk) (blk->jroot) 568 569 /** 570 \brief Get number of modes. 571 */ 572 #define GetNmode(blk) (blk->nmode) 573 574 /** 575 \brief Get pointer of the mode register. 576 */ 577 #define GetModePtrs(blk) (blk->mode) 578 579 /** 580 \brief Get pointer of the block label 581 */ 582 #define GetLabelPtrs(blk) (blk->label) 583 584 ///@} 585 586 #endif /* __SCICOS_BLOCK_H__ */ 587 588