Home | History | Annotate | Download | only in intltest 
      1 /*
      2 **********************************************************************
      3 * Copyright (c) 2004, International Business Machines
      4 * Corporation and others.  All Rights Reserved.
      5 **********************************************************************
      6 * Author: Alan Liu
      7 * Created: March 19 2004
      8 * Since: ICU 3.0
      9 **********************************************************************
     10 */
     11 #include "textfile.h"
     12 #include "cmemory.h"
     13 #include "cstring.h"
     14 #include "intltest.h"
     15 #include "util.h"
     16 
     17 // If the symbol CCP is defined, then the 'name' and 'encoding'
     18 // constructor parameters are copied.  Otherwise they are aliased.
     19 // #define CCP
     20 
     21 TextFile::TextFile(const char* _name, const char* _encoding, UErrorCode& ec) :
     22     file(0),
     23     name(0), encoding(0),
     24     buffer(0),
     25     capacity(0),
     26     lineNo(0)
     27 {
     28     if (U_FAILURE(ec) || _name == 0 || _encoding == 0) {
     29         if (U_SUCCESS(ec)) {
     30             ec = U_ILLEGAL_ARGUMENT_ERROR;
     31         }
     32         return;
     33     }
     34 
     35 #ifdef CCP
     36     name = uprv_malloc(uprv_strlen(_name) + 1);
     37     encoding = uprv_malloc(uprv_strlen(_encoding) + 1);
     38     if (name == 0 || encoding == 0) {
     39         ec = U_MEMORY_ALLOCATION_ERROR;
     40         return;
     41     }
     42     uprv_strcpy(name, _name);
     43     uprv_strcpy(encoding, _encoding);
     44 #else
     45     name = (char*) _name;
     46     encoding = (char*) _encoding;
     47 #endif
     48 
     49     const char* testDir = IntlTest::getSourceTestData(ec);
     50     if (U_FAILURE(ec)) {
     51         return;
     52     }
     53     if (!ensureCapacity((int32_t)(uprv_strlen(testDir) + uprv_strlen(name) + 1))) {
     54         ec = U_MEMORY_ALLOCATION_ERROR;
     55         return;
     56     }
     57     uprv_strcpy(buffer, testDir);
     58     uprv_strcat(buffer, name);
     59 
     60     file = T_FileStream_open(buffer, "rb");
     61     if (file == 0) {
     62         ec = U_ILLEGAL_ARGUMENT_ERROR;
     63         return;
     64     }
     65 }
     66 
     67 TextFile::~TextFile() {
     68     if (file != 0) T_FileStream_close(file);
     69     if (buffer != 0) uprv_free(buffer);
     70 #ifdef CCP
     71     uprv_free(name);
     72     uprv_free(encoding);
     73 #endif
     74 }
     75 
     76 UBool TextFile::readLine(UnicodeString& line, UErrorCode& ec) {
     77     if (T_FileStream_eof(file)) {
     78         return FALSE;
     79     }
     80     // Note: 'buffer' may change after ensureCapacity() is called,
     81     // so don't use
     82     //   p=buffer; *p++=c;
     83     // but rather
     84     //   i=; buffer[i++]=c;
     85     int32_t n = 0;
     86     for (;;) {
     87         int c = T_FileStream_getc(file); // sic: int, not int32_t
     88         if (c < 0 || c == 0xD || c == 0xA) {
     89             // consume 0xA following 0xD
     90             if (c == 0xD) {
     91                 c = T_FileStream_getc(file);
     92                 if (c != 0xA && c >= 0) {
     93                     T_FileStream_ungetc(c, file);
     94                 }
     95             }
     96             break;
     97         }
     98         if (!setBuffer(n++, c, ec)) return FALSE;
     99     }
    100     if (!setBuffer(n++, 0, ec)) return FALSE;
    101     UnicodeString str(buffer, encoding);
    102     // Remove BOM in first line, if present
    103     if (lineNo == 0 && str[0] == 0xFEFF) {
    104         str.remove(0, 1);
    105     }
    106     ++lineNo;
    107     line = str.unescape();
    108     return TRUE;
    109 }
    110 
    111 UBool TextFile::readLineSkippingComments(UnicodeString& line, UErrorCode& ec,
    112                                          UBool trim) {
    113     for (;;) {
    114         if (!readLine(line, ec)) return FALSE;
    115         // Skip over white space
    116         int32_t pos = 0;
    117         ICU_Utility::skipWhitespace(line, pos, TRUE);
    118         // Ignore blank lines and comment lines
    119         if (pos == line.length() || line.charAt(pos) == 0x23/*'#'*/) {
    120             continue;
    121         }
    122         // Process line
    123         if (trim) line.remove(0, pos);
    124         return TRUE;
    125     }
    126 }
    127 
    128 /**
    129  * Set buffer[index] to c, growing buffer if necessary. Return TRUE if
    130  * successful.
    131  */
    132 UBool TextFile::setBuffer(int32_t index, char c, UErrorCode& ec) {
    133     if (capacity <= index) {
    134         if (!ensureCapacity(index+1)) {
    135             ec = U_MEMORY_ALLOCATION_ERROR;
    136             return FALSE;
    137         }
    138     }
    139     buffer[index] = c;
    140     return TRUE;
    141 }
    142 
    143 /**
    144  * Make sure that 'buffer' has at least 'mincapacity' bytes.
    145  * Return TRUE upon success. Upon return, 'buffer' may change
    146  * value. In any case, previous contents are preserved.
    147  */
    148 UBool TextFile::ensureCapacity(int32_t mincapacity) {
    149     if (capacity >= mincapacity) {
    150         return TRUE;
    151     }
    152 
    153     // Grow by factor of 2 to prevent frequent allocation
    154     // Note: 'capacity' may be 0
    155     int32_t i;
    156     for (i = capacity || 1024; i < mincapacity; ) {
    157         i <<= 1;
    158         if (i < 0) {
    159             i = 0x7FFFFFFF;
    160             break;
    161         }
    162     }
    163     mincapacity = i;
    164 
    165     // Simple realloc() no good; contents not preserved
    166     // Note: 'buffer' may be 0
    167     char* newbuffer = (char*) uprv_malloc(mincapacity);
    168     if (newbuffer == 0) {
    169         return FALSE;
    170     }
    171     if (buffer != 0) {
    172         uprv_strncpy(newbuffer, buffer, capacity);
    173         uprv_free(buffer);
    174     }
    175     buffer = newbuffer;
    176     capacity = mincapacity;
    177     return TRUE;
    178 }
    179 
    180