Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
att
GitHub Repository: att/ast
 Path: blob/master/src/lib/librecsort/rskeyopen.c
1808 views
1
/***********************************************************************

2
*                                                                      *

3
*               This software is part of the ast package               *

4
*          Copyright (c) 1996-2012 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
*                 Glenn Fowler <[email protected]>                  *

19
*                                                                      *

20
***********************************************************************/

21
#pragma prototyped

22


23
/*

24
 * keyed data support for recsort

25
 */

26


27
#include "rskeyhdr.h"

28


29
static const char id[] = "\n@(#)$Id: rskey library (AT&T Research) 2012-05-28 $\0\n";

30


31
static const char lib[] = "librecsort:rskey";

32


33
static State_t	state;

34


35
/*

36
 * initialize the global readonly tables

37
 */

38


39
static void

40
#if __STD_C

41
initialize(void)

42
#else

43
initialize()

44
#endif

45
{

46
	register int	i;

47


48
	setlocale(LC_ALL, "");

49
	for (i = 0; i <= UCHAR_MAX; i++)

50
	{

51
		state.all[i] = 1;

52
		state.ident[i] = i;

53
		state.fold[i] = islower(i) ? toupper(i) : i;

54
		if (blank(i))

55
			state.dict[i] = 1;

56
		if (isalnum(i))

57
		{

58
			state.dict[i] = 1;

59
			state.print[i] = 1;

60
		}

61
		else if (isprint(i))

62
			state.print[i] = 1;

63
	}

64
}

65


66
/*

67
 * open a recsort key discipline handle

68
 */

69


70
Rskey_t*

71
#if __STD_C

72
rskeyopen(Rskeydisc_t* keydisc, Rsdisc_t* disc)

73
#else

74
rskeyopen(keydisc)

75
Rskeydisc_t*	keydisc;

76
#endif

77
{

78
	register Rskey_t*	kp;

79


80
	if (!state.dict[' '])

81
		initialize();

82
	if (keydisc->version < 20111011L)

83
		disc = 0;

84
	if (!(kp = vmnewof(Vmheap, 0, Rskey_t, 1, disc ? 0 : sizeof(Rsdisc_t))))

85
		return 0;

86
	kp->id = lib;

87
	kp->disc = disc ? disc : (Rsdisc_t*)(kp + 1);

88
	kp->disc->version = keydisc->version;

89
	kp->disc->keylen = -1;

90
	kp->disc->data = REC_D_TYPE('\n');

91
	kp->keydisc = keydisc;

92
	kp->state = &state;

93
	kp->insize = INSIZE;

94
	kp->outsize = OUTSIZE;

95
	kp->procsize = PROCSIZE;

96
	kp->head = kp->tail = &kp->field.global;

97
	kp->field.global.end.field = MAXFIELD;

98
	kp->meth = Rsrasp;

99
	if (mbcoll())

100
	{

101
		kp->xfrmsiz = 256;

102
		if (!(kp->xfrmbuf = vmnewof(Vmheap, 0, unsigned char, kp->xfrmsiz, 0)))

103
		{

104
			vmfree(Vmheap, kp);

105
			kp = 0;

106
		}

107
	}

108
	return kp;

109
}

110


111
/*

112
 * close an rskeyopen() handle

113
 */

114


115
int

116
#if __STD_C

117
rskeyclose(Rskey_t* kp)

118
#else

119
rskeyclose(kp)

120
Rskey_t*	kp;

121
#endif

122
{

123
	register Rskeyfield_t*	fp;

124
	register Rskeyfield_t*	np;

125


126
	if (!kp)

127
		return -1;

128
	np = kp->field.global.next;

129
	while (fp = np)

130
	{

131
		np = fp->next;

132
		if (fp->freetrans)

133
			vmfree(Vmheap, fp->trans);

134
		vmfree(Vmheap, fp);

135
	}

136
	np = kp->accumulate.head;

137
	while (fp = np)

138
	{

139
		np = fp->next;

140
		vmfree(Vmheap, fp);

141
	}

142
	if (kp->field.positions)

143
		vmfree(Vmheap, kp->field.positions);

144
	vmfree(Vmheap, kp);

145
	return 0;

146
}

147


148