icuSources/test/intltest/textfile.cpp

   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