add.c File Reference

#include <stdio.h>
#include <assert.h>
#include "private.h"
#include "gsm.h"
#include "proto.h"

Include dependency graph for add.c:

Go to the source code of this file.

Macros
#define	saturate(x)    ((x) < MIN_WORD ? MIN_WORD : (x) > MAX_WORD ? MAX_WORD: (x))

Functions
word gsm_norm	P1 ((a), longword a)
word gsm_abs	P1 ((a), word a)
longword gsm_L_add	P2 ((a, b), longword a, longword b)
word gsm_add	P2 ((a, b), word a, word b)
longword gsm_L_asl	P2 ((a, n), longword a, int n)
word gsm_asl	P2 ((a, n), word a, int n)
word gsm_div	P2 ((num, denum), word num, word denum)

Variables
static unsigned char const	bitoff [256]

Macro Definition Documentation

saturate

#define saturate

(

x

)

((x) < MIN_WORD ? MIN_WORD : (x) > MAX_WORD ? MAX_WORD: (x))

Definition at line 20 of file add.c.

                               : (x) > MAX_WORD ? MAX_WORD: (x))

Function Documentation

P1() [1/2]

word gsm_norm P1	(	(a)	,
		longword	a
	)

Definition at line 117 of file add.c.

{
    assert(a != 0);
 
    if (a < 0) {
        if (a <= -1073741824) return 0;
        a = ~a;
    }
 
    return    a & 0xffff0000
        ? ( a & 0xff000000
          ?  -1 + bitoff[ 0xFF & (a >> 24) ]
          :   7 + bitoff[ 0xFF & (a >> 16) ] )
        : ( a & 0xff00
          ?  15 + bitoff[ 0xFF & (a >> 8) ]
          :  23 + bitoff[ 0xFF & a ] );
}

References a, and bitoff.

P1() [2/2]

word gsm_abs P1	(	(a)	,
		word	a
	)

Definition at line 51 of file add.c.

{
    return a < 0 ? (a == MIN_WORD ? MAX_WORD : -a) : a;
}

References a, MAX_WORD, and MIN_WORD.

P2() [1/5]

longword gsm_L_sub P2	(	(a, b)	,
		longword	a,
		longword	b
	)

Definition at line 62 of file add.c.

{
    if (a < 0) {
        if (b >= 0) return a + b;
        else {
            ulongword A = (ulongword)-(a + 1) + (ulongword)-(b + 1);
            return A >= MAX_LONGWORD ? MIN_LONGWORD :-(longword)A-2;
        }
    }
    else if (b <= 0) return a + b;
    else {
        ulongword A = (ulongword)a + (ulongword)b;
        return A > MAX_LONGWORD ? MAX_LONGWORD : A;
    }
}

References a, b, MAX_LONGWORD, and MIN_LONGWORD.

P2() [2/5]

longword gsm_L_mult P2	(	(a, b)	,
		word	a,
		word	b
	)

Definition at line 23 of file add.c.

{
    longword sum = (longword)a + (longword)b;
    return (word)saturate(sum);
}

References a, b, and saturate.

P2() [3/5]

longword gsm_L_asr P2	(	(a, n)	,
		longword	a,
		int	n
	)

Definition at line 153 of file add.c.

{
    if (n >= 32) return 0;
    if (n <= -32) return -(a < 0);
    if (n < 0) return gsm_L_asr(a, -n);
    return a << n;
}

References a.

P2() [4/5]

word gsm_asr P2	(	(a, n)	,
		word	a,
		int	n
	)

Definition at line 161 of file add.c.

{
    if (n >= 16) return 0;
    if (n <= -16) return -(a < 0);
    if (n < 0) return gsm_asr(a, -n);
    return a << n;
}

References a.

P2() [5/5]

word gsm_div P2	(	(num, denum)	,
		word	num,
		word	denum
	)

Definition at line 206 of file add.c.

{
    longword    L_num   = num;
    longword    L_denum = denum;
    word        div     = 0;
    int     k   = 15;
 
    /* The parameter num sometimes becomes zero.
     * Although this is explicitly guarded against in 4.2.5,
     * we assume that the result should then be zero as well.
     */
 
    /* assert(num != 0); */
 
    assert(num >= 0 && denum >= num);
    if (num == 0)
        return 0;
 
    while (k--) {
        div   <<= 1;
        L_num <<= 1;
 
        if (L_num >= L_denum) {
            L_num -= L_denum;
            div++;
        }
    }
 
    return div;
}

Variable Documentation

bitoff

unsigned char const bitoff[256]

static

Definition at line 98 of file add.c.

                                           {
     8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
     3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

Referenced by P1().