1 /* 2 ******************************************************************************* 3 * 4 * Copyright (C) 1998-2008, International Business Machines 5 * Corporation and others. All Rights Reserved. 6 * 7 ******************************************************************************* 8 * 9 * File ucbuf.c 10 * 11 * Modification History: 12 * 13 * Date Name Description 14 * 05/10/01 Ram Creation. 15 ******************************************************************************* 16 */ 17 18 #include "unicode/utypes.h" 19 #include "unicode/putil.h" 20 #include "unicode/ucnv.h" 21 #include "unicode/ucnv_err.h" 22 #include "filestrm.h" 23 #include "cstring.h" 24 #include "cmemory.h" 25 #include "ustrfmt.h" 26 #include "unicode/ustring.h" 27 #include "unicode/uchar.h" 28 #include "ucbuf.h" 29 #include <stdio.h> 30 31 #if !UCONFIG_NO_CONVERSION 32 33 34 #define MAX_IN_BUF 1000 35 #define MAX_U_BUF 1500 36 #define CONTEXT_LEN 20 37 38 struct UCHARBUF { 39 UChar* buffer; 40 UChar* currentPos; 41 UChar* bufLimit; 42 int32_t bufCapacity; 43 int32_t remaining; 44 int32_t signatureLength; 45 FileStream* in; 46 UConverter* conv; 47 UBool showWarning; /* makes this API not produce any errors */ 48 UBool isBuffered; 49 }; 50 51 U_CAPI UBool U_EXPORT2 52 ucbuf_autodetect_fs(FileStream* in, const char** cp, UConverter** conv, int32_t* signatureLength, UErrorCode* error){ 53 char start[8]; 54 int32_t numRead; 55 56 UChar target[1]={ 0 }; 57 UChar* pTarget; 58 const char* pStart; 59 60 /* read a few bytes */ 61 numRead=T_FileStream_read(in, start, sizeof(start)); 62 63 *cp = ucnv_detectUnicodeSignature(start, numRead, signatureLength, error); 64 65 /* unread the bytes beyond what was consumed for U+FEFF */ 66 T_FileStream_rewind(in); 67 if (*signatureLength > 0) { 68 numRead = T_FileStream_read(in, start, *signatureLength); 69 } 70 71 if(*cp==NULL){ 72 *conv =NULL; 73 return FALSE; 74 } 75 76 /* open the converter for the detected Unicode charset */ 77 *conv = ucnv_open(*cp,error); 78 79 /* convert and ignore initial U+FEFF, and the buffer overflow */ 80 pTarget = target; 81 pStart = start; 82 ucnv_toUnicode(*conv, &pTarget, target+1, &pStart, start+*signatureLength, NULL, FALSE, error); 83 *signatureLength = (int32_t)(pStart - start); 84 if(*error==U_BUFFER_OVERFLOW_ERROR) { 85 *error=U_ZERO_ERROR; 86 } 87 88 /* verify that we successfully read exactly U+FEFF */ 89 if(U_SUCCESS(*error) && (pTarget!=(target+1) || target[0]!=0xfeff)) { 90 *error=U_INTERNAL_PROGRAM_ERROR; 91 } 92 93 94 return TRUE; 95 } 96 static UBool ucbuf_isCPKnown(const char* cp){ 97 if(ucnv_compareNames("UTF-8",cp)==0){ 98 return TRUE; 99 } 100 if(ucnv_compareNames("UTF-16BE",cp)==0){ 101 return TRUE; 102 } 103 if(ucnv_compareNames("UTF-16LE",cp)==0){ 104 return TRUE; 105 } 106 if(ucnv_compareNames("UTF-16",cp)==0){ 107 return TRUE; 108 } 109 if(ucnv_compareNames("UTF-32",cp)==0){ 110 return TRUE; 111 } 112 if(ucnv_compareNames("UTF-32BE",cp)==0){ 113 return TRUE; 114 } 115 if(ucnv_compareNames("UTF-32LE",cp)==0){ 116 return TRUE; 117 } 118 if(ucnv_compareNames("SCSU",cp)==0){ 119 return TRUE; 120 } 121 if(ucnv_compareNames("BOCU-1",cp)==0){ 122 return TRUE; 123 } 124 if(ucnv_compareNames("UTF-7",cp)==0){ 125 return TRUE; 126 } 127 return FALSE; 128 } 129 130 U_CAPI FileStream * U_EXPORT2 131 ucbuf_autodetect(const char* fileName, const char** cp,UConverter** conv, int32_t* signatureLength,UErrorCode* error){ 132 FileStream* in=NULL; 133 if(error==NULL || U_FAILURE(*error)){ 134 return NULL; 135 } 136 if(conv==NULL || cp==NULL || fileName==NULL){ 137 *error = U_ILLEGAL_ARGUMENT_ERROR; 138 return NULL; 139 } 140 /* open the file */ 141 in= T_FileStream_open(fileName,"rb"); 142 143 if(in == NULL){ 144 *error=U_FILE_ACCESS_ERROR; 145 return NULL; 146 } 147 148 if(ucbuf_autodetect_fs(in,cp,conv,signatureLength,error)) { 149 return in; 150 } else { 151 ucnv_close(*conv); 152 *conv=NULL; 153 T_FileStream_close(in); 154 return NULL; 155 } 156 } 157 158 /* fill the uchar buffer */ 159 static UCHARBUF* 160 ucbuf_fillucbuf( UCHARBUF* buf,UErrorCode* error){ 161 UChar* pTarget=NULL; 162 UChar* target=NULL; 163 const char* source=NULL; 164 char carr[MAX_IN_BUF] = {'\0'}; 165 char* cbuf = carr; 166 int32_t inputRead=0; 167 int32_t outputWritten=0; 168 int32_t offset=0; 169 const char* sourceLimit =NULL; 170 int32_t cbufSize=0; 171 pTarget = buf->buffer; 172 /* check if we arrived here without exhausting the buffer*/ 173 if(buf->currentPos<buf->bufLimit){ 174 offset = (int32_t)(buf->bufLimit-buf->currentPos); 175 memmove(buf->buffer,buf->currentPos,offset* sizeof(UChar)); 176 } 177 178 #if DEBUG 179 memset(pTarget+offset,0xff,sizeof(UChar)*(MAX_IN_BUF-offset)); 180 #endif 181 if(buf->isBuffered){ 182 cbufSize = MAX_IN_BUF; 183 /* read the file */ 184 inputRead=T_FileStream_read(buf->in,cbuf,cbufSize-offset); 185 buf->remaining-=inputRead; 186 187 }else{ 188 cbufSize = T_FileStream_size(buf->in); 189 cbuf = (char*)uprv_malloc(cbufSize); 190 if (cbuf == NULL) { 191 *error = U_MEMORY_ALLOCATION_ERROR; 192 return NULL; 193 } 194 inputRead= T_FileStream_read(buf->in,cbuf,cbufSize); 195 buf->remaining-=inputRead; 196 } 197 198 /* just to be sure...*/ 199 if ( 0 == inputRead ) 200 buf->remaining = 0; 201 202 target=pTarget; 203 /* convert the bytes */ 204 if(buf->conv){ 205 /* set the callback to stop */ 206 UConverterToUCallback toUOldAction ; 207 void* toUOldContext; 208 void* toUNewContext=NULL; 209 ucnv_setToUCallBack(buf->conv, 210 UCNV_TO_U_CALLBACK_STOP, 211 toUNewContext, 212 &toUOldAction, 213 (const void**)&toUOldContext, 214 error); 215 /* since state is saved in the converter we add offset to source*/ 216 target = pTarget+offset; 217 source = cbuf; 218 sourceLimit = source + inputRead; 219 ucnv_toUnicode(buf->conv,&target,target+(buf->bufCapacity-offset), 220 &source,sourceLimit,NULL, 221 (UBool)(buf->remaining==0),error); 222 223 if(U_FAILURE(*error)){ 224 char context[CONTEXT_LEN+1]; 225 char preContext[CONTEXT_LEN+1]; 226 char postContext[CONTEXT_LEN+1]; 227 int8_t len = CONTEXT_LEN; 228 int32_t start=0; 229 int32_t stop =0; 230 int32_t pos =0; 231 /* use erro1 to preserve the error code */ 232 UErrorCode error1 =U_ZERO_ERROR; 233 234 if( buf->showWarning==TRUE){ 235 fprintf(stderr,"\n###WARNING: Encountered abnormal bytes while" 236 " converting input stream to target encoding: %s\n", 237 u_errorName(*error)); 238 } 239 240 241 /* now get the context chars */ 242 ucnv_getInvalidChars(buf->conv,context,&len,&error1); 243 context[len]= 0 ; /* null terminate the buffer */ 244 245 pos = (int32_t)(source - cbuf - len); 246 247 /* for pre-context */ 248 start = (pos <=CONTEXT_LEN)? 0 : (pos - (CONTEXT_LEN-1)); 249 stop = pos-len; 250 251 memcpy(preContext,cbuf+start,stop-start); 252 /* null terminate the buffer */ 253 preContext[stop-start] = 0; 254 255 /* for post-context */ 256 start = pos+len; 257 stop = (int32_t)(((pos+CONTEXT_LEN)<= (sourceLimit-cbuf) )? (pos+(CONTEXT_LEN-1)) : (sourceLimit-cbuf)); 258 259 memcpy(postContext,source,stop-start); 260 /* null terminate the buffer */ 261 postContext[stop-start] = 0; 262 263 if(buf->showWarning ==TRUE){ 264 /* print out the context */ 265 fprintf(stderr,"\tPre-context: %s\n",preContext); 266 fprintf(stderr,"\tContext: %s\n",context); 267 fprintf(stderr,"\tPost-context: %s\n", postContext); 268 } 269 270 /* reset the converter */ 271 ucnv_reset(buf->conv); 272 273 /* set the call back to substitute 274 * and restart conversion 275 */ 276 ucnv_setToUCallBack(buf->conv, 277 UCNV_TO_U_CALLBACK_SUBSTITUTE, 278 toUNewContext, 279 &toUOldAction, 280 (const void**)&toUOldContext, 281 &error1); 282 283 /* reset source and target start positions */ 284 target = pTarget+offset; 285 source = cbuf; 286 287 /* re convert */ 288 ucnv_toUnicode(buf->conv,&target,target+(buf->bufCapacity-offset), 289 &source,sourceLimit,NULL, 290 (UBool)(buf->remaining==0),&error1); 291 292 } 293 outputWritten = (int32_t)(target - pTarget); 294 295 296 #if DEBUG 297 { 298 int i; 299 target = pTarget; 300 for(i=0;i<numRead;i++){ 301 /* printf("%c", (char)(*target++));*/ 302 } 303 } 304 #endif 305 306 }else{ 307 u_charsToUChars(cbuf,target+offset,inputRead); 308 outputWritten=((buf->remaining>cbufSize)? cbufSize:inputRead+offset); 309 } 310 buf->currentPos = pTarget; 311 buf->bufLimit=pTarget+outputWritten; 312 *buf->bufLimit=0; /*NUL terminate*/ 313 if(cbuf!=carr){ 314 uprv_free(cbuf); 315 } 316 return buf; 317 } 318 319 320 321 /* get a UChar from the stream*/ 322 U_CAPI int32_t U_EXPORT2 323 ucbuf_getc(UCHARBUF* buf,UErrorCode* error){ 324 if(error==NULL || U_FAILURE(*error)){ 325 return FALSE; 326 } 327 if(buf->currentPos>=buf->bufLimit){ 328 if(buf->remaining==0){ 329 return U_EOF; 330 } 331 buf=ucbuf_fillucbuf(buf,error); 332 if(U_FAILURE(*error)){ 333 return U_EOF; 334 } 335 } 336 337 return *(buf->currentPos++); 338 } 339 340 /* get a UChar32 from the stream*/ 341 U_CAPI int32_t U_EXPORT2 342 ucbuf_getc32(UCHARBUF* buf,UErrorCode* error){ 343 int32_t retVal = (int32_t)U_EOF; 344 if(error==NULL || U_FAILURE(*error)){ 345 return FALSE; 346 } 347 if(buf->currentPos+1>=buf->bufLimit){ 348 if(buf->remaining==0){ 349 return U_EOF; 350 } 351 buf=ucbuf_fillucbuf(buf,error); 352 if(U_FAILURE(*error)){ 353 return U_EOF; 354 } 355 } 356 if(UTF_IS_LEAD(*(buf->currentPos))){ 357 retVal=UTF16_GET_PAIR_VALUE(buf->currentPos[0],buf->currentPos[1]); 358 buf->currentPos+=2; 359 }else{ 360 retVal = *(buf->currentPos++); 361 } 362 return retVal; 363 } 364 365 /* u_unescapeAt() callback to return a UChar*/ 366 static UChar U_CALLCONV 367 _charAt(int32_t offset, void *context) { 368 return ((UCHARBUF*) context)->currentPos[offset]; 369 } 370 371 /* getc and escape it */ 372 U_CAPI int32_t U_EXPORT2 373 ucbuf_getcx32(UCHARBUF* buf,UErrorCode* error) { 374 int32_t length; 375 int32_t offset; 376 UChar32 c32,c1,c2; 377 if(error==NULL || U_FAILURE(*error)){ 378 return FALSE; 379 } 380 /* Fill the buffer if it is empty */ 381 if (buf->currentPos >=buf->bufLimit-2) { 382 ucbuf_fillucbuf(buf,error); 383 } 384 385 /* Get the next character in the buffer */ 386 if (buf->currentPos < buf->bufLimit) { 387 c1 = *(buf->currentPos)++; 388 } else { 389 c1 = U_EOF; 390 } 391 392 c2 = *(buf->currentPos); 393 394 /* If it isn't a backslash, return it */ 395 if (c1 != 0x005C) { 396 return c1; 397 } 398 399 /* Determine the amount of data in the buffer */ 400 length = (int32_t)(buf->bufLimit - buf->currentPos); 401 402 /* The longest escape sequence is \Uhhhhhhhh; make sure 403 we have at least that many characters */ 404 if (length < 10) { 405 406 /* fill the buffer */ 407 ucbuf_fillucbuf(buf,error); 408 length = (int32_t)(buf->bufLimit - buf->buffer); 409 } 410 411 /* Process the escape */ 412 offset = 0; 413 c32 = u_unescapeAt(_charAt, &offset, length, (void*)buf); 414 415 /* check if u_unescapeAt unescaped and converted 416 * to c32 or not 417 */ 418 if(c32==0xFFFFFFFF){ 419 if(buf->showWarning) { 420 char context[CONTEXT_LEN+1]; 421 int32_t len = CONTEXT_LEN; 422 if(length < len) { 423 len = length; 424 } 425 context[len]= 0 ; /* null terminate the buffer */ 426 u_UCharsToChars( buf->currentPos, context, len); 427 fprintf(stderr,"Bad escape: [%c%s]...\n", (int)c1, context); 428 } 429 *error= U_ILLEGAL_ESCAPE_SEQUENCE; 430 return c1; 431 }else if(c32!=c2 || (c32==0x0075 && c2==0x0075 && c1==0x005C) /* for \u0075 c2=0x0075 and c32==0x0075*/){ 432 /* Update the current buffer position */ 433 buf->currentPos += offset; 434 }else{ 435 /* unescaping failed so we just return 436 * c1 and not consume the buffer 437 * this is useful for rules with escapes 438 * in resouce bundles 439 * eg: \' \\ \" 440 */ 441 return c1; 442 } 443 444 return c32; 445 } 446 447 U_CAPI UCHARBUF* U_EXPORT2 448 ucbuf_open(const char* fileName,const char** cp,UBool showWarning, UBool buffered, UErrorCode* error){ 449 450 FileStream* in = NULL; 451 int32_t fileSize=0; 452 const char* knownCp; 453 if(error==NULL || U_FAILURE(*error)){ 454 return NULL; 455 } 456 if(cp==NULL || fileName==NULL){ 457 *error = U_ILLEGAL_ARGUMENT_ERROR; 458 return FALSE; 459 } 460 if (!uprv_strcmp(fileName, "-")) { 461 in = T_FileStream_stdin(); 462 }else{ 463 in = T_FileStream_open(fileName, "rb"); 464 } 465 466 if(in!=NULL){ 467 UCHARBUF* buf =(UCHARBUF*) uprv_malloc(sizeof(UCHARBUF)); 468 fileSize = T_FileStream_size(in); 469 if(buf == NULL){ 470 *error = U_MEMORY_ALLOCATION_ERROR; 471 T_FileStream_close(in); 472 return NULL; 473 } 474 buf->in=in; 475 buf->conv=NULL; 476 buf->showWarning = showWarning; 477 buf->isBuffered = buffered; 478 buf->signatureLength=0; 479 if(*cp==NULL || **cp=='\0'){ 480 /* don't have code page name... try to autodetect */ 481 ucbuf_autodetect_fs(in,cp,&buf->conv,&buf->signatureLength,error); 482 }else if(ucbuf_isCPKnown(*cp)){ 483 /* discard BOM */ 484 ucbuf_autodetect_fs(in,&knownCp,&buf->conv,&buf->signatureLength,error); 485 } 486 if(U_SUCCESS(*error) && buf->conv==NULL) { 487 buf->conv=ucnv_open(*cp,error); 488 } 489 if(U_FAILURE(*error)){ 490 ucnv_close(buf->conv); 491 uprv_free(buf); 492 T_FileStream_close(in); 493 return NULL; 494 } 495 496 if((buf->conv==NULL) && (buf->showWarning==TRUE)){ 497 fprintf(stderr,"###WARNING: No converter defined. Using codepage of system.\n"); 498 } 499 buf->remaining=fileSize-buf->signatureLength; 500 if(buf->isBuffered){ 501 buf->bufCapacity=MAX_U_BUF; 502 }else{ 503 buf->bufCapacity=buf->remaining+buf->signatureLength+1/*for terminating nul*/; 504 } 505 buf->buffer=(UChar*) uprv_malloc(U_SIZEOF_UCHAR * buf->bufCapacity ); 506 if (buf->buffer == NULL) { 507 *error = U_MEMORY_ALLOCATION_ERROR; 508 ucbuf_close(buf); 509 return NULL; 510 } 511 buf->currentPos=buf->buffer; 512 buf->bufLimit=buf->buffer; 513 if(U_FAILURE(*error)){ 514 fprintf(stderr, "Could not open codepage [%s]: %s\n", *cp, u_errorName(*error)); 515 ucbuf_close(buf); 516 return NULL; 517 } 518 ucbuf_fillucbuf(buf,error); 519 if(U_FAILURE(*error)){ 520 ucbuf_close(buf); 521 return NULL; 522 } 523 return buf; 524 } 525 *error =U_FILE_ACCESS_ERROR; 526 return NULL; 527 } 528 529 530 531 /* TODO: this method will fail if at the 532 * begining of buffer and the uchar to unget 533 * is from the previous buffer. Need to implement 534 * system to take care of that situation. 535 */ 536 U_CAPI void U_EXPORT2 537 ucbuf_ungetc(int32_t c,UCHARBUF* buf){ 538 /* decrement currentPos pointer 539 * if not at the begining of buffer 540 */ 541 if(buf->currentPos!=buf->buffer){ 542 if(*(buf->currentPos-1)==c){ 543 buf->currentPos--; 544 } else { 545 /* ungetc failed - did not match. */ 546 } 547 } else { 548 /* ungetc failed - beginning of buffer. */ 549 } 550 } 551 552 /* frees the resources of UChar* buffer */ 553 static void 554 ucbuf_closebuf(UCHARBUF* buf){ 555 uprv_free(buf->buffer); 556 buf->buffer = NULL; 557 } 558 559 /* close the buf and release resources*/ 560 U_CAPI void U_EXPORT2 561 ucbuf_close(UCHARBUF* buf){ 562 if(buf!=NULL){ 563 if(buf->conv){ 564 ucnv_close(buf->conv); 565 } 566 T_FileStream_close(buf->in); 567 ucbuf_closebuf(buf); 568 uprv_free(buf); 569 } 570 } 571 572 /* rewind the buf and file stream */ 573 U_CAPI void U_EXPORT2 574 ucbuf_rewind(UCHARBUF* buf,UErrorCode* error){ 575 if(error==NULL || U_FAILURE(*error)){ 576 return; 577 } 578 if(buf){ 579 buf->currentPos=buf->buffer; 580 buf->bufLimit=buf->buffer; 581 T_FileStream_rewind(buf->in); 582 buf->remaining=T_FileStream_size(buf->in)-buf->signatureLength; 583 584 ucnv_resetToUnicode(buf->conv); 585 if(buf->signatureLength>0) { 586 UChar target[1]={ 0 }; 587 UChar* pTarget; 588 char start[8]; 589 const char* pStart; 590 int32_t numRead; 591 592 /* read the signature bytes */ 593 numRead=T_FileStream_read(buf->in, start, buf->signatureLength); 594 595 /* convert and ignore initial U+FEFF, and the buffer overflow */ 596 pTarget = target; 597 pStart = start; 598 ucnv_toUnicode(buf->conv, &pTarget, target+1, &pStart, start+numRead, NULL, FALSE, error); 599 if(*error==U_BUFFER_OVERFLOW_ERROR) { 600 *error=U_ZERO_ERROR; 601 } 602 603 /* verify that we successfully read exactly U+FEFF */ 604 if(U_SUCCESS(*error) && (numRead!=buf->signatureLength || pTarget!=(target+1) || target[0]!=0xfeff)) { 605 *error=U_INTERNAL_PROGRAM_ERROR; 606 } 607 } 608 } 609 } 610 611 612 U_CAPI int32_t U_EXPORT2 613 ucbuf_size(UCHARBUF* buf){ 614 if(buf){ 615 if(buf->isBuffered){ 616 return (T_FileStream_size(buf->in)-buf->signatureLength)/ucnv_getMinCharSize(buf->conv); 617 }else{ 618 return (int32_t)(buf->bufLimit - buf->buffer); 619 } 620 } 621 return 0; 622 } 623 624 U_CAPI const UChar* U_EXPORT2 625 ucbuf_getBuffer(UCHARBUF* buf,int32_t* len,UErrorCode* error){ 626 if(error==NULL || U_FAILURE(*error)){ 627 return NULL; 628 } 629 if(buf==NULL || len==NULL){ 630 *error = U_ILLEGAL_ARGUMENT_ERROR; 631 return NULL; 632 } 633 *len = (int32_t)(buf->bufLimit - buf->buffer); 634 return buf->buffer; 635 } 636 637 U_CAPI const char* U_EXPORT2 638 ucbuf_resolveFileName(const char* inputDir, const char* fileName, char* target, int32_t* len, UErrorCode* status){ 639 int32_t requiredLen = 0; 640 int32_t dirlen = 0; 641 int32_t filelen = 0; 642 if(status==NULL || U_FAILURE(*status)){ 643 return NULL; 644 } 645 646 if(inputDir == NULL || fileName == NULL || len==NULL || (target==NULL && *len>0)){ 647 *status = U_ILLEGAL_ARGUMENT_ERROR; 648 return NULL; 649 } 650 651 652 dirlen = (int32_t)uprv_strlen(inputDir); 653 filelen = (int32_t)uprv_strlen(fileName); 654 if(inputDir[dirlen-1] != U_FILE_SEP_CHAR) { 655 requiredLen = dirlen + filelen + 2; 656 if((*len < requiredLen) || target==NULL){ 657 *len = requiredLen; 658 *status = U_BUFFER_OVERFLOW_ERROR; 659 return NULL; 660 } 661 662 target[0] = '\0'; 663 /* 664 * append the input dir to openFileName if the first char in 665 * filename is not file seperation char and the last char input directory is not '.'. 666 * This is to support : 667 * genrb -s. /home/icu/data 668 * genrb -s. icu/data 669 * The user cannot mix notations like 670 * genrb -s. /icu/data --- the absolute path specified. -s redundant 671 * user should use 672 * genrb -s. icu/data --- start from CWD and look in icu/data dir 673 */ 674 if( (fileName[0] != U_FILE_SEP_CHAR) && (inputDir[dirlen-1] !='.')){ 675 uprv_strcpy(target, inputDir); 676 target[dirlen] = U_FILE_SEP_CHAR; 677 } 678 target[dirlen + 1] = '\0'; 679 } else { 680 requiredLen = dirlen + filelen + 1; 681 if((*len < requiredLen) || target==NULL){ 682 *len = requiredLen; 683 *status = U_BUFFER_OVERFLOW_ERROR; 684 return NULL; 685 } 686 687 uprv_strcpy(target, inputDir); 688 } 689 690 uprv_strcat(target, fileName); 691 return target; 692 } 693 /* 694 * Unicode TR 13 says any of the below chars is 695 * a new line char in a readline function in addition 696 * to CR+LF combination which needs to be 697 * handled seperately 698 */ 699 static UBool ucbuf_isCharNewLine(UChar c){ 700 switch(c){ 701 case 0x000A: /* LF */ 702 case 0x000D: /* CR */ 703 case 0x000C: /* FF */ 704 case 0x0085: /* NEL */ 705 case 0x2028: /* LS */ 706 case 0x2029: /* PS */ 707 return TRUE; 708 default: 709 return FALSE; 710 } 711 } 712 713 U_CAPI const UChar* U_EXPORT2 714 ucbuf_readline(UCHARBUF* buf,int32_t* len,UErrorCode* err){ 715 UChar* temp = buf->currentPos; 716 UChar* savePos =NULL; 717 UChar c=0x0000; 718 if(buf->isBuffered){ 719 /* The input is buffered we have to do more 720 * for returning a pointer U_TRUNCATED_CHAR_FOUND 721 */ 722 for(;;){ 723 c = *temp++; 724 if(buf->remaining==0){ 725 return NULL; /* end of file is reached return NULL */ 726 } 727 if(temp>=buf->bufLimit && buf->currentPos == buf->buffer){ 728 *err= U_TRUNCATED_CHAR_FOUND; 729 return NULL; 730 }else{ 731 ucbuf_fillucbuf(buf,err); 732 if(U_FAILURE(*err)){ 733 return NULL; 734 } 735 } 736 /* 737 * Accoding to TR 13 readLine functions must interpret 738 * CR, CR+LF, LF, NEL, PS, LS or FF as line seperators 739 */ 740 /* Windows CR LF */ 741 if(c ==0x0d && temp+1<=buf->bufLimit && *(temp+1) == 0x0a ){ 742 *len = (int32_t)(temp++ - buf->currentPos); 743 savePos = buf->currentPos; 744 buf->currentPos = temp; 745 return savePos; 746 } 747 /* else */ 748 749 if (temp>=buf->bufLimit|| ucbuf_isCharNewLine(c)){ /* Unipad inserts 2028 line separators! */ 750 *len = (int32_t)(temp - buf->currentPos); 751 savePos = buf->currentPos; 752 buf->currentPos = temp; 753 return savePos; 754 } 755 } 756 }else{ 757 /* we know that all input is read into the internal 758 * buffer so we can safely return pointers 759 */ 760 for(;;){ 761 c = *temp++; 762 763 if(buf->currentPos==buf->bufLimit){ 764 return NULL; /* end of file is reached return NULL */ 765 } 766 /* Windows CR LF */ 767 if(c ==0x0d && temp+1<=buf->bufLimit && *(temp+1) == 0x0a ){ 768 *len = (int32_t)(temp++ - buf->currentPos); 769 savePos = buf->currentPos; 770 buf->currentPos = temp; 771 return savePos; 772 } 773 /* else */ 774 if (temp>=buf->bufLimit|| ucbuf_isCharNewLine(c)) { /* Unipad inserts 2028 line separators! */ 775 *len = (int32_t)(temp - buf->currentPos); 776 savePos = buf->currentPos; 777 buf->currentPos = temp; 778 return savePos; 779 } 780 } 781 } 782 /* not reached */ 783 /* A compiler warning will appear if all paths don't contain a return statement. */ 784 /* return NULL;*/ 785 } 786 #endif 787
