icuSources/tools/toolutil/ucbuf.c

   1 /*
   2 *******************************************************************************
   3 *
   4 *   Copyright (C) 1998-2014, 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/uchar.h"
  21 #include "unicode/ucnv.h"
  22 #include "unicode/ucnv_err.h"
  23 #include "unicode/ustring.h"
  24 #include "unicode/utf16.h"
  25 #include "filestrm.h"
  26 #include "cstring.h"
  27 #include "cmemory.h"
  28 #include "ustrfmt.h"
  29 #include "ucbuf.h"
  30 #include <stdio.h>
  31
  32 #if !UCONFIG_NO_CONVERSION
  33
  34
  35 #define MAX_IN_BUF 1000
  36 #define MAX_U_BUF 1500
  37 #define CONTEXT_LEN 20
  38
  39 struct UCHARBUF {
  40     UChar* buffer;
  41     UChar* currentPos;
  42     UChar* bufLimit;
  43     int32_t bufCapacity;
  44     int32_t remaining;
  45     int32_t signatureLength;
  46     FileStream* in;
  47     UConverter* conv;
  48     UBool showWarning; /* makes this API not produce any errors */
  49     UBool isBuffered;
  50 };
  51
  52 U_CAPI UBool U_EXPORT2
  53 ucbuf_autodetect_fs(FileStream* in, const char** cp, UConverter** conv, int32_t* signatureLength, UErrorCode* error){
  54     char start[8];
  55     int32_t numRead;
  56
  57     UChar target[1]={ 0 };
  58     UChar* pTarget;
  59     const char* pStart;
  60
  61     /* read a few bytes */
  62     numRead=T_FileStream_read(in, start, sizeof(start));
  63
  64     *cp = ucnv_detectUnicodeSignature(start, numRead, signatureLength, error);
  65
  66     /* unread the bytes beyond what was consumed for U+FEFF */
  67     T_FileStream_rewind(in);
  68     if (*signatureLength > 0) {
  69         T_FileStream_read(in, start, *signatureLength);
  70     }
  71
  72     if(*cp==NULL){
  73         *conv =NULL;
  74         return FALSE;
  75     }
  76
  77     /* open the converter for the detected Unicode charset */
  78     *conv = ucnv_open(*cp,error);
  79
  80     /* convert and ignore initial U+FEFF, and the buffer overflow */
  81     pTarget = target;
  82     pStart = start;
  83     ucnv_toUnicode(*conv, &pTarget, target+1, &pStart, start+*signatureLength, NULL, FALSE, error);
  84     *signatureLength = (int32_t)(pStart - start);
  85     if(*error==U_BUFFER_OVERFLOW_ERROR) {
  86         *error=U_ZERO_ERROR;
  87     }
  88
  89     /* verify that we successfully read exactly U+FEFF */
  90     if(U_SUCCESS(*error) && (pTarget!=(target+1) || target[0]!=0xfeff)) {
  91         *error=U_INTERNAL_PROGRAM_ERROR;
  92     }
  93
  94
  95     return TRUE;
  96 }
  97 static UBool ucbuf_isCPKnown(const char* cp){
  98     if(ucnv_compareNames("UTF-8",cp)==0){
  99         return TRUE;
 100     }
 101     if(ucnv_compareNames("UTF-16BE",cp)==0){
 102         return TRUE;
 103     }
 104     if(ucnv_compareNames("UTF-16LE",cp)==0){
 105         return TRUE;
 106     }
 107     if(ucnv_compareNames("UTF-16",cp)==0){
 108         return TRUE;
 109     }
 110     if(ucnv_compareNames("UTF-32",cp)==0){
 111         return TRUE;
 112     }
 113     if(ucnv_compareNames("UTF-32BE",cp)==0){
 114         return TRUE;
 115     }
 116     if(ucnv_compareNames("UTF-32LE",cp)==0){
 117         return TRUE;
 118     }
 119     if(ucnv_compareNames("SCSU",cp)==0){
 120         return TRUE;
 121     }
 122     if(ucnv_compareNames("BOCU-1",cp)==0){
 123         return TRUE;
 124     }
 125     if(ucnv_compareNames("UTF-7",cp)==0){
 126         return TRUE;
 127     }
 128     return FALSE;
 129 }
 130
 131 U_CAPI FileStream * U_EXPORT2
 132 ucbuf_autodetect(const char* fileName, const char** cp,UConverter** conv, int32_t* signatureLength,UErrorCode* error){
 133     FileStream* in=NULL;
 134     if(error==NULL || U_FAILURE(*error)){
 135         return NULL;
 136     }
 137     if(conv==NULL || cp==NULL || fileName==NULL){
 138         *error = U_ILLEGAL_ARGUMENT_ERROR;
 139         return NULL;
 140     }
 141     /* open the file */
 142     in= T_FileStream_open(fileName,"rb");
 143
 144     if(in == NULL){
 145         *error=U_FILE_ACCESS_ERROR;
 146         return NULL;
 147     }
 148
 149     if(ucbuf_autodetect_fs(in,cp,conv,signatureLength,error)) {
 150         return in;
 151     } else {
 152         ucnv_close(*conv);
 153         *conv=NULL;
 154         T_FileStream_close(in);
 155         return NULL;
 156     }
 157 }
 158
 159 /* fill the uchar buffer */
 160 static UCHARBUF*
 161 ucbuf_fillucbuf( UCHARBUF* buf,UErrorCode* error){
 162     UChar* pTarget=NULL;
 163     UChar* target=NULL;
 164     const char* source=NULL;
 165     char  carr[MAX_IN_BUF] = {'\0'};
 166     char* cbuf =  carr;
 167     int32_t inputRead=0;
 168     int32_t outputWritten=0;
 169     int32_t offset=0;
 170     const char* sourceLimit =NULL;
 171     int32_t cbufSize=0;
 172     pTarget = buf->buffer;
 173     /* check if we arrived here without exhausting the buffer*/
 174     if(buf->currentPos<buf->bufLimit){
 175         offset = (int32_t)(buf->bufLimit-buf->currentPos);
 176         memmove(buf->buffer,buf->currentPos,offset* sizeof(UChar));
 177     }
 178
 179 #if UCBUF_DEBUG
 180     memset(pTarget+offset,0xff,sizeof(UChar)*(MAX_IN_BUF-offset));
 181 #endif
 182     if(buf->isBuffered){
 183         cbufSize = MAX_IN_BUF;
 184         /* read the file */
 185         inputRead=T_FileStream_read(buf->in,cbuf,cbufSize-offset);
 186         buf->remaining-=inputRead;
 187
 188     }else{
 189         cbufSize = T_FileStream_size(buf->in);
 190         cbuf = (char*)uprv_malloc(cbufSize);
 191         if (cbuf == NULL) {
 192                 *error = U_MEMORY_ALLOCATION_ERROR;
 193                 return NULL;
 194         }
 195         inputRead= T_FileStream_read(buf->in,cbuf,cbufSize);
 196         buf->remaining-=inputRead;
 197     }
 198
 199     /* just to be sure...*/
 200     if ( 0 == inputRead )
 201        buf->remaining = 0;
 202
 203     target=pTarget;
 204     /* convert the bytes */
 205     if(buf->conv){
 206         /* set the callback to stop */
 207         UConverterToUCallback toUOldAction ;
 208         void* toUOldContext;
 209         void* toUNewContext=NULL;
 210         ucnv_setToUCallBack(buf->conv,
 211            UCNV_TO_U_CALLBACK_STOP,
 212            toUNewContext,
 213            &toUOldAction,
 214            (const void**)&toUOldContext,
 215            error);
 216         /* since state is saved in the converter we add offset to source*/
 217         target = pTarget+offset;
 218         source = cbuf;
 219         sourceLimit = source + inputRead;
 220         ucnv_toUnicode(buf->conv,&target,target+(buf->bufCapacity-offset),
 221                         &source,sourceLimit,NULL,
 222                         (UBool)(buf->remaining==0),error);
 223
 224         if(U_FAILURE(*error)){
 225             char context[CONTEXT_LEN+1];
 226             char preContext[CONTEXT_LEN+1];
 227             char postContext[CONTEXT_LEN+1];
 228             int8_t len = CONTEXT_LEN;
 229             int32_t start=0;
 230             int32_t stop =0;
 231             int32_t pos =0;
 232             /* use erro1 to preserve the error code */
 233             UErrorCode error1 =U_ZERO_ERROR;
 234
 235             if( buf->showWarning==TRUE){
 236                 fprintf(stderr,"\n###WARNING: Encountered abnormal bytes while"
 237                                " converting input stream to target encoding: %s\n",
 238                                u_errorName(*error));
 239             }
 240
 241
 242             /* now get the context chars */
 243             ucnv_getInvalidChars(buf->conv,context,&len,&error1);
 244             context[len]= 0 ; /* null terminate the buffer */
 245
 246             pos = (int32_t)(source - cbuf - len);
 247
 248             /* for pre-context */
 249             start = (pos <=CONTEXT_LEN)? 0 : (pos - (CONTEXT_LEN-1));
 250             stop  = pos-len;
 251
 252             memcpy(preContext,cbuf+start,stop-start);
 253             /* null terminate the buffer */
 254             preContext[stop-start] = 0;
 255
 256             /* for post-context */
 257             start = pos+len;
 258             stop  = (int32_t)(((pos+CONTEXT_LEN)<= (sourceLimit-cbuf) )? (pos+(CONTEXT_LEN-1)) : (sourceLimit-cbuf));
 259
 260             memcpy(postContext,source,stop-start);
 261             /* null terminate the buffer */
 262             postContext[stop-start] = 0;
 263
 264             if(buf->showWarning ==TRUE){
 265                 /* print out the context */
 266                 fprintf(stderr,"\tPre-context: %s\n",preContext);
 267                 fprintf(stderr,"\tContext: %s\n",context);
 268                 fprintf(stderr,"\tPost-context: %s\n", postContext);
 269             }
 270
 271             /* reset the converter */
 272             ucnv_reset(buf->conv);
 273
 274             /* set the call back to substitute
 275              * and restart conversion
 276              */
 277             ucnv_setToUCallBack(buf->conv,
 278                UCNV_TO_U_CALLBACK_SUBSTITUTE,
 279                toUNewContext,
 280                &toUOldAction,
 281                (const void**)&toUOldContext,
 282                &error1);
 283
 284             /* reset source and target start positions */
 285             target = pTarget+offset;
 286             source = cbuf;
 287
 288             /* re convert */
 289             ucnv_toUnicode(buf->conv,&target,target+(buf->bufCapacity-offset),
 290                             &source,sourceLimit,NULL,
 291                             (UBool)(buf->remaining==0),&error1);
 292
 293         }
 294         outputWritten = (int32_t)(target - pTarget);
 295
 296 #if UCBUF_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(U16_IS_LEAD(*(buf->currentPos))){
 357         retVal=U16_GET_SUPPLEMENTARY(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 <= buf->bufLimit && *temp == 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 <= buf->bufLimit && *temp == 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