Skip to content

Commit 48165ec

Browse files
tglsfdctglsfdc
committed
Latest round of fmgr updates. All functions with bool,char, or int2
inputs have been converted to newstyle. This should go a long way towards fixing our portability problems with platforms where char and short parameters are passed differently from int-width parameters. Still more to do for the Alpha port however.
1 parent c61db5b commit 48165ec

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

47 files changed

+2175
-2008
lines changed

‎src/backend/access/hash/hashfunc.c

Lines changed: 100 additions & 109 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@
88
*
99
*
1010
* IDENTIFICATION
11-
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashfunc.c,v 1.25 2000/04/12 17:14:44 momjian Exp $
11+
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashfunc.c,v 1.26 2000/06/05 07:28:35 tgl Exp $
1212
*
1313
* NOTES
1414
* These functions are stored in pg_amproc. For each operator class
@@ -21,190 +21,183 @@
2121

2222
#include "access/hash.h"
2323

24-
uint32
25-
hashint2(int16 key)
24+
Datum
25+
hashint2(PG_FUNCTION_ARGS)
2626
{
27-
return (uint32) ~key;
27+
PG_RETURN_UINT32((uint32) ~ PG_GETARG_INT16(0));
2828
}
2929

30-
uint32
31-
hashint4(uint32 key)
30+
Datum
31+
hashint4(PG_FUNCTION_ARGS)
3232
{
33-
return ~key;
33+
PG_RETURN_UINT32(~ PG_GETARG_UINT32(0));
3434
}
3535

36-
uint32
37-
hashint8(int64 *key)
36+
Datum
37+
hashint8(PG_FUNCTION_ARGS)
3838
{
39-
return ~((uint32) *key);
39+
/* we just use the low 32 bits... */
40+
PG_RETURN_UINT32(~((uint32) PG_GETARG_INT64(0)));
4041
}
4142

4243
/* Hash function from Chris Torek. */
43-
uint32
44-
hashfloat4(float32 keyp)
44+
Datum
45+
hashfloat4(PG_FUNCTION_ARGS)
4546
{
46-
int len;
47+
float4 key = PG_GETARG_FLOAT4(0);
48+
char *kp = (char *) &key;
49+
int len = sizeof(key);
4750
int loop;
4851
uint32 h;
49-
char *kp = (char *) keyp;
50-
51-
len = sizeof(float32data);
5252

5353
#define HASH4a h = (h << 5) - h + *kp++;
5454
#define HASH4b h = (h << 5) + h + *kp++;
5555
#define HASH4 HASH4b
5656

57-
5857
h = 0;
59-
if (len > 0)
60-
{
61-
loop = (len + 8 - 1) >> 3;
58+
/*
59+
* This is a tad silly, given that we expect len = 4, but a smart
60+
* compiler should be able to eliminate the redundant code...
61+
*/
62+
loop = (len + 8 - 1) >> 3;
6263

63-
switch (len & (8 - 1))
64-
{
65-
case 0:
66-
do
67-
{ /* All fall throughs */
68-
HASH4;
69-
case 7:
70-
HASH4;
71-
case 6:
72-
HASH4;
73-
case 5:
74-
HASH4;
75-
case 4:
76-
HASH4;
77-
case 3:
78-
HASH4;
79-
case 2:
80-
HASH4;
81-
case 1:
82-
HASH4;
83-
} while (--loop);
84-
}
64+
switch (len & (8 - 1))
65+
{
66+
case 0:
67+
do
68+
{ /* All fall throughs */
69+
HASH4;
70+
case 7:
71+
HASH4;
72+
case 6:
73+
HASH4;
74+
case 5:
75+
HASH4;
76+
case 4:
77+
HASH4;
78+
case 3:
79+
HASH4;
80+
case 2:
81+
HASH4;
82+
case 1:
83+
HASH4;
84+
} while (--loop);
8585
}
86-
return h;
86+
PG_RETURN_UINT32(h);
8787
}
8888

89-
90-
uint32
91-
hashfloat8(float64 keyp)
89+
Datum
90+
hashfloat8(PG_FUNCTION_ARGS)
9291
{
93-
int len;
92+
float8 key = PG_GETARG_FLOAT8(0);
93+
char *kp = (char *) &key;
94+
int len = sizeof(key);
9495
int loop;
9596
uint32 h;
96-
char *kp = (char *) keyp;
97-
98-
len = sizeof(float64data);
9997

10098
#define HASH4a h = (h << 5) - h + *kp++;
10199
#define HASH4b h = (h << 5) + h + *kp++;
102100
#define HASH4 HASH4b
103101

104-
105102
h = 0;
106-
if (len > 0)
107-
{
108-
loop = (len + 8 - 1) >> 3;
103+
/*
104+
* This is a tad silly, given that we expect len = 8, but a smart
105+
* compiler should be able to eliminate the redundant code...
106+
*/
107+
loop = (len + 8 - 1) >> 3;
109108

110-
switch (len & (8 - 1))
111-
{
112-
case 0:
113-
do
114-
{ /* All fall throughs */
115-
HASH4;
116-
case 7:
117-
HASH4;
118-
case 6:
119-
HASH4;
120-
case 5:
121-
HASH4;
122-
case 4:
123-
HASH4;
124-
case 3:
125-
HASH4;
126-
case 2:
127-
HASH4;
128-
case 1:
129-
HASH4;
130-
} while (--loop);
131-
}
109+
switch (len & (8 - 1))
110+
{
111+
case 0:
112+
do
113+
{ /* All fall throughs */
114+
HASH4;
115+
case 7:
116+
HASH4;
117+
case 6:
118+
HASH4;
119+
case 5:
120+
HASH4;
121+
case 4:
122+
HASH4;
123+
case 3:
124+
HASH4;
125+
case 2:
126+
HASH4;
127+
case 1:
128+
HASH4;
129+
} while (--loop);
132130
}
133-
return h;
131+
PG_RETURN_UINT32(h);
134132
}
135133

136-
137-
uint32
138-
hashoid(Oid key)
134+
Datum
135+
hashoid(PG_FUNCTION_ARGS)
139136
{
140-
return (uint32) ~key;
137+
PG_RETURN_UINT32(~(uint32) PG_GETARG_OID(0));
141138
}
142139

143-
uint32
144-
hashoidvector(Oid *key)
140+
Datum
141+
hashoidvector(PG_FUNCTION_ARGS)
145142
{
143+
Oid *key = (Oid *) PG_GETARG_POINTER(0);
146144
int i;
147145
uint32 result = 0;
148146

149147
for (i = INDEX_MAX_KEYS; --i >= 0;)
150148
result = (result << 1) ^ (~(uint32) key[i]);
151-
return result;
149+
PG_RETURN_UINT32(result);
152150
}
153151

154152
/*
155153
* Note: hashint2vector currently can't be used as a user hash table
156154
* hash function, because it has no pg_proc entry. We only need it
157155
* for catcache indexing.
158156
*/
159-
uint32
160-
hashint2vector(int16 *key)
157+
Datum
158+
hashint2vector(PG_FUNCTION_ARGS)
161159
{
160+
int16 *key = (int16 *) PG_GETARG_POINTER(0);
162161
int i;
163162
uint32 result = 0;
164163

165164
for (i = INDEX_MAX_KEYS; --i >= 0;)
166165
result = (result << 1) ^ (~(uint32) key[i]);
167-
return result;
166+
PG_RETURN_UINT32(result);
168167
}
169168

170169

171170
#define PRIME1 37
172171
#define PRIME2 1048583
173172

174-
uint32
175-
hashchar(char key)
173+
Datum
174+
hashchar(PG_FUNCTION_ARGS)
176175
{
177176
uint32 h;
178177

179178
/* Convert char to integer */
180-
h = (key - ' ');
179+
h = (PG_GETARG_CHAR(0) - ' ');
181180
h %= PRIME2;
182181

183-
return h;
182+
PG_RETURN_UINT32(h);
184183
}
185184

186-
187-
uint32
188-
hashname(NameData *n)
185+
Datum
186+
hashname(PG_FUNCTION_ARGS)
189187
{
188+
char *key = NameStr(* PG_GETARG_NAME(0));
189+
int len = NAMEDATALEN;
190190
uint32 h;
191-
int len;
192-
char *key;
193-
194-
key = NameStr(*n);
195191

196192
h = 0;
197-
len = NAMEDATALEN;
198193
/* Convert string to integer */
199194
while (len--)
200195
h = h * PRIME1 ^ (*key++ - ' ');
201196
h %= PRIME2;
202197

203-
return h;
198+
PG_RETURN_UINT32(h);
204199
}
205200

206-
207-
208201
/*
209202
* (Comment from the original db3 hashing code: )
210203
*
@@ -216,19 +209,17 @@ hashname(NameData *n)
216209
*
217210
* "OZ's original sdbm hash"
218211
*/
219-
uint32
220-
hashtext(struct varlena * key)
212+
Datum
213+
hashtext(PG_FUNCTION_ARGS)
221214
{
215+
text *key = PG_GETARG_TEXT_P(0);
222216
int keylen;
223217
char *keydata;
224218
uint32 n;
225219
int loop;
226220

227221
keydata = VARDATA(key);
228-
keylen = VARSIZE(key);
229-
230-
/* keylen includes the four bytes in which string keylength is stored */
231-
keylen -= sizeof(VARSIZE(key));
222+
keylen = VARSIZE(key) - VARHDRSZ;
232223

233224
#define HASHC n = *keydata++ + 65599 * n
234225

@@ -260,5 +251,5 @@ hashtext(struct varlena * key)
260251
} while (--loop);
261252
}
262253
}
263-
return n;
254+
PG_RETURN_UINT32(n);
264255
}

0 commit comments

Comments
 (0)