Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
att
GitHub Repository: att/ast
 Path: blob/master/src/lib/libvcodex/Vcdelta/vcdtblinit.c
1810 views
1
/***********************************************************************

2
*                                                                      *

3
*               This software is part of the ast package               *

4
*          Copyright (c) 2003-2011 AT&T Intellectual Property          *

5
*                      and is licensed under the                       *

6
*                 Eclipse Public License, Version 1.0                  *

7
*                    by AT&T Intellectual Property                     *

8
*                                                                      *

9
*                A copy of the License is available at                 *

10
*          http://www.eclipse.org/org/documents/epl-v10.html           *

11
*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *

12
*                                                                      *

13
*              Information and Software Systems Research               *

14
*                            AT&T Research                             *

15
*                           Florham Park NJ                            *

16
*                                                                      *

17
*                   Phong Vo <[email protected]>                    *

18
*                                                                      *

19
***********************************************************************/

20
#include	"vcdhdr.h"

21


22


23
/*	Construct default code tables for encoding/decoding delta instructions

24
**

25
**	Written by Kiem-Phong Vo ([email protected])

26
*/

27


28
/* default code table for compression	*/

29
Vcdtable_t*	_Vcdtbl = 0;

30


31
Vcdindex_t	_Vcdindex = { 0 };

32
Vcdsize_t	_Vcdsize =

33
		{ 17,						/* add		*/

34
		  { 18, 18, 18, 18, 18, 18, 18, 18, 18 },	/* copy		*/

35
		  {  4,  4,  4,  4,  4,  4,  4,  4,  4 },	/* add1		*/

36
		  {  6,  6,  6,  6,  6,  6,  4,  4,  4 },	/* copy2	*/

37
		  {  4,  4,  4,  4,  4,  4,  4,  4,  4 },	/* copy1	*/

38
		  {  1,  1,  1,  1,  1,  1,  1,  1,  1 },	/* add2		*/

39
		};

40
static Vcdtable_t	_Vcdtable =

41
		{ 4,						/* s_near	*/

42
		  3						/* s_same	*/

43
		};

44


45
#if __STD_C

46
static void vcdtblmake(Vcdtable_t* tbl, Vcdsize_t* siz, Vcdindex_t* idx)

47
#else

48
static void vcdtblmake(tbl, siz, idx)

49
Vcdtable_t*	tbl;

50
Vcdsize_t*	siz;

51
Vcdindex_t*	idx;

52
#endif

53
{

54
	int		i, m, maxm, s, maxs, t, maxt;

55
	Vcdcode_t*	code = tbl->code;

56
	/**/DEBUG_DECLARE(int, k);

57


58
	i = 0; /* the only RUN instruction has index 0	*/

59
	code[i].inst1.type = VCD_RUN;

60
	code[i].inst1.size = 0;		/* size coded separately	*/

61
	code[i].inst1.mode = 0;		/* there is no mode for RUN	*/

62
	code[i].inst2.type = VCD_NOOP;	/* there is no merged inst 	*/

63
	code[i].inst1.size = 0;

64
	code[i].inst1.mode = 0;

65
	i += 1;

66


67
	/**/DEBUG_SET(k,0); /* the single ADD instructions */

68
	for(s = 0; s <= siz->add; ++s)

69
	{	code[i].inst1.type = VCD_ADD;

70
		code[i].inst1.size = s;

71
		code[i].inst1.mode = 0;

72
		code[i].inst2.type = VCD_NOOP;

73
		code[i].inst2.size = 0;

74
		code[i].inst2.mode = 0;

75
		if(idx)

76
			idx->add[s] = i;

77
		i += 1; /**/DEBUG_COUNT(k);

78
	} /**/DEBUG_ASSERT(i < 256);

79


80
	/* max address type */

81
	maxm = tbl->s_same + tbl->s_near + 1;

82


83
	/**/DEBUG_SET(k,0); /* the single COPY instructions */

84
	for(m = VCD_SELF; m <= maxm; ++m)

85
	for(s = 0, maxs = siz->copy[m]; s <= maxs; s = s == 0 ? COPYMIN : s+1)

86
	{	code[i].inst1.type = VCD_COPY;

87
		code[i].inst1.size = s;

88
		code[i].inst1.mode = m;

89
		code[i].inst2.type = VCD_NOOP;

90
		code[i].inst2.size = 0;

91
		code[i].inst2.mode = 0;

92
		if(idx)

93
			idx->copy[m][s] = i;

94
		i += 1; /**/DEBUG_COUNT(k);

95
	} /**/DEBUG_ASSERT(i <= 256);

96


97
	/**/DEBUG_SET(k,0); /* merged ADD+COPY instructions */

98
	for(m = VCD_SELF; m <= maxm; ++m)

99
	for(s = 1, maxs = siz->add1[m]; s <= maxs; ++s)

100
	for(t = COPYMIN, maxt = siz->copy2[m]; t <= maxt; ++t)

101
	{	code[i].inst1.type = VCD_ADD;

102
		code[i].inst1.size = s;

103
		code[i].inst1.mode = 0;

104
		code[i].inst2.type = VCD_COPY;

105
		code[i].inst2.size = t;

106
		code[i].inst2.mode = m;

107
		if(idx)

108
			idx->addcopy[s][m][t] = i;

109
		i += 1; /**/DEBUG_COUNT(k);

110
	} /**/DEBUG_ASSERT(i <= 256);

111


112
	/**/DEBUG_SET(k,0); /* merged COPY+ADD instructions */

113
	for(m = VCD_SELF; m <= maxm; ++m)

114
	for(s = COPYMIN, maxs = siz->copy1[m]; s <= maxs; ++s)

115
	for(t = 1, maxt = siz->add2[m]; t <= maxt; ++t)

116
	{	code[i].inst1.type = VCD_COPY;

117
		code[i].inst1.size = s;

118
		code[i].inst1.mode = m;

119
		code[i].inst2.type = VCD_ADD;

120
		code[i].inst2.size = t;

121
		code[i].inst2.mode = 0;

122
		if(idx)

123
			idx->copyadd[m][s][t] = i;

124
		i += 1; /**/DEBUG_COUNT(k);

125
	} /**/DEBUG_ASSERT(i <= 256);

126


127
	/**/DEBUG_ASSERT(i == 256);

128
}

129


130
#if __STD_C

131
void _vcdtblinit(void)

132
#else

133
void _vcdtblinit()

134
#endif

135
{

136
	if(!_Vcdtbl)

137
	{	vcdtblmake(&_Vcdtable, &_Vcdsize, &_Vcdindex);

138
		_Vcdtbl = &_Vcdtable;

139
	}

140
}

141


142