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