← Back to branch summary

~ubuntu-branches/ubuntu/precise/icu/precise

« back to all changes in this revision

Viewing changes to source/test/cintltst/nfsprep.c

  • Committer: Package Import Robot
  • Author(s): Jay Berkenbilt
  • Date: 2009-09-04 11:56:06 UTC
  • mfrom: (10.1.6 sid)
  • Revision ID: package-import@ubuntu.com-20090904115606-sqxxuizelam5tozb
Tags: 4.2.1-3
http://bugs.debian.org/544799
Change install-doc target to not fail if there are subdirectories of
doc/html.  This is necessary to handle the doc/html/search directory
created by doxygen 3.6.1.  (Closes: #544799)

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/test/cintltst/nfsprep.c
 
1
/*
 
2
 *******************************************************************************
 
3
 *
 
4
 *   Copyright (C) 2003-2007, International Business Machines
 
5
 *   Corporation and others.  All Rights Reserved.
 
6
 *
 
7
 *******************************************************************************
 
8
 *   file name:  nfsprep.c
 
9
 *   encoding:   US-ASCII
 
10
 *   tab size:   8 (not used)
 
11
 *   indentation:4
 
12
 *
 
13
 *   created on: 2003jul11
 
14
 *   created by: Ram Viswanadha
 
15
 */
 
16
 
 
17
#include "unicode/utypes.h"
 
18
 
 
19
#if !UCONFIG_NO_IDNA
 
20
 
 
21
#include "nfsprep.h"
 
22
#include "ustr_imp.h"
 
23
#include "cintltst.h"
 
24
 
 
25
#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
 
26
#define NFS4_MAX_BUFFER_SIZE 1000
 
27
#define PREFIX_SUFFIX_SEPARATOR 0x0040 /* '@' */
 
28
 
 
29
 
 
30
const char* NFS4DataFileNames[5] ={
 
31
    "nfscss",
 
32
    "nfscsi",
 
33
    "nfscis",
 
34
    "nfsmxp",
 
35
    "nfsmxs"
 
36
};
 
37
 
 
38
 
 
39
int32_t
 
40
nfs4_prepare( const char* src, int32_t srcLength,
 
41
              char* dest, int32_t destCapacity,
 
42
              NFS4ProfileState state,
 
43
              UParseError* parseError,
 
44
              UErrorCode*  status){
 
45
    
 
46
    UChar b1Stack[NFS4_MAX_BUFFER_SIZE], 
 
47
          b2Stack[NFS4_MAX_BUFFER_SIZE]; 
 
48
    char  b3Stack[NFS4_MAX_BUFFER_SIZE];
 
49
 
 
50
    /* initialize pointers to stack buffers */
 
51
    UChar *b1 = b1Stack, *b2 = b2Stack;
 
52
    char  *b3=b3Stack;
 
53
    int32_t b1Len=0, b2Len=0, b3Len=0,
 
54
            b1Capacity = NFS4_MAX_BUFFER_SIZE, 
 
55
            b2Capacity = NFS4_MAX_BUFFER_SIZE,
 
56
            b3Capacity = NFS4_MAX_BUFFER_SIZE,
 
57
            reqLength=0;
 
58
    
 
59
    UStringPrepProfile* profile = NULL;
 
60
    /* get the test data path */
 
61
    const char *testdatapath = NULL;
 
62
 
 
63
    if(status==NULL || U_FAILURE(*status)){
 
64
        return 0;
 
65
    }
 
66
    if((src==NULL) || (srcLength < -1) || (destCapacity<0) || (!dest && destCapacity > 0)){
 
67
        *status = U_ILLEGAL_ARGUMENT_ERROR;
 
68
        return 0;
 
69
    }
 
70
    testdatapath = loadTestData(status);
 
71
 
 
72
    /* convert the string from UTF-8 to UTF-16 */
 
73
    u_strFromUTF8(b1,b1Capacity,&b1Len,src,srcLength,status);
 
74
    if(*status == U_BUFFER_OVERFLOW_ERROR){
 
75
 
 
76
        /* reset the status */
 
77
        *status = U_ZERO_ERROR;
 
78
        
 
79
        b1 = (UChar*) malloc(b1Len * U_SIZEOF_UCHAR);
 
80
        if(b1==NULL){
 
81
            *status = U_MEMORY_ALLOCATION_ERROR;
 
82
            goto CLEANUP;
 
83
        }
 
84
 
 
85
        b1Capacity = b1Len;
 
86
        u_strFromUTF8(b1, b1Capacity, &b1Len, src, srcLength, status);
 
87
    }
 
88
 
 
89
    /* open the profile */
 
90
    profile = usprep_open(testdatapath, NFS4DataFileNames[state],  status);
 
91
    /* prepare the string */
 
92
    b2Len = usprep_prepare(profile, b1, b1Len, b2, b2Capacity, USPREP_DEFAULT, parseError, status);
 
93
    if(*status == U_BUFFER_OVERFLOW_ERROR){
 
94
        *status = U_ZERO_ERROR;
 
95
        b2 = (UChar*) malloc(b2Len * U_SIZEOF_UCHAR);
 
96
        if(b2== NULL){
 
97
            *status = U_MEMORY_ALLOCATION_ERROR;
 
98
            goto CLEANUP;
 
99
        }
 
100
        b2Len = usprep_prepare(profile, b1, b1Len, b2, b2Len, USPREP_DEFAULT, parseError, status);
 
101
    }
 
102
    
 
103
    /* convert the string back to UTF-8 */
 
104
    u_strToUTF8(b3,b3Capacity, &b3Len, b2, b2Len, status);
 
105
    if(*status == U_BUFFER_OVERFLOW_ERROR){
 
106
        *status = U_ZERO_ERROR;
 
107
        b3 = (char*) malloc(b3Len);
 
108
        if(b3== NULL){
 
109
            *status = U_MEMORY_ALLOCATION_ERROR;
 
110
            goto CLEANUP;
 
111
        }
 
112
        b3Capacity = b3Len;
 
113
        u_strToUTF8(b3,b3Capacity, &b3Len, b2, b2Len, status);
 
114
    }
 
115
 
 
116
    reqLength = b3Len;
 
117
    if(dest!=NULL && reqLength <= destCapacity){
 
118
        memmove(dest, b3, reqLength);
 
119
    }
 
120
 
 
121
CLEANUP:
 
122
    if(b1!=b1Stack){
 
123
        free(b1);
 
124
    }
 
125
    if(b2!=b2Stack){
 
126
        free(b2);
 
127
    }
 
128
    if(b3!=b3Stack){
 
129
        free(b3);
 
130
    }
 
131
 
 
132
    return u_terminateChars(dest, destCapacity, reqLength, status);
 
133
}
 
134
 
 
135
/* sorted array for binary search*/
 
136
static const char* special_prefixes[]={
 
137
    "\x0041\x004e\x004f\x004e\x0059\x004d\x004f\x0055\x0053",    
 
138
    "\x0041\x0055\x0054\x0048\x0045\x004e\x0054\x0049\x0043\x0041\x0054\x0045\x0044",
 
139
    "\x0042\x0041\x0054\x0043\x0048", 
 
140
    "\x0044\x0049\x0041\x004c\x0055\x0050", 
 
141
    "\x0045\x0056\x0045\x0052\x0059\x004f\x004e\x0045", 
 
142
    "\x0047\x0052\x004f\x0055\x0050",
 
143
    "\x0049\x004e\x0054\x0045\x0052\x0041\x0043\x0054\x0049\x0056\x0045",  
 
144
    "\x004e\x0045\x0054\x0057\x004f\x0052\x004b", 
 
145
    "\x004f\x0057\x004e\x0045\x0052",
 
146
};
 
147
 
 
148
 
 
149
/* binary search the sorted array */
 
150
static int 
 
151
findStringIndex(const char* const *sortedArr, int32_t sortedArrLen, const char* target, int32_t targetLen){
 
152
 
 
153
    int left, middle, right,rc;
 
154
 
 
155
    left =0;
 
156
    right= sortedArrLen-1;
 
157
 
 
158
    while(left <= right){
 
159
        middle = (left+right)/2;
 
160
        rc=strncmp(sortedArr[middle],target, targetLen);
 
161
    
 
162
        if(rc<0){
 
163
            left = middle+1;
 
164
        }else if(rc >0){
 
165
            right = middle -1;
 
166
        }else{
 
167
            return middle;
 
168
        }
 
169
    }
 
170
    return -1;
 
171
}
 
172
 
 
173
static void 
 
174
getPrefixSuffix(const char *src, int32_t srcLength, 
 
175
                const char **prefix, int32_t *prefixLen,
 
176
                const char **suffix, int32_t *suffixLen,
 
177
                UErrorCode *status){
 
178
 
 
179
    int32_t i=0;
 
180
    *prefix = src;
 
181
    while(i<srcLength){
 
182
        if(src[i] == PREFIX_SUFFIX_SEPARATOR){
 
183
            if((i+1) == srcLength){
 
184
                /* we reached the end of the string */
 
185
                *suffix = NULL;
 
186
                i++;
 
187
                break;
 
188
            }
 
189
            i++;/* the prefix contains the separator */
 
190
            *suffix = src + i;
 
191
            break;
 
192
        }
 
193
        i++;
 
194
    }
 
195
    *prefixLen = i;
 
196
    *suffixLen = srcLength - i;
 
197
    /* special prefixes must not be followed by suffixes! */
 
198
    if((findStringIndex(special_prefixes,LENGTHOF(special_prefixes), *prefix, *prefixLen-1) != -1) && (*suffix != NULL)){
 
199
        *status = U_PARSE_ERROR;
 
200
        return;
 
201
    }
 
202
            
 
203
}
 
204
 
 
205
int32_t
 
206
nfs4_mixed_prepare( const char* src, int32_t srcLength,
 
207
                    char* dest, int32_t destCapacity,
 
208
                    UParseError* parseError,
 
209
                    UErrorCode*  status){
 
210
 
 
211
    const char *prefix = NULL, *suffix = NULL;
 
212
    int32_t prefixLen=0, suffixLen=0;
 
213
    char  pStack[NFS4_MAX_BUFFER_SIZE], 
 
214
          sStack[NFS4_MAX_BUFFER_SIZE]; 
 
215
    char *p=pStack, *s=sStack;
 
216
    int32_t pLen=0, sLen=0, reqLen=0,
 
217
            pCapacity = NFS4_MAX_BUFFER_SIZE,
 
218
            sCapacity = NFS4_MAX_BUFFER_SIZE;
 
219
 
 
220
 
 
221
    if(status==NULL || U_FAILURE(*status)){
 
222
        return 0;
 
223
    }
 
224
    if((src==NULL) || (srcLength < -1) || (destCapacity<0) || (!dest && destCapacity > 0)){
 
225
        *status = U_ILLEGAL_ARGUMENT_ERROR;
 
226
        return 0;
 
227
    }
 
228
    if(srcLength == -1){
 
229
        srcLength = (int32_t)strlen(src);
 
230
    }
 
231
    getPrefixSuffix(src, srcLength, &prefix, &prefixLen, &suffix, &suffixLen, status); 
 
232
 
 
233
    /* prepare the prefix */
 
234
    pLen = nfs4_prepare(prefix, prefixLen, p, pCapacity, NFS4_MIXED_PREP_PREFIX, parseError, status);
 
235
    if(*status == U_BUFFER_OVERFLOW_ERROR){
 
236
        *status = U_ZERO_ERROR;
 
237
        p = (char*) malloc(pLen);
 
238
        if(p == NULL){
 
239
           *status = U_MEMORY_ALLOCATION_ERROR;
 
240
           goto CLEANUP;
 
241
        }
 
242
        pLen = nfs4_prepare(prefix, prefixLen, p, pLen, NFS4_MIXED_PREP_PREFIX, parseError, status);
 
243
    }
 
244
 
 
245
    /* prepare the suffix */
 
246
    if(suffix != NULL){
 
247
        sLen = nfs4_prepare(suffix, suffixLen, s, sCapacity, NFS4_MIXED_PREP_SUFFIX, parseError, status);
 
248
        if(*status == U_BUFFER_OVERFLOW_ERROR){
 
249
            *status = U_ZERO_ERROR;
 
250
            s = (char*) malloc(pLen);
 
251
            if(s == NULL){
 
252
               *status = U_MEMORY_ALLOCATION_ERROR;
 
253
               goto CLEANUP;
 
254
            }
 
255
            sLen = nfs4_prepare(suffix, suffixLen, s, sLen, NFS4_MIXED_PREP_SUFFIX, parseError, status);
 
256
        }
 
257
    }
 
258
    reqLen = pLen+sLen+1 /* for the delimiter */;
 
259
    if(dest != NULL && reqLen <= destCapacity){
 
260
        memmove(dest, p, pLen);
 
261
        /* add the suffix */
 
262
        if(suffix!=NULL){
 
263
            dest[pLen++] = PREFIX_SUFFIX_SEPARATOR;
 
264
            memmove(dest+pLen, s, sLen);
 
265
        }
 
266
    }
 
267
 
 
268
CLEANUP:
 
269
    if(p != pStack){
 
270
        free(p);
 
271
    }
 
272
    if(s != sStack){
 
273
        free(s);
 
274
    }
 
275
    
 
276
    return u_terminateChars(dest, destCapacity, reqLen, status);
 
277
}
 
278
 
 
279
int32_t
 
280
nfs4_cis_prepare(   const char* src, int32_t srcLength,
 
281
                    char* dest, int32_t destCapacity,
 
282
                    UParseError* parseError,
 
283
                    UErrorCode*  status){
 
284
    return nfs4_prepare(src, srcLength, dest, destCapacity, NFS4_CIS_PREP, parseError, status);
 
285
}
 
286
 
 
287
 
 
288
int32_t
 
289
nfs4_cs_prepare(    const char* src, int32_t srcLength,
 
290
                    char* dest, int32_t destCapacity,
 
291
                    UBool isCaseSensitive,
 
292
                    UParseError* parseError,
 
293
                    UErrorCode*  status){
 
294
    if(isCaseSensitive){
 
295
        return nfs4_prepare(src, srcLength, dest, destCapacity, NFS4_CS_PREP_CS, parseError, status);
 
296
    }else{
 
297
        return nfs4_prepare(src, srcLength, dest, destCapacity, NFS4_CS_PREP_CI, parseError, status);
 
298
    }
 
299
}
 
300
 
 
301
#endif
 
302
/*
 
303
 * Hey, Emacs, please set the following:
 
304
 *
 
305
 * Local Variables:
 
306
 * indent-tabs-mode: nil
 
307
 * End:
 
308
 *
 
309
 */
 
310