basop.c

嵌入式linux系统的网络编程（C＋＋） 在ARM上实现视频会议 此程序获得全国研究生电子大赛一等奖 压缩包内为全部源码

        Overflow = 1;
        carry_int = 0;
    }
    else {
        if ((L_var1 < 0L) && (L_var2 < 0L) && (L_test > 0L)) {
            Overflow = 1;
            carry_int = 1;
        }
        else {
            if (((L_var1 ^ L_var2) < 0L) && (L_test > 0L)) {
                Overflow = 0;
                carry_int = 1;
            }
            else {
                Overflow = 0;
                carry_int = 0;
            }
        }
    }

    if (Carry) {
        if (L_test == MAX_32) {
            Overflow = 1;
            Carry = carry_int;
        }
        else {
            if (L_test == (Word32) 0xFFFFFFFFL) {
                Carry = 1;
            }
            else {
                Carry = carry_int;
            }
        }
    }
    else {
        Carry = carry_int;
    }

    return(L_var_out);
}

/*___________________________________________________________________________
 |                                                                           |
 |   Function Name : L_sub_c                                                 |
 |                                                                           |
 |   Purpose :                                                               |
 |                                                                           |
 |   Performs 32 bits subtraction of the two 32 bits variables with carry    |
 |   (borrow) : L_var1-L_var2-C. No saturation. Generate carry and Overflow  |
 |   values. The carry and overflow values are binary variables which can    |
 |   be tested and assigned values.                                          |
 |                                                                           |
 |   Complexity weight : 2                                                   |
 |                                                                           |
 |   Inputs :                                                                |
 |                                                                           |
 |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 |                                                                           |
 |    L_var2   32 bit long signed integer (Word32) whose value falls in the  |
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 |                                                                           |
 |   Outputs :                                                               |
 |                                                                           |
 |    none                                                                   |
 |                                                                           |
 |   Return Value :                                                          |
 |                                                                           |
 |    L_var_out                                                              |
 |             32 bit long signed integer (Word32) whose value falls in the  |
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
 |                                                                           |
 |   Caution :                                                               |
 |                                                                           |
 |    In some cases the Carry flag has to be cleared or set before using op- |
 |    rators which take into account its value.                              |
 |___________________________________________________________________________|
*/

Word32 L_sub_c(Word32 L_var1, Word32 L_var2)
{
    Word32 L_var_out;
    Word32 L_test;
    Flag carry_int = 0;

    if (Carry) {
        Carry = 0;
        if (L_var2 != MIN_32) {
            L_var_out = L_add_c(L_var1,-L_var2);
        }
        else {
            L_var_out = L_var1 - L_var2;
            if (L_var1 > 0L) {
                Overflow = 1;
                Carry = 0;
            }
        }
    }
    else {
        L_var_out = L_var1 - L_var2 - (Word32)0X00000001L;
        L_test = L_var1 - L_var2;

        if ((L_test < 0L) && (L_var1 > 0L) && (L_var2 < 0L)) {
            Overflow = 1;
            carry_int = 0;
        }
        else if ((L_test > 0L) && (L_var1 < 0L) && (L_var2 > 0L)) {
            Overflow = 1;
            carry_int = 1;
        }
        else if ((L_test > 0L) && ((L_var1 ^ L_var2) > 0L)) {
            Overflow = 0;
            carry_int = 1;
        }


        if (L_test == MIN_32) {
            Overflow = 1;
            Carry = carry_int;
        }
        else {
            Carry = carry_int;
        }
    }

    return(L_var_out);
}

/*___________________________________________________________________________
 |                                                                           |
 |   Function Name : L_negate                                                |
 |                                                                           |
 |   Purpose :                                                               |
 |                                                                           |
 |   Negate the 32 bit variable L_var1 with saturation; saturate in the case |
 |   where input is -2147483648 (0x8000 0000).                               |
 |                                                                           |
 |   Complexity weight : 2                                                   |
 |                                                                           |
 |   Inputs :                                                                |
 |                                                                           |
 |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 |
 |                                                                           |
 |   Outputs :                                                               |
 |                                                                           |
 |    none                                                                   |
 |                                                                           |
 |   Return Value :                                                          |
 |                                                                           |
 |    L_var_out                                                              |
 |             32 bit long signed integer (Word32) whose value falls in the  |
 |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              |
 |___________________________________________________________________________|
*/

Word32 L_negate(Word32 L_var1)
{
    Word32 L_var_out;

    L_var_out = (L_var1 == MIN_32) ? MAX_32 : -L_var1;
    return(L_var_out);
}

/*___________________________________________________________________________
 |                                                                           |
 |   Function Name : mult_r                                                  |
 |                                                                           |
 |   Purpose :                                                               |
 |                                                                           |
 |   Same as mult with rounding, i.e.:                                       |
 |     mult_r(var1,var2) = shr(((var1*var2) + 16384),15) and                 |
 |     mult_r(-32768,-32768) = 32767.                                        |
 |                                                                           |
 |   Complexity weight : 2                                                   |
 |                                                                           |
 |   Inputs :                                                                |
 |                                                                           |
 |    var1                                                                   |
 |             16 bit short signed integer (Word16) whose value falls in the |
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 |                                                                           |
 |    var2                                                                   |
 |             16 bit short signed integer (Word16) whose value falls in the |
 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   |
 |                                                                           |
 |   Outputs :                                                               |
 |                                                                           |
 |    none                                                                   |
 |                                                                           |
 |   Return Value :                                                          |
 |                                                                           |
 |    var_out                                                                |
 |             16 bit short signed integer (Word16) whose value falls in the |
 |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                |
 |___________________________________________________________________________|
*/

Word16 mult_r(Word16 var1, Word16 var2)
{
    Word16 var_out;
    Word32 L_produit_arr;

    L_produit_arr = (Word32)var1 * (Word32)var2; /* product */
    L_produit_arr += (Word32) 0x00004000L;        /* round */
    L_produit_arr &= (Word32) 0xffff8000L;
    L_produit_arr >>= 15;                        /* shift */

    if (L_produit_arr & (Word32) 0x00010000L)  {
                                     /* sign extend when necessary */
        L_produit_arr |= (Word32) 0xffff0000L;
    }

    var_out = sature(L_produit_arr);
    return(var_out);
}

/*___________________________________________________________________________
 |                                                                           |
 |   Function Name : L_shl                                                   |
 |                                                                           |
 |   Purpose :                                                               |
 |                                                                           |
 |   Arithmetically shift the 32 bit input L_var1 left var2 positions. Zero  |
 |   fill the var2 LSB of the result. If var2 is negative, L_var1 right by   |
 |   -var2 arithmetically shift with sign extension. Saturate the result in  |
 |   case of underflows or overflows.                                        |
 |                                                                           |
 |   Complexity weight : 2                                                   |
 |                                                                           |
 |   Inputs :                                                                |
 |                                                                           |
 |    L_var1   32 bit long signed integer (Word32) whose value falls in the  |
 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.