1 /* 2 ********************************************************************** 3 * Copyright (c) 2002-2005, International Business Machines 4 * Corporation and others. All Rights Reserved. 5 ********************************************************************** 6 ********************************************************************** 7 */ 8 /** 9 * This Program tests the performance of ICU's Normalization engine against Windows 10 * to run it use the command like 11 * 12 * c:\normperf.exe -s C:\work\ICUCupertinoRep\icu4c\collation-perf-data -i 10 -p 15 -f TestNames_Asian.txt -u -e UTF-8 -l 13 */ 14 #include "normperf.h" 15 #include "uoptions.h" 16 #include <stdio.h> 17 18 #define LENGTHOF(array) (sizeof(array)/sizeof((array)[0])) 19 20 UPerfFunction* NormalizerPerformanceTest::runIndexedTest(int32_t index, UBool exec,const char* &name, char* par) { 21 switch (index) { 22 TESTCASE(0,TestICU_NFC_NFD_Text); 23 TESTCASE(1,TestICU_NFC_NFC_Text); 24 TESTCASE(2,TestICU_NFC_Orig_Text); 25 26 TESTCASE(3,TestICU_NFD_NFD_Text); 27 TESTCASE(4,TestICU_NFD_NFC_Text); 28 TESTCASE(5,TestICU_NFD_Orig_Text); 29 30 TESTCASE(6,TestICU_FCD_NFD_Text); 31 TESTCASE(7,TestICU_FCD_NFC_Text); 32 TESTCASE(8,TestICU_FCD_Orig_Text); 33 34 TESTCASE(9,TestWin_NFC_NFD_Text); 35 TESTCASE(10,TestWin_NFC_NFC_Text); 36 TESTCASE(11,TestWin_NFC_Orig_Text); 37 38 TESTCASE(12,TestWin_NFD_NFD_Text); 39 TESTCASE(13,TestWin_NFD_NFC_Text); 40 TESTCASE(14,TestWin_NFD_Orig_Text); 41 42 TESTCASE(15,TestQC_NFC_NFD_Text); 43 TESTCASE(16,TestQC_NFC_NFC_Text); 44 TESTCASE(17,TestQC_NFC_Orig_Text); 45 46 TESTCASE(18,TestQC_NFD_NFD_Text); 47 TESTCASE(19,TestQC_NFD_NFC_Text); 48 TESTCASE(20,TestQC_NFD_Orig_Text); 49 50 TESTCASE(21,TestQC_FCD_NFD_Text); 51 TESTCASE(22,TestQC_FCD_NFC_Text); 52 TESTCASE(23,TestQC_FCD_Orig_Text); 53 54 TESTCASE(24,TestIsNormalized_NFC_NFD_Text); 55 TESTCASE(25,TestIsNormalized_NFC_NFC_Text); 56 TESTCASE(26,TestIsNormalized_NFC_Orig_Text); 57 58 TESTCASE(27,TestIsNormalized_NFD_NFD_Text); 59 TESTCASE(28,TestIsNormalized_NFD_NFC_Text); 60 TESTCASE(29,TestIsNormalized_NFD_Orig_Text); 61 62 TESTCASE(30,TestIsNormalized_FCD_NFD_Text); 63 TESTCASE(31,TestIsNormalized_FCD_NFC_Text); 64 TESTCASE(32,TestIsNormalized_FCD_Orig_Text); 65 66 default: 67 name = ""; 68 return NULL; 69 } 70 return NULL; 71 72 } 73 74 void NormalizerPerformanceTest::normalizeInput(ULine* dest,const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options){ 75 int32_t reqLen = 0; 76 UErrorCode status = U_ZERO_ERROR; 77 for(;;){ 78 /* pure pre-flight */ 79 reqLen=unorm_normalize(src,srcLen,mode, options,NULL,0,&status); 80 if(status==U_BUFFER_OVERFLOW_ERROR){ 81 status=U_ZERO_ERROR; 82 dest->name = new UChar[reqLen+1]; 83 reqLen= unorm_normalize(src,srcLen,mode, options,dest->name,reqLen+1,&status); 84 dest->len=reqLen; 85 break; 86 }else if(U_FAILURE(status)){ 87 printf("Could not normalize input. Error: %s", u_errorName(status)); 88 } 89 } 90 } 91 UChar* NormalizerPerformanceTest::normalizeInput(int32_t& len, const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options){ 92 int32_t reqLen = 0; 93 UErrorCode status = U_ZERO_ERROR; 94 UChar* dest = NULL; 95 for(;;){ 96 /* pure pre-flight */ 97 reqLen=unorm_normalize(src,srcLen,mode, options,NULL,0,&status); 98 if(status==U_BUFFER_OVERFLOW_ERROR){ 99 status=U_ZERO_ERROR; 100 dest = new UChar[reqLen+1]; 101 reqLen= unorm_normalize(src,srcLen,mode, options,dest,reqLen+1,&status); 102 len=reqLen; 103 break; 104 }else if(U_FAILURE(status)){ 105 printf("Could not normalize input. Error: %s", u_errorName(status)); 106 return NULL; 107 } 108 } 109 return dest; 110 } 111 112 static UOption cmdLineOptions[]={ 113 UOPTION_DEF("options", 'o', UOPT_OPTIONAL_ARG) 114 }; 115 116 NormalizerPerformanceTest::NormalizerPerformanceTest(int32_t argc, const char* argv[], UErrorCode& status) 117 : UPerfTest(argc,argv,status), options(0) { 118 NFDBuffer = NULL; 119 NFCBuffer = NULL; 120 NFDBufferLen = 0; 121 NFCBufferLen = 0; 122 NFDFileLines = NULL; 123 NFCFileLines = NULL; 124 125 if(status== U_ILLEGAL_ARGUMENT_ERROR){ 126 fprintf(stderr,gUsageString, "normperf"); 127 return; 128 } 129 130 if(U_FAILURE(status)){ 131 fprintf(stderr, "FAILED to create UPerfTest object. Error: %s\n", u_errorName(status)); 132 return; 133 } 134 135 _remainingArgc = u_parseArgs(_remainingArgc, (char **)argv, (int32_t)(LENGTHOF(cmdLineOptions)), cmdLineOptions); 136 if(cmdLineOptions[0].doesOccur && cmdLineOptions[0].value!=NULL) { 137 options=(int32_t)strtol(cmdLineOptions[0].value, NULL, 16); 138 } 139 140 if(line_mode){ 141 ULine* filelines = getLines(status); 142 if(U_FAILURE(status)){ 143 fprintf(stderr, "FAILED to read lines from file and create UPerfTest object. Error: %s\n", u_errorName(status)); 144 return; 145 } 146 NFDFileLines = new ULine[numLines]; 147 NFCFileLines = new ULine[numLines]; 148 149 for(int32_t i=0;i<numLines;i++){ 150 normalizeInput(&NFDFileLines[i],filelines[i].name,filelines[i].len,UNORM_NFD, options); 151 normalizeInput(&NFCFileLines[i],filelines[i].name,filelines[i].len,UNORM_NFC, options); 152 153 } 154 }else if(bulk_mode){ 155 int32_t srcLen = 0; 156 const UChar* src = getBuffer(srcLen,status); 157 NFDBufferLen = 0; 158 NFCBufferLen = 0; 159 160 if(U_FAILURE(status)){ 161 fprintf(stderr, "FAILED to read buffer from file and create UPerfTest object. Error: %s\n", u_errorName(status)); 162 return; 163 } 164 165 NFDBuffer = normalizeInput(NFDBufferLen,src,srcLen,UNORM_NFD, options); 166 NFCBuffer = normalizeInput(NFCBufferLen,src,srcLen,UNORM_NFC, options); 167 } 168 169 } 170 171 NormalizerPerformanceTest::~NormalizerPerformanceTest(){ 172 delete[] NFDFileLines; 173 delete[] NFCFileLines; 174 delete[] NFDBuffer; 175 delete[] NFCBuffer; 176 } 177 178 // Test NFC Performance 179 UPerfFunction* NormalizerPerformanceTest::TestICU_NFC_NFD_Text(){ 180 if(line_mode){ 181 NormPerfFunction* func= new NormPerfFunction(ICUNormNFC, options,NFDFileLines,numLines, uselen); 182 return func; 183 }else{ 184 NormPerfFunction* func= new NormPerfFunction(ICUNormNFC, options,NFDBuffer, NFDBufferLen, uselen); 185 return func; 186 } 187 } 188 UPerfFunction* NormalizerPerformanceTest::TestICU_NFC_NFC_Text(){ 189 if(line_mode){ 190 NormPerfFunction* func = new NormPerfFunction(ICUNormNFC, options,NFCFileLines,numLines, uselen); 191 return func; 192 }else{ 193 NormPerfFunction* func= new NormPerfFunction(ICUNormNFC, options,NFCBuffer, NFCBufferLen, uselen); 194 return func; 195 } 196 } 197 UPerfFunction* NormalizerPerformanceTest::TestICU_NFC_Orig_Text(){ 198 if(line_mode){ 199 NormPerfFunction* func = new NormPerfFunction(ICUNormNFC, options,lines,numLines, uselen); 200 return func; 201 }else{ 202 NormPerfFunction* func = new NormPerfFunction(ICUNormNFC, options,buffer, bufferLen, uselen); 203 return func; 204 } 205 } 206 207 // Test NFD Performance 208 UPerfFunction* NormalizerPerformanceTest::TestICU_NFD_NFD_Text(){ 209 if(line_mode){ 210 NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFDFileLines,numLines, uselen); 211 return func; 212 }else{ 213 NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFDBuffer,NFDBufferLen, uselen); 214 return func; 215 } 216 } 217 UPerfFunction* NormalizerPerformanceTest::TestICU_NFD_NFC_Text(){ 218 if(line_mode){ 219 NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFCFileLines,numLines, uselen); 220 return func; 221 }else{ 222 NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFCBuffer,NFCBufferLen, uselen); 223 return func; 224 } 225 } 226 UPerfFunction* NormalizerPerformanceTest::TestICU_NFD_Orig_Text(){ 227 if(line_mode){ 228 NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,lines,numLines, uselen); 229 return func; 230 }else{ 231 NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,buffer,bufferLen, uselen); 232 return func; 233 } 234 } 235 236 // Test FCD Performance 237 UPerfFunction* NormalizerPerformanceTest::TestICU_FCD_NFD_Text(){ 238 if(line_mode){ 239 NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFDFileLines,numLines, uselen); 240 return func; 241 }else{ 242 NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFDBuffer,NFDBufferLen, uselen); 243 return func; 244 } 245 246 } 247 UPerfFunction* NormalizerPerformanceTest::TestICU_FCD_NFC_Text(){ 248 if(line_mode){ 249 NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFCFileLines,numLines, uselen); 250 return func; 251 }else{ 252 NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFCBuffer,NFCBufferLen, uselen); 253 return func; 254 } 255 } 256 UPerfFunction* NormalizerPerformanceTest::TestICU_FCD_Orig_Text(){ 257 if(line_mode){ 258 NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,lines,numLines, uselen); 259 return func; 260 }else{ 261 NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,buffer,bufferLen, uselen); 262 return func; 263 } 264 } 265 266 // Test Win NFC Performance 267 UPerfFunction* NormalizerPerformanceTest::TestWin_NFC_NFD_Text(){ 268 if(line_mode){ 269 NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFDFileLines,numLines, uselen); 270 return func; 271 }else{ 272 NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFDBuffer,NFDBufferLen, uselen); 273 return func; 274 } 275 } 276 UPerfFunction* NormalizerPerformanceTest::TestWin_NFC_NFC_Text(){ 277 if(line_mode){ 278 NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFCFileLines,numLines, uselen); 279 return func; 280 }else{ 281 NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFCBuffer,NFCBufferLen, uselen); 282 return func; 283 } 284 } 285 UPerfFunction* NormalizerPerformanceTest::TestWin_NFC_Orig_Text(){ 286 if(line_mode){ 287 NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,lines,numLines, uselen); 288 return func; 289 }else{ 290 NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,buffer,bufferLen, uselen); 291 return func; 292 } 293 } 294 295 // Test Win NFD Performance 296 UPerfFunction* NormalizerPerformanceTest::TestWin_NFD_NFD_Text(){ 297 if(line_mode){ 298 NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFDFileLines,numLines, uselen); 299 return func; 300 }else{ 301 NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFDBuffer,NFDBufferLen, uselen); 302 return func; 303 } 304 } 305 UPerfFunction* NormalizerPerformanceTest::TestWin_NFD_NFC_Text(){ 306 if(line_mode){ 307 NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFCFileLines,numLines, uselen); 308 return func; 309 }else{ 310 NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFCBuffer,NFCBufferLen, uselen); 311 return func; 312 } 313 } 314 UPerfFunction* NormalizerPerformanceTest::TestWin_NFD_Orig_Text(){ 315 if(line_mode){ 316 NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,lines,numLines, uselen); 317 return func; 318 }else{ 319 NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,buffer,bufferLen, uselen); 320 return func; 321 } 322 } 323 324 // Test Quick Check Performance 325 UPerfFunction* NormalizerPerformanceTest::TestQC_NFC_NFD_Text(){ 326 if(line_mode){ 327 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDFileLines, numLines, UNORM_NFC, options,uselen); 328 return func; 329 }else{ 330 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDBuffer, NFDBufferLen, UNORM_NFC, options,uselen); 331 return func; 332 } 333 } 334 UPerfFunction* NormalizerPerformanceTest::TestQC_NFC_NFC_Text(){ 335 if(line_mode){ 336 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCFileLines, numLines, UNORM_NFC, options,uselen); 337 return func; 338 }else{ 339 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCBuffer, NFCBufferLen, UNORM_NFC, options,uselen); 340 return func; 341 } 342 } 343 UPerfFunction* NormalizerPerformanceTest::TestQC_NFC_Orig_Text(){ 344 if(line_mode){ 345 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,lines, numLines, UNORM_NFC, options,uselen); 346 return func; 347 }else{ 348 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,buffer, bufferLen, UNORM_NFC, options,uselen); 349 return func; 350 } 351 } 352 353 UPerfFunction* NormalizerPerformanceTest::TestQC_NFD_NFD_Text(){ 354 if(line_mode){ 355 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDFileLines, numLines, UNORM_NFD, options,uselen); 356 return func; 357 }else{ 358 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDBuffer, NFDBufferLen, UNORM_NFD, options,uselen); 359 return func; 360 } 361 } 362 UPerfFunction* NormalizerPerformanceTest::TestQC_NFD_NFC_Text(){ 363 if(line_mode){ 364 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCFileLines, numLines, UNORM_NFD, options,uselen); 365 return func; 366 }else{ 367 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCBuffer, NFCBufferLen, UNORM_NFD, options,uselen); 368 return func; 369 } 370 } 371 UPerfFunction* NormalizerPerformanceTest::TestQC_NFD_Orig_Text(){ 372 if(line_mode){ 373 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,lines, numLines, UNORM_NFD, options,uselen); 374 return func; 375 }else{ 376 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,buffer, bufferLen, UNORM_NFD, options,uselen); 377 return func; 378 } 379 } 380 381 UPerfFunction* NormalizerPerformanceTest::TestQC_FCD_NFD_Text(){ 382 if(line_mode){ 383 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDFileLines, numLines, UNORM_FCD, options,uselen); 384 return func; 385 }else{ 386 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDBuffer, NFDBufferLen, UNORM_FCD, options,uselen); 387 return func; 388 } 389 } 390 UPerfFunction* NormalizerPerformanceTest::TestQC_FCD_NFC_Text(){ 391 if(line_mode){ 392 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCFileLines, numLines, UNORM_FCD, options,uselen); 393 return func; 394 }else{ 395 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCBuffer, NFCBufferLen, UNORM_FCD, options,uselen); 396 return func; 397 } 398 } 399 UPerfFunction* NormalizerPerformanceTest::TestQC_FCD_Orig_Text(){ 400 if(line_mode){ 401 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,lines, numLines, UNORM_FCD, options,uselen); 402 return func; 403 }else{ 404 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,buffer, bufferLen, UNORM_FCD, options,uselen); 405 return func; 406 } 407 } 408 409 // Test isNormalized Performance 410 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFC_NFD_Text(){ 411 if(line_mode){ 412 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDFileLines, numLines, UNORM_NFC, options,uselen); 413 return func; 414 }else{ 415 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDBuffer, NFDBufferLen, UNORM_NFC, options,uselen); 416 return func; 417 } 418 } 419 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFC_NFC_Text(){ 420 if(line_mode){ 421 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCFileLines, numLines, UNORM_NFC, options,uselen); 422 return func; 423 }else{ 424 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCBuffer, NFCBufferLen, UNORM_NFC, options,uselen); 425 return func; 426 } 427 } 428 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFC_Orig_Text(){ 429 if(line_mode){ 430 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,lines, numLines, UNORM_NFC, options,uselen); 431 return func; 432 }else{ 433 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,buffer, bufferLen, UNORM_NFC, options,uselen); 434 return func; 435 } 436 } 437 438 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFD_NFD_Text(){ 439 if(line_mode){ 440 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDFileLines, numLines, UNORM_NFD, options,uselen); 441 return func; 442 }else{ 443 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDBuffer, NFDBufferLen, UNORM_NFD, options,uselen); 444 return func; 445 } 446 } 447 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFD_NFC_Text(){ 448 if(line_mode){ 449 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCFileLines, numLines, UNORM_NFD, options,uselen); 450 return func; 451 }else{ 452 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCBuffer, NFCBufferLen, UNORM_NFD, options,uselen); 453 return func; 454 } 455 } 456 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFD_Orig_Text(){ 457 if(line_mode){ 458 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,lines, numLines, UNORM_NFD, options,uselen); 459 return func; 460 }else{ 461 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,buffer, bufferLen, UNORM_NFD, options,uselen); 462 return func; 463 } 464 } 465 466 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_FCD_NFD_Text(){ 467 if(line_mode){ 468 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDFileLines, numLines, UNORM_FCD, options,uselen); 469 return func; 470 }else{ 471 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDBuffer, NFDBufferLen, UNORM_FCD, options,uselen); 472 return func; 473 } 474 } 475 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_FCD_NFC_Text(){ 476 if(line_mode){ 477 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCFileLines, numLines, UNORM_FCD, options,uselen); 478 return func; 479 }else{ 480 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCBuffer, NFCBufferLen, UNORM_FCD, options,uselen); 481 return func; 482 } 483 } 484 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_FCD_Orig_Text(){ 485 if(line_mode){ 486 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,lines, numLines, UNORM_FCD, options,uselen); 487 return func; 488 }else{ 489 QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,buffer, bufferLen, UNORM_FCD, options,uselen); 490 return func; 491 } 492 } 493 494 int main(int argc, const char* argv[]){ 495 UErrorCode status = U_ZERO_ERROR; 496 NormalizerPerformanceTest test(argc, argv, status); 497 if(U_FAILURE(status)){ 498 return status; 499 } 500 if(test.run()==FALSE){ 501 fprintf(stderr,"FAILED: Tests could not be run please check the arguments.\n"); 502 return -1; 503 } 504 return 0; 505 } 506
