自学教程：C++ CGInteger函数代码示例

static  void    Equivalent( cg_op op_code ) {//===========================================    cg_name     op1;    cg_name     op2;    unsigned_16 typ_info;    cg_type     typ1;    cg_type     typ2;    typ_info = GetU16();    typ1 = GetType1( typ_info );    typ2 = GetType2( typ_info );    op1 = XPopValue( typ1 );    op2 = XPopValue( typ2 );    typ1 = CGType( op1 );    if( typ1 != TY_BOOLEAN ) {        op1 = CGCompare( O_NE, op1, CGInteger( 0, typ1 ), typ1 );    }    typ2 = CGType( op2 );    if( typ2 != TY_BOOLEAN ) {        op2 = CGCompare( O_NE, op2, CGInteger( 0, typ2 ), typ2 );    }    XPush( CGCompare( op_code, op1, op2, TY_UINT_1 ) );}

void    FCAdvFillHi( void ) {//=====================// Fill hi bound of a dimension (actually computes # of elements in dimension).    sym_id              arr;    act_dim_list        *dim_ptr;    uint                lo_size;    uint                hi_size;    int                 hi_offset;    int                 ss;    cg_name             num_elts;    cg_name             hi;    cg_name             adv;    call_handle         call;    arr = GetPtr();    dim_ptr = arr->u.ns.si.va.u.dim_ext;    adv = GetAdv( arr );    hi_size = BETypeLength( TY_ADV_HI );    lo_size = BETypeLength( TY_ADV_LO );    ss = GetU16();    hi = GetTypedValue();    if( CGOpts & CGOPT_DI_CV ) {        hi_offset = _DimCount( dim_ptr->dim_flags ) * BETypeLength( TY_ADV_ENTRY );        if( Options & OPT_BOUNDS ) {            hi_offset += BETypeLength( TY_POINTER );        }        hi_offset += (ss - 1) * (lo_size + BETypeLength( TY_ADV_HI_CV )) + lo_size;        hi = CGAssign( StructRef( adv, hi_offset ), hi, TY_ADV_HI_CV );        adv = GetAdv( arr );    }    if( Options & OPT_BOUNDS ) {        call = InitCall( RT_ADV_FILL_HI );        CGAddParm( call, hi, TY_INT_4 );        CGAddParm( call, CGInteger( ss, TY_UNSIGNED ), TY_UNSIGNED );        CGAddParm( call, adv, TY_LOCAL_POINTER );        CGDone( CGUnary( O_POINTS, CGCall( call ), TY_INT_4 ) );    } else {        hi_offset = (ss - 1) * ( lo_size + hi_size ) + lo_size;        num_elts = CGBinary( O_PLUS, hi,                             CGBinary( O_MINUS, CGInteger( 1, TY_INTEGER ),                                       LoBound( arr, ss - 1 ),                                       TY_ADV_HI ),                             TY_ADV_HI );        CGDone( CGAssign( StructRef( adv, hi_offset ), num_elts, TY_ADV_HI ) );    }}

cg_name StructRef( cg_name structure, int offset ) {//==================================================// Reference a field in a structure.    return( CGBinary( O_PLUS, structure, CGInteger( offset, TY_INTEGER ), TY_LOCAL_POINTER ) ); }

cg_name FieldArrayNumElts( sym_id arr ) {//=======================================// Get number of elements in an array.    return( CGInteger( arr->u.fd.dim_ext->num_elts, TY_INT_4 ) );}

static  void    DbSubscript( sym_id arr ) {//=========================================// Generate call to debugging subscript routine.    act_dim_list        *dim_ptr;    int                 dims_no;    int                 i;    call_handle         call;    cg_name             offset;    cg_name             subscripts[MAX_DIM];    dim_ptr = arr->u.ns.si.va.u.dim_ext;    dims_no = _DimCount( dim_ptr->dim_flags );    call = InitCall( RT_SUBSCRIPT );    for( i = 0; i < dims_no; ++i ) {        subscripts[ i ] = GetTypedValue();    }    for( i = 1; i <= dims_no; ++i ) {        CGAddParm( call, subscripts[ dims_no - i ], TY_INT_4 );    }    CGAddParm( call, GetAdv( arr ), TY_LOCAL_POINTER );    CGAddParm( call, CGInteger( _DimCount( dim_ptr->dim_flags ), TY_INTEGER ), TY_INTEGER );    offset = CGUnary( O_POINTS, CGCall( call ), TY_INT_4 );    Index( arr, offset );}

cg_name Concat( uint num_args, cg_name dest ) {//=============================================// Do concatenation operation.    int         count;    call_handle call;    cg_name     dest_1;    cg_name     dest_2;    if( num_args & CAT_TEMP ) {        call = InitCall( RT_TCAT );        num_args &= ~CAT_TEMP;    } else if( num_args == 1 ) {        call = InitCall( RT_MOVE );    } else {        call = InitCall( RT_CAT );    }    count = num_args;    while( count > 0 ) {        CGAddParm( call, StkElement( count ), TY_LOCAL_POINTER );        --count;    }    PopStkElements( num_args );    CloneCGName( dest, &dest_1, &dest_2 );    CGAddParm( call, dest_1, TY_LOCAL_POINTER );    if( num_args != 1 ) {        CGAddParm( call, CGInteger( num_args, TY_UNSIGNED ), TY_UNSIGNED );    }    return( CGBinary( O_COMMA, CGCall( call ), dest_2, TY_LOCAL_POINTER ) );}

void    FCCharNMove( void ) {//=====================// Perform N character assignment of non optimal lengths.    int         src_len;    int         dst_len;    cg_name     dst;    cg_name     dst2;    call_handle call;    bool        equal = FALSE;    src_len = GetInt();    dst_len = GetInt();    if( src_len < dst_len ) {        call = InitInlineCall( INLINE_STRBLAST_NE );    } else {        src_len = dst_len;        equal = TRUE;        call = InitInlineCall( INLINE_STRBLAST_EQ );    }    dst = XPop();    CloneCGName( dst, &dst, &dst2 );    if( OZOpts & OZOPT_O_SPACE || !equal ) {        CGAddParm( call, CGInteger( src_len, TY_INTEGER ), TY_INTEGER );    } else {        // Special but common case, so we optimize it.        CGAddParm( call, CGInteger( src_len & TAIL_MASK, TY_INTEGER ),                        TY_INTEGER );        CGAddParm( call, CGInteger( src_len >> TAIL_SHIFT, TY_INTEGER ),                        TY_INTEGER );    }    CGAddParm( call, SCBPointer( XPop() ), TY_LOCAL_POINTER );    if( !equal ) {        CGAddParm( call, CGInteger( dst_len - src_len, TY_INTEGER ), TY_INTEGER );    }    CGAddParm( call, SCBPointer( dst ), TY_LOCAL_POINTER );    XPush( CGBinary( O_COMMA, CGCall( call ), dst2, TY_LOCAL_POINTER ) );}

void    FCAdvFillHiLo1( void ) {//========================// Fill hi and lo=1 bound of a dimension.    sym_id              arr;    cg_name             lo;    cg_name             hi;    cg_name             adv;    unsigned            ss;    uint                lo_size;    uint                hi_size;    int                 lo_offset;    int                 hi_offset;    call_handle         call;    // Get general information    arr = GetPtr();    ss = GetU16();    adv = GetAdv( arr );    hi_size = BETypeLength( TY_ADV_HI );    lo_size = BETypeLength( TY_ADV_LO );    hi = GetTypedValue();    if( Options & OPT_BOUNDS ) {        call = InitCall( RT_ADV_FILL_HI_LO1 );        CGAddParm( call, hi, TY_INT_4 );        CGAddParm( call, CGInteger( ss, TY_UNSIGNED ), TY_UNSIGNED );        CGAddParm( call, adv, TY_LOCAL_POINTER );        CGDone( CGUnary( O_POINTS, CGCall( call ), TY_INT_4 ) );    } else {        hi_offset = (ss - 1) * ( lo_size + hi_size ) + lo_size;        CGDone( CGAssign( StructRef( adv, hi_offset ), hi, TY_ADV_HI ) );        // set lo bound of the adv        lo = CGInteger( 1, TY_INT_4 );        lo_offset = (ss - 1) * BETypeLength( TY_ADV_ENTRY );        adv = GetAdv( arr );        CGDone( CGAssign( StructRef( adv, lo_offset ), lo, TY_ADV_LO ) );    }}

static  void    VariableDims( sym_id arr ) {//==========================================// Subscript an array that has a variable array declarator.    act_dim_list        *dim_ptr;    int                 dims_no;    int                 ss_offset;    cg_name             offset;    cg_name             c_offset;    dim_ptr = arr->u.ns.si.va.u.dim_ext;    dims_no = _DimCount( dim_ptr->dim_flags );    offset = CGInteger( 0, TY_INT_4 );    c_offset = CGInteger( 0, TY_INT_4 );    ss_offset = 0;    while( ss_offset < dims_no ) {        // offset += ( ss - lo ) * multiplier;        //              or        // offset   += ss*multiplier        // c_offset -= lo*multiplier        offset = CGBinary( O_PLUS,                           offset,                           CGBinary( O_TIMES,                                     GetTypedValue(),                                     Multiplier( arr, ss_offset ),                                     TY_INT_4 ),                           TY_INT_4 );        c_offset = CGBinary( O_MINUS,                             c_offset,                             CGBinary( O_TIMES,                                       LoBound( arr, ss_offset ),                                       Multiplier( arr, ss_offset ),                                       TY_INT_4 ),                             TY_INT_4 );        ss_offset++;    }    Index( arr, CGBinary( O_PLUS, c_offset, offset, TY_INT_4 ) );}

cg_name ConstArrayOffset( act_dim_list *dims ) {//==============================================    int                 dims_no;    cg_name             hi_off;    intstar4            multiplier;    intstar4            hi;    intstar4            lo;    intstar4            *bounds;    intstar4            lo_off;    dims_no = _DimCount( dims->dim_flags );    bounds = &dims->subs_1_lo;    multiplier = 1;    hi_off = CGInteger( 0, TY_INT_4 );    lo_off = 0;    for(;;) {        lo = *bounds;        bounds++;        hi = *bounds;        bounds++;        // offset += ( ss - lo ) * multiplier;        //              or        // hi_off += ss*multiplier        // lo_off -= lo*multiplier        hi_off = CGBinary( O_PLUS,                           hi_off,                           CGBinary( O_TIMES,                                     GetTypedValue(),                                     CGInteger( multiplier, TY_INT_4 ),                                     TY_INT_4 ),                           TY_INT_4 );        lo_off -= lo * multiplier;        if( --dims_no == 0 ) break;        multiplier *= ( hi - lo + 1 );    }    return( CGBinary( O_PLUS, CGInteger( lo_off, TY_INT_4 ), hi_off, TY_INT_4 ) );}

static void    XCmplxMixOp( RTCODE rtn_id, bool cmplx_scalar ) {//=======================================================// F-Code processor for binary complex number operations involving// runtime routines.// x / (c,d) or (c,d) / x    uint_16     typ_info;    cg_type     s_typ;    cg_type     x_typ;    cg_name     s;    cg_cmplx    x;    typ_info = GetU16();    if( cmplx_scalar ) {        x_typ = GetType1( typ_info );        s_typ = GetType2( typ_info );        XPopCmplx( &x, x_typ );        s = XPopValue( s_typ );    } else {        s_typ = GetType1( typ_info );        x_typ = GetType2( typ_info );        s = XPopValue( s_typ );        XPopCmplx( &x, x_typ );    }    x_typ = ResCGType( s_typ, CmplxBaseType( x_typ ) );    if( cmplx_scalar ) {        // currently, the only time XCmplxMixOp() is called when the left        // operand is complex and the right operand is a scalar, is for        // exponentiation        s_typ = PromoteIntType( s_typ );        if( s_typ == TY_INT_4 ) {            DoCmplxScalarOp( RT_C8POWI, x.realpart, x.imagpart, s );        } else {            DoCmplxOp( rtn_id, x.realpart, x.imagpart, s, CGInteger( 0, x_typ ) );        }    } else {        DoCmplxOp( rtn_id, s, CGInteger( 0, x_typ ), x.realpart, x.imagpart );    }}

static cg_name CharArrLength( sym_id sym ) {//==========================================// Get element size for character*(*) arrays.    if( sym->u.ns.flags & SY_VALUE_PARM ) {        return( CGInteger( 0, TY_INTEGER ) );    } else if( Options & OPT_DESCRIPTOR ) {        return( SCBLength( CGUnary( O_POINTS, CGFEName( sym, TY_POINTER ), TY_POINTER ) ) );    } else {        return( CGUnary( O_POINTS, CGFEName( FindArgShadow( sym ), TY_INTEGER ), TY_INTEGER ) );    }}

void    FCIfArith( void ) {//===================// Set up control structure for arithmetic if.    cg_name     if_expr;    sym_id      lt;    sym_id      eq;    sym_id      gt;    cg_type     typ;    typ = GetType( GetU16() );    if_expr = XPopValue( typ );    lt = GetPtr();    eq = GetPtr();    gt = GetPtr();    if( lt == gt ) {        CGControl( O_IF_TRUE,                   CGCompare( O_EQ, if_expr, CGInteger( 0, typ ), typ ),                   GetStmtLabel( eq ) );        CGControl( O_GOTO, NULL, GetStmtLabel( lt ) );    } else if( lt == eq ) {        CGControl( O_IF_TRUE,                   CGCompare( O_GT, if_expr, CGInteger( 0, typ ), typ ),                   GetStmtLabel( gt ) );        CGControl( O_GOTO, NULL, GetStmtLabel( eq ) );    } else if( eq == gt ) {        CGControl( O_IF_TRUE,                   CGCompare( O_LT, if_expr, CGInteger( 0, typ ), typ ),                   GetStmtLabel( lt ) );        CGControl( O_GOTO, NULL, GetStmtLabel( eq ) );    } else {        CG3WayControl( if_expr, GetStmtLabel( lt ), GetStmtLabel( eq ),                       GetStmtLabel( gt ) );    }    RefStmtLabel( lt );    RefStmtLabel( eq );    RefStmtLabel( gt );}

void    FCSetLine( void ) {//===================// Generate run-time call to ISN routine.    call_handle handle;    unsigned_16 line_num;    line_num = GetU16();    if( ( SubProgId->ns.flags & SY_SUBPROG_TYPE ) == SY_BLOCK_DATA ) return;    handle = InitCall( RT_SET_LINE );    CGAddParm( handle, CGInteger( line_num, TY_INTEGER ), TY_INTEGER );    CGDone( CGCall( handle ) );}

static  cg_name Multiplier( sym_id arr, int subs_no ) {//=====================================================// Compute mulitplier.    cg_name     multiplier;    multiplier = CGInteger( 1, TY_INT_4 );    while( subs_no != 0 ) {        multiplier = CGBinary( O_TIMES, multiplier,                               HiBound( arr, subs_no - 1 ), TY_INT_4 );        subs_no--;    }    return( multiplier );}

void    XCCompare( int op ) {//===========================// Scalar/Complex compare.    cg_name     x;    cg_cmplx    z;    unsigned_16 typ_info;    cg_type     typ1;    typ_info = GetU16();    typ1 = GetType1( typ_info );    x = XPopValue( typ1 );    XPopCmplx( &z, GetType2( typ_info ) );    CCCmp( op, x, CGInteger( 0, typ1 ), z.realpart, z.imagpart );}

cg_name ArrayNumElts( sym_id arr ) {//==================================// Get number of elements in an array.    cg_name             num_elts;    act_dim_list        *dim;    dim = arr->u.ns.si.va.u.dim_ext;    if( _AdvRequired( dim ) ) {        num_elts = Multiplier( arr, _DimCount( dim->dim_flags ) );    } else {        num_elts = CGInteger( dim->num_elts, TY_INT_4 );    }    return( num_elts );}

static  void    CXCompare( int op ) {//===================================// Complex/Scalar compare.    cg_name     x;    cg_cmplx    z;    uint_16     typ_info;    cg_type     typ2;    typ_info = GetU16();    typ2 = GetType2( typ_info );    XPopCmplx( &z, GetType1( typ_info ) );    x = XPopValue( typ2 );    CCCmp( op, z.realpart, z.imagpart, x, CGInteger( 0, typ2 ) );}

cg_name ArrayEltSize( sym_id arr ) {//==================================// Get element size of an array.    cg_name     elt_size;    uint        size;    size = _SymSize( arr );    if( size == 0 ) {   // character*(*) array        elt_size = CharItemLen( arr );    } else {        elt_size = CGInteger( size, TY_INTEGER );    }    return( elt_size );}