1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
/*
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed
under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
*/
// This file is the C port driver for Erlang. It provides a low overhead
// means of calling into C code, however unlike the Fabric engine, coding
// errors in this module can crash the entire Erlang server.
#include "erl_driver.h"
#include "unicode/ucol.h"
#include "unicode/ucasemap.h"
#ifndef WIN32
#include <string.h> // for memcpy
#endif
typedef struct {
ErlDrvPort port;
UCollator* collNoCase;
UCollator* coll;
} couch_drv_data;
static void couch_drv_stop(ErlDrvData data)
{
couch_drv_data* pData = (couch_drv_data*)data;
if (pData->coll) {
ucol_close(pData->coll);
}
if (pData->collNoCase) {
ucol_close(pData->collNoCase);
}
driver_free((char*)pData);
}
static ErlDrvData couch_drv_start(ErlDrvPort port, char *buff)
{
UErrorCode status = U_ZERO_ERROR;
couch_drv_data* pData = (couch_drv_data*)driver_alloc(sizeof(couch_drv_data));
if (pData == NULL)
return ERL_DRV_ERROR_GENERAL;
pData->port = port;
pData->coll = NULL;
pData->collNoCase = NULL;
pData->coll = ucol_open("", &status);
if (U_FAILURE(status)) {
couch_drv_stop((ErlDrvData)pData);
return ERL_DRV_ERROR_GENERAL;
}
pData->collNoCase = ucol_open("", &status);
if (U_FAILURE(status)) {
couch_drv_stop((ErlDrvData)pData);
return ERL_DRV_ERROR_GENERAL;
}
ucol_setAttribute(pData->collNoCase, UCOL_STRENGTH, UCOL_PRIMARY, &status);
if (U_FAILURE(status)) {
couch_drv_stop((ErlDrvData)pData);
return ERL_DRV_ERROR_GENERAL;
}
return (ErlDrvData)pData;
}
static int return_control_result(void* pLocalResult, int localLen, char **ppRetBuf, int returnLen)
{
if (*ppRetBuf == NULL || localLen > returnLen) {
*ppRetBuf = (char*)driver_alloc_binary(localLen);
if(*ppRetBuf == NULL) {
return -1;
}
}
memcpy(*ppRetBuf, pLocalResult, localLen);
return localLen;
}
static int couch_drv_control(ErlDrvData drv_data, unsigned int command, const char *pBuf,
int bufLen, char **rbuf, int rlen)
{
#define COLLATE 0
#define COLLATE_NO_CASE 1
couch_drv_data* pData = (couch_drv_data*)drv_data;
UErrorCode status = U_ZERO_ERROR;
int collResult;
char response;
UCharIterator iterA;
UCharIterator iterB;
int32_t length;
// 2 strings are in the buffer, consecutively
// The strings begin first with a 32 bit integer byte length, then the actual
// string bytes follow.
// first 32bits are the length
memcpy(&length, pBuf, sizeof(length));
pBuf += sizeof(length);
// point the iterator at it.
uiter_setUTF8(&iterA, pBuf, length);
pBuf += length; // now on to string b
// first 32bits are the length
memcpy(&length, pBuf, sizeof(length));
pBuf += sizeof(length);
// point the iterator at it.
uiter_setUTF8(&iterB, pBuf, length);
if (command == COLLATE)
collResult = ucol_strcollIter(pData->coll, &iterA, &iterB, &status);
else if (command == COLLATE_NO_CASE)
collResult = ucol_strcollIter(pData->collNoCase, &iterA, &iterB, &status);
else
return -1;
if (collResult < 0)
response = 0; //lt
else if (collResult > 0)
response = 1; //gt
else
response = 2; //eq
return return_control_result(&response, sizeof(response), rbuf, rlen);
}
ErlDrvEntry couch_driver_entry = {
NULL, /* F_PTR init, N/A */
couch_drv_start, /* L_PTR start, called when port is opened */
couch_drv_stop, /* F_PTR stop, called when port is closed */
NULL, /* F_PTR output, called when erlang has sent */
NULL, /* F_PTR ready_input, called when input descriptor ready */
NULL, /* F_PTR ready_output, called when output descriptor ready */
"couch_erl_driver", /* char *driver_name, the argument to open_port */
NULL, /* F_PTR finish, called when unloaded */
NULL, /* Not used */
couch_drv_control, /* F_PTR control, port_command callback */
NULL, /* F_PTR timeout, reserved */
NULL /* F_PTR outputv, reserved */
};
DRIVER_INIT(couch_erl_driver) /* must match name in driver_entry */
{
return &couch_driver_entry;
}
|
