include/ntuple/qp_exe_flow.h

0001 /*
0002  *  qp_exe_flow.h  --
0003  *  Interpreter switch for the flow control intructions
0004  *
0005  *  Original:  9-Jan-1995 16:23
0006  *
0007  *  Author:   Maarten Ballintijn <Maarten.Ballintijn@cern.ch>
0008  *
0009  *  $Id$
0010  *
0011  *  $Log$
0012  *  Revision 1.10  1996/04/23 18:38:28  maartenb
0013  *  - Add RCS keywords
0014  *
0015  *
0016  */
0017
0018 {
0019     switch ( fc ) {
0020     case FC_NOP:
0021             break;
0022
0023     case FC_HALT:
0024             /* keep in sync with FC_HALT_BIT in qp_execute.c */
0025             /* tricky, because we might have to pop several frames */
0026             while ( opc & FC_HALT_BIT ) {
0027                 if ( cut_call_sp > 0 ) {
0028                     int size, i;
0029                     bool    shape_pop;
0030
0031                     i = cut_index_stack[--cut_call_sp];
0032                     opc = cut_opc_stack[cut_call_sp];
0033                     pc = cut_call_stack[cut_call_sp];
0034
0035                     size = frame_size[framep];
0036                     cut_size[i] = size;
0037                     cut_bsize[i] = 4 * size *
0038                         datatype_size[cut_type[i]];
0039                     memcpy( cut_value[i], stack+frame[framep],
0040                         cut_bsize[i] );
0041                     cut_valid[i] = TRUE;
0042                     if ( cut_has_shape[i] && ((opc & FC_DYNAMIC_INFO_BIT) == 0) ){
0043                         SHAPE_POP( 1 );
0044                     }
0045                 } else {
0046                     /* ready with main segment */
0047                     running = FALSE;
0048                     break;
0049                 }
0050             }
0051             break;
0052
0053     case FC_JUMP:
0054         {
0055             int     offset;
0056
0057             offset = *pc++;
0058             pc += offset;
0059             break;
0060         }
0061
0062     case FC_POP_JUMP:   /* pop on true, jump on false */
0063         {
0064             Int32       *ptr;
0065             int     offset;
0066
0067             offset = *pc++;
0068             ptr =  stack + frame[framep];
0069             qp_assert( frame_size[framep] == 1 );
0070             if ( *ptr != 0 ) {
0071                 POP_FRAME(1);
0072             } else {
0073                 pc += offset;
0074             }
0075             break;
0076         }
0077
0078     case FC_JUMP_POP:   /* pop on false, jump on true */
0079         {
0080             Int32       *ptr;
0081             int     offset;
0082
0083             offset = *pc++;
0084             ptr =  stack + frame[framep];
0085             qp_assert( frame_size[framep] == 1 );
0086             if ( *ptr == 0 ) {
0087                 POP_FRAME(1);
0088             } else {
0089                 pc += offset;
0090             }
0091             break;
0092         }
0093
0094     case FC_CUT:
0095         {
0096             register int    idx = *pc++;
0097             void    *p;
0098
0099             if ( cut_valid[idx] ) {
0100                 NEW_FRAME( cut_type[idx], cut_size[idx], p );
0101                 memcpy( p, cut_value[idx], cut_bsize[idx] );
0102             } else {
0103                 cut_index_stack[cut_call_sp] = idx;
0104                 cut_opc_stack[cut_call_sp] = opc;
0105                 cut_call_stack[cut_call_sp++] = pc;
0106                 pc = cut_segment[idx];
0107                 opc = 0; /* flush, to avoid early termination */
0108             }
0109             break;
0110         }
0111
0112     case FC_GCUT_1D:
0113     {
0114         bool        *r;
0115         Float32     *o1, low, high;
0116         register int    i, n;
0117         int     cid = stack[frame[framep]];
0118
0119         n = frame_size[framep-1];
0120         o1 = (Float32 *) &stack[frame[framep-1]];
0121
0122         low = cut_data[cid]->points[0][0];
0123         high = cut_data[cid]->points[1][0];
0124
0125         POP_FRAME(2);
0126
0127         NEW_FRAME(D_BOOL,n,r);
0128
0129         o1 += n - 1;
0130         r += n - 1;
0131         for ( i=0 ; i < n ; i++ ) {
0132             if ( low <= *o1 && *o1 < high ) {
0133                 *r = TRUE;
0134             } else {
0135                 *r = FALSE;
0136             }
0137             o1 -= 1;
0138             r -= 1;
0139         }
0140         break;
0141     }
0142
0143     case FC_GCUT_2D:
0144     {
0145         register bool       *r;
0146         register Float32    *o1, *o2;
0147         Float32         tmp1, tmp2;
0148         int         i, n = 1, inc_o1, inc_o2;
0149         int         cid = stack[frame[framep]];
0150
0151         if ( frame_size[framep-1] != 1 ) {
0152             o1 = (Float32 *)&stack[frame[framep-1]];
0153             inc_o1 = 1;
0154             n = frame_size[framep-1];
0155         } else {
0156             tmp1 = *((Float32 *) &stack[frame[framep-1]]);
0157             o1 = (Float32 *) &tmp1;
0158             inc_o1 = 0;
0159         }
0160
0161         if ( frame_size[framep-2] != 1 ) {
0162             o2 = (Float32 *)&stack[frame[framep-2]];
0163             inc_o2 = 1;
0164             qp_assert( n==1 || n==frame_size[framep-2] );
0165             n = frame_size[framep-2];
0166         } else {
0167             tmp2 = *((Float32 *) &stack[frame[framep-2]]);
0168             o2 = (Float32 *) &tmp2;
0169             inc_o2 = 0;
0170         }
0171         POP_FRAME(3);
0172
0173         NEW_FRAME(D_BOOL,n,r);
0174
0175         o1 += inc_o1 * (n-1);
0176         o2 += inc_o2 * (n-1);
0177         r += (n-1);
0178         for ( i=0 ; i < n ; i++ ) {
0179             *r = polygon_sel( cid, *o2, *o1 );
0180             o1 -= inc_o1;
0181             o2 -= inc_o2;
0182             r -= 1;
0183         }
0184         break;
0185     }
0186
0187     case FC_DUMP:   /* dump current stack frame */
0188         {
0189             Int32       *ptr;
0190             DataType    dt = ( opc>>13 ) & 0xF ;
0191             int     size, i;
0192
0193             if ( framep <= 0 ) {
0194                 printf( "DUMP: no frame ??? (framep = %d)\n",
0195                     framep );
0196                 break;
0197             }
0198
0199             if ( ! exe_verbose ) {
0200                 break;
0201             }
0202
0203             ptr =  stack + frame[framep];
0204             size = frame_size[framep];
0205             if ( dt != frame_type[framep] ) {
0206                 sf_report( "Warning: FC_DUMP - stack has %s"
0207                     "i.s.o %s\n",
0208                     datatype_to_str( frame_type[framep] ),
0209                     datatype_to_str( dt ) );
0210             }
0211
0212             printf( "DUMP: frame %d size %d type %s\n",
0213                 framep, size, datatype_to_str( dt ) );
0214
0215             for ( i=0; i < size ; i++ )
0216             switch ( dt ) { /* switch DataType */
0217             case D_UNDEF:
0218                     printf( "D_UNDEF\n" );
0219                     break;
0220             case D_BOOL:
0221                     printf( "%s\n", ptr[i] == 0 ?
0222                          ".false." : ".true." );
0223                     break;
0224             case D_UINT:
0225                     printf( "z'%x'\n", ptr[i] );
0226                     break;
0227             case D_ULONG:
0228                     sf_report( "FC_DUMP: D_ULONG not "
0229                             "supported\n" );
0230                     break;
0231             case D_INT:
0232                     printf( "%d\n", ptr[i] );
0233                     break;
0234             case D_LONG:
0235                     sf_report( "FC_DUMP: D_LONG not "
0236                             "supported\n" );
0237                     break;
0238             case D_FLOAT:
0239                     {
0240                         char    b[32];
0241                         Float32 f = ((float*)ptr)[i];
0242
0243                         sprintf( b, "%g", f );
0244                         if ( ! strchr( b, '.' ) )
0245                             strcat( b, "." );
0246                         strcat( b, "\n" );
0247                         fputs( b, stdout );
0248                     }
0249                     break;
0250             case D_DOUBLE:
0251                     {
0252                         char    b[32], *p;
0253                         Float64 d = ((double*)ptr)[i];
0254
0255                         sprintf( b, "%lg", d );
0256                         if ( ! strchr( b, '.' ) )
0257                             strcat( b, "." );
0258                         p = strchr( b, 'e' );
0259                         if ( p == 0 ) {
0260                             strcat( b, "d0" );
0261                         } else {
0262                             *p = 'd';
0263                         }
0264                         strcat( b, "\n" );
0265                         fputs( b, stdout );
0266                     }
0267                     break;
0268             case D_STR:
0269                     printf( "'%*.*s'\n", QP_STR_MAX,
0270                         QP_STR_MAX, (char *)&ptr[i*8] );
0271                     break;
0272             default:
0273                 sf_report( "qp_exe_flow.h: FC_DUMP: "
0274                     "unkown DataType (%d)\n", dt );
0275                 *errp = R_INTERNAL_ERROR;
0276                 running = FALSE;
0277                 break;
0278             }
0279
0280             if ( (opc & FC_DYNAMIC_INFO_BIT) != 0 ) {
0281                 int  i, n = shape_sp->ndim;
0282
0283                 fputs( "\t\tshape=(", stdout );
0284                 for ( i = 0 ; i < n ; i++ ) {
0285                     if ( i > 0 ) fputc( ',', stdout );
0286                     fprintf( stdout, "%d", shape_sp->range[i] );
0287                 }
0288                 fputs( ")\n", stdout );
0289             }
0290         }
0291         break;
0292
0293     case FC_CHECK_SHAPE:
0294         {
0295             bool        ok;
0296
0297             SHAPE_LOAD(pc);
0298             SHAPE_CHECK_N( 2, ok );
0299             if ( ! ok ) {
0300                 sf_report( "Evt %ld: Shapes of the expressions do "
0301                     "not match.\n", ievt );
0302                 running = FALSE;
0303                 *errp = R_SHAPE_ERROR;
0304                 break;  /* skip the event */
0305             }
0306             SHAPE_POP(2);
0307         }
0308         break;
0309
0310     default:
0311         sf_report( "qp_exe_flow.h: Unkown Fcode ( %d )\n", fc );
0312         *errp = R_INTERNAL_ERROR;
0313         running = FALSE;
0314         break;
0315     }
0316 }