Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-02-21 10:05:31 

0001 /*
0002  *  qp_exe_conv_case.h  --
0003  *
0004  *  Original: 23-Apr-1996 20:24
0005  *
0006  *  Author:   Maarten Ballintijn <Maarten.Ballintijn@cern.ch>
0007  *
0008  *  $Id$
0009  *
0010  *  $Log$
0011  *  Revision 1.4  1996/10/03 09:58:15  lecointe
0012  *  Force the value of the C boolean TRUE to 1 (was -1 on DEC)
0013  *
0014  *  Revision 1.3  1996/04/23 18:38:25  maartenb
0015  *  - Add RCS keywords
0016  *
0017  *
0018  */
0019 
0020 case FC_B_2_B: {
0021     int i, n = frame_size[framep];
0022     o1 = &stack[frame[framep]];
0023     if ( n == 1 ) {
0024         SET_FRAME_TYPE( D_BOOL );
0025             *((bool *) o1) = *((bool *) o1) ? 1 : 0;
0026     } else {
0027         NEW_FRAME( D_BOOL, n, r);
0028         for ( i=0 ; i < n ; i++ ) {
0029             ((bool *) r)[i] = ((bool *) o1)[i] ? 1 : 0;
0030         }
0031         SQUEEZE_FRAME(1);
0032     }
0033     break;
0034 }
0035 
0036 case FC_B_2_U: {
0037     int i, n = frame_size[framep];
0038     o1 = &stack[frame[framep]];
0039     if ( n == 1 ) {
0040         SET_FRAME_TYPE( D_UINT );
0041         *((UInt32 *) o1) = *((bool *) o1) ? 1 : 0;
0042     } else {
0043         NEW_FRAME( D_UINT, n, r);
0044         for ( i=0 ; i < n ; i++ ) {
0045             ((UInt32 *) r)[i] = ((bool *) o1)[i] ? 1 : 0;
0046         }
0047         SQUEEZE_FRAME(1);
0048     }
0049     break;
0050 }
0051 
0052 case FC_B_2_LU: {
0053     int i, n = frame_size[framep];
0054     o1 = &stack[frame[framep]];
0055     if ( n == 1 ) {
0056         SET_FRAME_TYPE( D_ULONG );
0057         *((UInt64 *) o1) = *((bool *) o1) ? 1 : 0;
0058     } else {
0059         NEW_FRAME( D_ULONG, n, r);
0060         for ( i=0 ; i < n ; i++ ) {
0061             ((UInt64 *) r)[i] = ((bool *) o1)[i] ? 1 : 0;
0062         }
0063         SQUEEZE_FRAME(1);
0064     }
0065     break;
0066 }
0067 
0068 case FC_B_2_I: {
0069     int i, n = frame_size[framep];
0070     o1 = &stack[frame[framep]];
0071     if ( n == 1 ) {
0072         SET_FRAME_TYPE( D_INT );
0073         *((Int32 *) o1) = *((bool *) o1) ? 1 : 0;
0074     } else {
0075         NEW_FRAME( D_INT, n, r);
0076         for ( i=0 ; i < n ; i++ ) {
0077             ((Int32 *) r)[i] = ((bool *) o1)[i] ? 1 : 0;
0078         }
0079         SQUEEZE_FRAME(1);
0080     }
0081     break;
0082 }
0083 
0084 case FC_B_2_LI: {
0085     int i, n = frame_size[framep];
0086     o1 = &stack[frame[framep]];
0087     if ( n == 1 ) {
0088         SET_FRAME_TYPE( D_LONG );
0089         *((Int64 *) o1) = *((bool *) o1) ? 1 : 0;
0090     } else {
0091         NEW_FRAME( D_LONG, n, r);
0092         for ( i=0 ; i < n ; i++ ) {
0093             ((Int64 *) r)[i] = ((bool *) o1)[i] ? 1 : 0;
0094         }
0095         SQUEEZE_FRAME(1);
0096     }
0097     break;
0098 }
0099 
0100 case FC_B_2_F: {
0101     int i, n = frame_size[framep];
0102     o1 = &stack[frame[framep]];
0103     if ( n == 1 ) {
0104         SET_FRAME_TYPE( D_FLOAT );
0105             *((Float32 *) o1) = *((bool *) o1) ? 1.0 : 0.0;
0106     } else {
0107         NEW_FRAME( D_FLOAT, n, r);
0108         for ( i=0 ; i < n ; i++ ) {
0109             ((Float32 *) r)[i] = ((bool *) o1)[i] ? 1.0 : 0.0;
0110         }
0111         SQUEEZE_FRAME(1);
0112     }
0113     break;
0114 }
0115 
0116 case FC_B_2_LF: {
0117     int i, n = frame_size[framep];
0118     o1 = &stack[frame[framep]];
0119     if ( n == 1 ) {
0120         SET_FRAME_TYPE( D_DOUBLE );
0121         *((Float64 *) o1) = *((bool *) o1) ? 1.0 : 0.0;
0122     } else {
0123         NEW_FRAME( D_DOUBLE, n, r);
0124         for ( i=0 ; i < n ; i++ ) {
0125             ((Float64 *) r)[i] = ((bool *) o1)[i] ? 1.0 : 0.0;
0126         }
0127         SQUEEZE_FRAME(1);
0128     }
0129     break;
0130 }
0131 
0132 case FC_U_2_B: {
0133     int i, n = frame_size[framep];
0134     o1 = &stack[frame[framep]];
0135     if ( n == 1 ) {
0136         SET_FRAME_TYPE( D_BOOL );
0137         *((bool *) o1) = *((UInt32 *) o1) ? 1 : 0;
0138     } else {
0139         NEW_FRAME( D_BOOL, n, r);
0140         for ( i=0 ; i < n ; i++ ) {
0141             ((bool *) r)[i] = ((UInt32 *) o1)[i] ? 1 : 0;
0142         }
0143         SQUEEZE_FRAME(1);
0144     }
0145     break;
0146 }
0147 
0148 case FC_U_2_U: {
0149     int i, n = frame_size[framep];
0150     o1 = &stack[frame[framep]];
0151     if ( n == 1 ) {
0152         SET_FRAME_TYPE( D_UINT );
0153         *((UInt32 *) o1) = *((UInt32 *) o1);
0154     } else {
0155         NEW_FRAME( D_UINT, n, r);
0156         for ( i=0 ; i < n ; i++ ) {
0157             ((UInt32 *) r)[i] = ((UInt32 *) o1)[i];
0158         }
0159         SQUEEZE_FRAME(1);
0160     }
0161     break;
0162 }
0163 
0164 case FC_U_2_LU: {
0165     int i, n = frame_size[framep];
0166     o1 = &stack[frame[framep]];
0167     if ( n == 1 ) {
0168         SET_FRAME_TYPE( D_ULONG );
0169         *((UInt64 *) o1) = *((UInt32 *) o1);
0170     } else {
0171         NEW_FRAME( D_ULONG, n, r);
0172         for ( i=0 ; i < n ; i++ ) {
0173             ((UInt64 *) r)[i] = ((UInt32 *) o1)[i];
0174         }
0175         SQUEEZE_FRAME(1);
0176     }
0177     break;
0178 }
0179 
0180 case FC_U_2_I: {
0181     int i, n = frame_size[framep];
0182     o1 = &stack[frame[framep]];
0183     if ( n == 1 ) {
0184         SET_FRAME_TYPE( D_INT );
0185         *((Int32 *) o1) = *((UInt32 *) o1);
0186     } else {
0187         NEW_FRAME( D_INT, n, r);
0188         for ( i=0 ; i < n ; i++ ) {
0189             ((Int32 *) r)[i] = ((UInt32 *) o1)[i];
0190         }
0191         SQUEEZE_FRAME(1);
0192     }
0193     break;
0194 }
0195 
0196 case FC_U_2_LI: {
0197     int i, n = frame_size[framep];
0198     o1 = &stack[frame[framep]];
0199     if ( n == 1 ) {
0200         SET_FRAME_TYPE( D_LONG );
0201         *((Int64 *) o1) = *((UInt32 *) o1);
0202     } else {
0203         NEW_FRAME( D_LONG, n, r);
0204         for ( i=0 ; i < n ; i++ ) {
0205             ((Int64 *) r)[i] = ((UInt32 *) o1)[i];
0206         }
0207         SQUEEZE_FRAME(1);
0208     }
0209     break;
0210 }
0211 
0212 case FC_U_2_F: {
0213     int i, n = frame_size[framep];
0214     o1 = &stack[frame[framep]];
0215     if ( n == 1 ) {
0216         SET_FRAME_TYPE( D_FLOAT );
0217         *((Float32 *) o1) = *((UInt32 *) o1);
0218     } else {
0219         NEW_FRAME( D_FLOAT, n, r);
0220         for ( i=0 ; i < n ; i++ ) {
0221             ((Float32 *) r)[i] = ((UInt32 *) o1)[i];
0222         }
0223         SQUEEZE_FRAME(1);
0224     }
0225     break;
0226 }
0227 
0228 case FC_U_2_LF: {
0229     int i, n = frame_size[framep];
0230     o1 = &stack[frame[framep]];
0231     if ( n == 1 ) {
0232         SET_FRAME_TYPE( D_DOUBLE );
0233         *((Float64 *) o1) = *((UInt32 *) o1);
0234     } else {
0235         NEW_FRAME( D_DOUBLE, n, r);
0236         for ( i=0 ; i < n ; i++ ) {
0237             ((Float64 *) r)[i] = ((UInt32 *) o1)[i];
0238         }
0239         SQUEEZE_FRAME(1);
0240     }
0241     break;
0242 }
0243 
0244 case FC_LU_2_B: {
0245     int i, n = frame_size[framep];
0246     o1 = &stack[frame[framep]];
0247     if ( n == 1 ) {
0248         SET_FRAME_TYPE( D_BOOL );
0249         *((bool *) o1) = *((UInt64 *) o1) ? 1 : 0;
0250     } else {
0251         NEW_FRAME( D_BOOL, n, r);
0252         for ( i=0 ; i < n ; i++ ) {
0253             ((bool *) r)[i] = ((UInt64 *) o1)[i] ? 1 : 0;
0254         }
0255         SQUEEZE_FRAME(1);
0256     }
0257     break;
0258 }
0259 
0260 case FC_LU_2_U: {
0261     int i, n = frame_size[framep];
0262     o1 = &stack[frame[framep]];
0263     if ( n == 1 ) {
0264         SET_FRAME_TYPE( D_UINT );
0265         *((UInt32 *) o1) = *((UInt64 *) o1);
0266     } else {
0267         NEW_FRAME( D_UINT, n, r);
0268         for ( i=0 ; i < n ; i++ ) {
0269             ((UInt32 *) r)[i] = ((UInt64 *) o1)[i];
0270         }
0271         SQUEEZE_FRAME(1);
0272     }
0273     break;
0274 }
0275 
0276 case FC_LU_2_LU: {
0277     int i, n = frame_size[framep];
0278     o1 = &stack[frame[framep]];
0279     if ( n == 1 ) {
0280         SET_FRAME_TYPE( D_ULONG );
0281         *((UInt64 *) o1) = *((UInt64 *) o1);
0282     } else {
0283         NEW_FRAME( D_ULONG, n, r);
0284         for ( i=0 ; i < n ; i++ ) {
0285             ((UInt64 *) r)[i] = ((UInt64 *) o1)[i];
0286         }
0287         SQUEEZE_FRAME(1);
0288     }
0289     break;
0290 }
0291 
0292 case FC_LU_2_I: {
0293     int i, n = frame_size[framep];
0294     o1 = &stack[frame[framep]];
0295     if ( n == 1 ) {
0296         SET_FRAME_TYPE( D_INT );
0297         *((Int32 *) o1) = *((UInt64 *) o1);
0298     } else {
0299         NEW_FRAME( D_INT, n, r);
0300         for ( i=0 ; i < n ; i++ ) {
0301             ((Int32 *) r)[i] = ((UInt64 *) o1)[i];
0302         }
0303         SQUEEZE_FRAME(1);
0304     }
0305     break;
0306 }
0307 
0308 case FC_LU_2_LI: {
0309     int i, n = frame_size[framep];
0310     o1 = &stack[frame[framep]];
0311     if ( n == 1 ) {
0312         SET_FRAME_TYPE( D_LONG );
0313         *((Int64 *) o1) = *((UInt64 *) o1);
0314     } else {
0315         NEW_FRAME( D_LONG, n, r);
0316         for ( i=0 ; i < n ; i++ ) {
0317             ((Int64 *) r)[i] = ((UInt64 *) o1)[i];
0318         }
0319         SQUEEZE_FRAME(1);
0320     }
0321     break;
0322 }
0323 
0324 case FC_LU_2_F: {
0325     int i, n = frame_size[framep];
0326     o1 = &stack[frame[framep]];
0327     if ( n == 1 ) {
0328         SET_FRAME_TYPE( D_FLOAT );
0329         *((Float32 *) o1) = *((UInt64 *) o1);
0330     } else {
0331         NEW_FRAME( D_FLOAT, n, r);
0332         for ( i=0 ; i < n ; i++ ) {
0333             ((Float32 *) r)[i] = ((UInt64 *) o1)[i];
0334         }
0335         SQUEEZE_FRAME(1);
0336     }
0337     break;
0338 }
0339 
0340 case FC_LU_2_LF: {
0341     int i, n = frame_size[framep];
0342     o1 = &stack[frame[framep]];
0343     if ( n == 1 ) {
0344         SET_FRAME_TYPE( D_DOUBLE );
0345         *((Float64 *) o1) = *((UInt64 *) o1);
0346     } else {
0347         NEW_FRAME( D_DOUBLE, n, r);
0348         for ( i=0 ; i < n ; i++ ) {
0349             ((Float64 *) r)[i] = ((UInt64 *) o1)[i];
0350         }
0351         SQUEEZE_FRAME(1);
0352     }
0353     break;
0354 }
0355 
0356 /*
0357  *  #if 0
0358  */
0359 case FC_I_2_B: {
0360     int i, n = frame_size[framep];
0361     o1 = &stack[frame[framep]];
0362     if ( n == 1 ) {
0363         SET_FRAME_TYPE( D_BOOL );
0364         *((bool *) o1) = *((Int32 *) o1) ? 1 : 0;
0365     } else {
0366         NEW_FRAME( D_BOOL, n, r);
0367         for ( i=0 ; i < n ; i++ ) {
0368             ((bool *) r)[i] = ((Int32 *) o1)[i] ? 1 : 0;
0369         }
0370         SQUEEZE_FRAME(1);
0371     }
0372     break;
0373 }
0374 
0375 case FC_I_2_U: {
0376     int i, n = frame_size[framep];
0377     o1 = &stack[frame[framep]];
0378     if ( n == 1 ) {
0379         SET_FRAME_TYPE( D_UINT );
0380         *((UInt32 *) o1) = *((Int32 *) o1) ? 1 : 0;
0381     } else {
0382         NEW_FRAME( D_UINT, n, r);
0383         for ( i=0 ; i < n ; i++ ) {
0384             ((UInt32 *) r)[i] = ((Int32 *) o1)[i] ? 1 : 0;
0385         }
0386         SQUEEZE_FRAME(1);
0387     }
0388     break;
0389 }
0390 
0391 case FC_I_2_LU: {
0392     int i, n = frame_size[framep];
0393     o1 = &stack[frame[framep]];
0394     if ( n == 1 ) {
0395         SET_FRAME_TYPE( D_ULONG );
0396         *((UInt64 *) o1) = *((Int32 *) o1);
0397     } else {
0398         NEW_FRAME( D_ULONG, n, r);
0399         for ( i=0 ; i < n ; i++ ) {
0400             ((UInt64 *) r)[i] = ((Int32 *) o1)[i];
0401         }
0402         SQUEEZE_FRAME(1);
0403     }
0404     break;
0405 }
0406 
0407 case FC_I_2_I: {
0408     int i, n = frame_size[framep];
0409     o1 = &stack[frame[framep]];
0410     if ( n == 1 ) {
0411         SET_FRAME_TYPE( D_INT );
0412         *((Int32 *) o1) = *((Int32 *) o1);
0413     } else {
0414         NEW_FRAME( D_INT, n, r);
0415         for ( i=0 ; i < n ; i++ ) {
0416             ((Int32 *) r)[i] = ((Int32 *) o1)[i];
0417         }
0418         SQUEEZE_FRAME(1);
0419     }
0420     break;
0421 }
0422 
0423 case FC_I_2_LI: {
0424     int i, n = frame_size[framep];
0425     o1 = &stack[frame[framep]];
0426     if ( n == 1 ) {
0427         SET_FRAME_TYPE( D_LONG );
0428         *((Int64 *) o1) = *((Int32 *) o1);
0429     } else {
0430         NEW_FRAME( D_LONG, n, r);
0431         for ( i=0 ; i < n ; i++ ) {
0432             ((Int64 *) r)[i] = ((Int32 *) o1)[i];
0433         }
0434         SQUEEZE_FRAME(1);
0435     }
0436     break;
0437 }
0438 
0439 case FC_I_2_F: {
0440     int i, n = frame_size[framep];
0441     o1 = &stack[frame[framep]];
0442     if ( n == 1 ) {
0443         SET_FRAME_TYPE( D_FLOAT );
0444         *((Float32 *) o1) = *((Int32 *) o1);
0445     } else {
0446         NEW_FRAME( D_FLOAT, n, r);
0447         for ( i=0 ; i < n ; i++ ) {
0448             ((Float32 *) r)[i] = ((Int32 *) o1)[i];
0449         }
0450         SQUEEZE_FRAME(1);
0451     }
0452     break;
0453 }
0454 
0455 case FC_I_2_LF: {
0456     int i, n = frame_size[framep];
0457     o1 = &stack[frame[framep]];
0458     if ( n == 1 ) {
0459         SET_FRAME_TYPE( D_DOUBLE );
0460         *((Float64 *) o1) = *((Int32 *) o1);
0461     } else {
0462         NEW_FRAME( D_DOUBLE, n, r);
0463         for ( i=0 ; i < n ; i++ ) {
0464             ((Float64 *) r)[i] = ((Int32 *) o1)[i];
0465         }
0466         SQUEEZE_FRAME(1);
0467     }
0468     break;
0469 }
0470 
0471 case FC_LI_2_B: {
0472     int i, n = frame_size[framep];
0473     o1 = &stack[frame[framep]];
0474     if ( n == 1 ) {
0475         SET_FRAME_TYPE( D_BOOL );
0476         *((bool *) o1) = *((Int64 *) o1) ? 1 : 0;
0477     } else {
0478         NEW_FRAME( D_BOOL, n, r);
0479         for ( i=0 ; i < n ; i++ ) {
0480             ((bool *) r)[i] = ((Int64 *) o1)[i] ? 1 : 0;
0481         }
0482         SQUEEZE_FRAME(1);
0483     }
0484     break;
0485 }
0486 
0487 case FC_LI_2_U: {
0488     int i, n = frame_size[framep];
0489     o1 = &stack[frame[framep]];
0490     if ( n == 1 ) {
0491         SET_FRAME_TYPE( D_UINT );
0492         *((UInt32 *) o1) = *((Int64 *) o1);
0493     } else {
0494         NEW_FRAME( D_UINT, n, r);
0495         for ( i=0 ; i < n ; i++ ) {
0496             ((UInt32 *) r)[i] = ((Int64 *) o1)[i];
0497         }
0498         SQUEEZE_FRAME(1);
0499     }
0500     break;
0501 }
0502 
0503 case FC_LI_2_LU: {
0504     int i, n = frame_size[framep];
0505     o1 = &stack[frame[framep]];
0506     if ( n == 1 ) {
0507         SET_FRAME_TYPE( D_ULONG );
0508         *((UInt64 *) o1) = *((Int64 *) o1);
0509     } else {
0510         NEW_FRAME( D_ULONG, n, r);
0511         for ( i=0 ; i < n ; i++ ) {
0512             ((UInt64 *) r)[i] = ((Int64 *) o1)[i];
0513         }
0514         SQUEEZE_FRAME(1);
0515     }
0516     break;
0517 }
0518 
0519 case FC_LI_2_I: {
0520     int i, n = frame_size[framep];
0521     o1 = &stack[frame[framep]];
0522     if ( n == 1 ) {
0523         SET_FRAME_TYPE( D_INT );
0524         *((Int32 *) o1) = *((Int64 *) o1);
0525     } else {
0526         NEW_FRAME( D_INT, n, r);
0527         for ( i=0 ; i < n ; i++ ) {
0528             ((Int32 *) r)[i] = ((Int64 *) o1)[i];
0529         }
0530         SQUEEZE_FRAME(1);
0531     }
0532     break;
0533 }
0534 
0535 case FC_LI_2_LI: {
0536     int i, n = frame_size[framep];
0537     o1 = &stack[frame[framep]];
0538     if ( n == 1 ) {
0539         SET_FRAME_TYPE( D_LONG );
0540         *((Int64 *) o1) = *((Int64 *) o1);
0541     } else {
0542         NEW_FRAME( D_LONG, n, r);
0543         for ( i=0 ; i < n ; i++ ) {
0544             ((Int64 *) r)[i] = ((Int64 *) o1)[i];
0545         }
0546         SQUEEZE_FRAME(1);
0547     }
0548     break;
0549 }
0550 
0551 case FC_LI_2_F: {
0552     int i, n = frame_size[framep];
0553     o1 = &stack[frame[framep]];
0554     if ( n == 1 ) {
0555         SET_FRAME_TYPE( D_FLOAT );
0556         *((Float32 *) o1) = *((Int64 *) o1);
0557     } else {
0558         NEW_FRAME( D_FLOAT, n, r);
0559         for ( i=0 ; i < n ; i++ ) {
0560             ((Float32 *) r)[i] = ((Int64 *) o1)[i];
0561         }
0562         SQUEEZE_FRAME(1);
0563     }
0564     break;
0565 }
0566 
0567 case FC_LI_2_LF: {
0568     int i, n = frame_size[framep];
0569     o1 = &stack[frame[framep]];
0570     if ( n == 1 ) {
0571         SET_FRAME_TYPE( D_DOUBLE );
0572         *((Float64 *) o1) = *((Int64 *) o1);
0573     } else {
0574         NEW_FRAME( D_DOUBLE, n, r);
0575         for ( i=0 ; i < n ; i++ ) {
0576             ((Float64 *) r)[i] = ((Int64 *) o1)[i];
0577         }
0578         SQUEEZE_FRAME(1);
0579     }
0580     break;
0581 }
0582 
0583 case FC_F_2_B: {
0584     int i, n = frame_size[framep];
0585     o1 = &stack[frame[framep]];
0586     if ( n == 1 ) {
0587         SET_FRAME_TYPE( D_BOOL );
0588         *((bool *) o1) = *((Float32 *) o1) ? 1 : 0;
0589     } else {
0590         NEW_FRAME( D_BOOL, n, r);
0591         for ( i=0 ; i < n ; i++ ) {
0592             ((bool *) r)[i] = ((Float32 *) o1)[i] ? 1 : 0;
0593         }
0594         SQUEEZE_FRAME(1);
0595     }
0596     break;
0597 }
0598 
0599 case FC_F_2_U: {
0600     int i, n = frame_size[framep];
0601     o1 = &stack[frame[framep]];
0602     if ( n == 1 ) {
0603         SET_FRAME_TYPE( D_UINT );
0604         *((UInt32 *) o1) = *((Float32 *) o1);
0605     } else {
0606         NEW_FRAME( D_UINT, n, r);
0607         for ( i=0 ; i < n ; i++ ) {
0608             ((UInt32 *) r)[i] = ((Float32 *) o1)[i];
0609         }
0610         SQUEEZE_FRAME(1);
0611     }
0612     break;
0613 }
0614 
0615 case FC_F_2_LU: {
0616     int i, n = frame_size[framep];
0617     o1 = &stack[frame[framep]];
0618     if ( n == 1 ) {
0619         SET_FRAME_TYPE( D_ULONG );
0620         *((UInt64 *) o1) = *((Float32 *) o1);
0621     } else {
0622         NEW_FRAME( D_ULONG, n, r);
0623         for ( i=0 ; i < n ; i++ ) {
0624             ((UInt64 *) r)[i] = ((Float32 *) o1)[i];
0625         }
0626         SQUEEZE_FRAME(1);
0627     }
0628     break;
0629 }
0630 
0631 case FC_F_2_I: {
0632     int i, n = frame_size[framep];
0633     o1 = &stack[frame[framep]];
0634     if ( n == 1 ) {
0635         SET_FRAME_TYPE( D_INT );
0636         *((Int32 *) o1) = *((Float32 *) o1);
0637     } else {
0638         NEW_FRAME( D_INT, n, r);
0639         for ( i=0 ; i < n ; i++ ) {
0640             ((Int32 *) r)[i] = ((Float32 *) o1)[i];
0641         }
0642         SQUEEZE_FRAME(1);
0643     }
0644     break;
0645 }
0646 
0647 case FC_F_2_LI: {
0648     int i, n = frame_size[framep];
0649     o1 = &stack[frame[framep]];
0650     if ( n == 1 ) {
0651         SET_FRAME_TYPE( D_LONG );
0652         *((Int64 *) o1) = *((Float32 *) o1);
0653     } else {
0654         NEW_FRAME( D_LONG, n, r);
0655         for ( i=0 ; i < n ; i++ ) {
0656             ((Int64 *) r)[i] = ((Float32 *) o1)[i];
0657         }
0658         SQUEEZE_FRAME(1);
0659     }
0660     break;
0661 }
0662 
0663 case FC_F_2_F: {
0664     int i, n = frame_size[framep];
0665     o1 = &stack[frame[framep]];
0666     if ( n == 1 ) {
0667         SET_FRAME_TYPE( D_FLOAT );
0668         *((Float32 *) o1) = *((Float32 *) o1);
0669     } else {
0670         NEW_FRAME( D_FLOAT, n, r);
0671         for ( i=0 ; i < n ; i++ ) {
0672             ((Float32 *) r)[i] = ((Float32 *) o1)[i];
0673         }
0674         SQUEEZE_FRAME(1);
0675     }
0676     break;
0677 }
0678 
0679 case FC_F_2_LF: {
0680     int i, n = frame_size[framep];
0681     o1 = &stack[frame[framep]];
0682     if ( n == 1 ) {
0683         SET_FRAME_TYPE( D_DOUBLE );
0684         *((Float64 *) o1) = *((Float32 *) o1);
0685     } else {
0686         NEW_FRAME( D_DOUBLE, n, r);
0687         for ( i=0 ; i < n ; i++ ) {
0688             ((Float64 *) r)[i] = ((Float32 *) o1)[i];
0689         }
0690         SQUEEZE_FRAME(1);
0691     }
0692     break;
0693 }
0694 
0695 case FC_LF_2_B: {
0696     int i, n = frame_size[framep];
0697     o1 = &stack[frame[framep]];
0698     if ( n == 1 ) {
0699         SET_FRAME_TYPE( D_BOOL );
0700         *((bool *) o1) = *((Float64 *) o1) ? 1 : 0;
0701     } else {
0702         NEW_FRAME( D_BOOL, n, r);
0703         for ( i=0 ; i < n ; i++ ) {
0704             ((bool *) r)[i] = ((Float64 *) o1)[i] ? 1 : 0;
0705         }
0706         SQUEEZE_FRAME(1);
0707     }
0708     break;
0709 }
0710 
0711 case FC_LF_2_U: {
0712     int i, n = frame_size[framep];
0713     o1 = &stack[frame[framep]];
0714     if ( n == 1 ) {
0715         SET_FRAME_TYPE( D_UINT );
0716         *((UInt32 *) o1) = *((Float64 *) o1);
0717     } else {
0718         NEW_FRAME( D_UINT, n, r);
0719         for ( i=0 ; i < n ; i++ ) {
0720             ((UInt32 *) r)[i] = ((Float64 *) o1)[i];
0721         }
0722         SQUEEZE_FRAME(1);
0723     }
0724     break;
0725 }
0726 
0727 case FC_LF_2_LU: {
0728     int i, n = frame_size[framep];
0729     o1 = &stack[frame[framep]];
0730     if ( n == 1 ) {
0731         SET_FRAME_TYPE( D_ULONG );
0732         *((UInt64 *) o1) = *((Float64 *) o1);
0733     } else {
0734         NEW_FRAME( D_ULONG, n, r);
0735         for ( i=0 ; i < n ; i++ ) {
0736             ((UInt64 *) r)[i] = ((Float64 *) o1)[i];
0737         }
0738         SQUEEZE_FRAME(1);
0739     }
0740     break;
0741 }
0742 
0743 case FC_LF_2_I: {
0744     int i, n = frame_size[framep];
0745     o1 = &stack[frame[framep]];
0746     if ( n == 1 ) {
0747         SET_FRAME_TYPE( D_INT );
0748         *((Int32 *) o1) = *((Float64 *) o1);
0749     } else {
0750         NEW_FRAME( D_INT, n, r);
0751         for ( i=0 ; i < n ; i++ ) {
0752             ((Int32 *) r)[i] = ((Float64 *) o1)[i];
0753         }
0754         SQUEEZE_FRAME(1);
0755     }
0756     break;
0757 }
0758 
0759 case FC_LF_2_LI: {
0760     int i, n = frame_size[framep];
0761     o1 = &stack[frame[framep]];
0762     if ( n == 1 ) {
0763         SET_FRAME_TYPE( D_LONG );
0764         *((Int64 *) o1) = *((Float64 *) o1);
0765     } else {
0766         NEW_FRAME( D_LONG, n, r);
0767         for ( i=0 ; i < n ; i++ ) {
0768             ((Int64 *) r)[i] = ((Float64 *) o1)[i];
0769         }
0770         SQUEEZE_FRAME(1);
0771     }
0772     break;
0773 }
0774 
0775 case FC_LF_2_F: {
0776     int i, n = frame_size[framep];
0777     o1 = &stack[frame[framep]];
0778     if ( n == 1 ) {
0779         SET_FRAME_TYPE( D_FLOAT );
0780         *((Float32 *) o1) = *((Float64 *) o1);
0781     } else {
0782         NEW_FRAME( D_FLOAT, n, r);
0783         for ( i=0 ; i < n ; i++ ) {
0784             ((Float32 *) r)[i] = ((Float64 *) o1)[i];
0785         }
0786         SQUEEZE_FRAME(1);
0787     }
0788     break;
0789 }
0790 
0791 case FC_LF_2_LF: {
0792     int i, n = frame_size[framep];
0793     o1 = &stack[frame[framep]];
0794     if ( n == 1 ) {
0795         SET_FRAME_TYPE( D_DOUBLE );
0796         *((Float64 *) o1) = *((Float64 *) o1);
0797     } else {
0798         NEW_FRAME( D_DOUBLE, n, r);
0799         for ( i=0 ; i < n ; i++ ) {
0800             ((Float64 *) r)[i] = ((Float64 *) o1)[i];
0801         }
0802         SQUEEZE_FRAME(1);
0803     }
0804     break;
0805 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!