Check in the pristine copy of ICU 4.6...

icu46/source/tools/toolutil/unewdata.c

+/*
+*******************************************************************************
+*
+*   Copyright (C) 1999-2010, International Business Machines
+*   Corporation and others.  All Rights Reserved.
+*
+*******************************************************************************
+*   file name:  unewdata.c
+*   encoding:   US-ASCII
+*   tab size:   8 (not used)
+*   indentation:4
+*
+*   created on: 1999oct25
+*   created by: Markus W. Scherer
+*/
+
+#include <stdio.h>
+#include "unicode/utypes.h"
+#include "unicode/putil.h"
+#include "unicode/ustring.h"
+#include "cmemory.h"
+#include "cstring.h"
+#include "filestrm.h"
+#include "unicode/udata.h"
+#include "unewdata.h"
+
+struct UNewDataMemory {
+    FileStream *file;
+    uint16_t headerSize;
+    uint8_t magic1, magic2;
+};
+
+U_CAPI UNewDataMemory * U_EXPORT2
+udata_create(const char *dir, const char *type, const char *name,
+             const UDataInfo *pInfo,
+             const char *comment,
+             UErrorCode *pErrorCode) {
+    UNewDataMemory *pData;
+    uint16_t headerSize, commentLength;
+    char filename[512];
+    uint8_t bytes[16];
+    int length;
+
+    if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
+        return NULL;
+    } else if(name==NULL || *name==0 || pInfo==NULL) {
+        *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
+        return NULL;
+    }
+
+    /* allocate the data structure */
+    pData=(UNewDataMemory *)uprv_malloc(sizeof(UNewDataMemory));
+    if(pData==NULL) {
+        *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
+        return NULL;
+    }
+    
+    /* Check that the full path won't be too long */
+    length = 0;                                 /* Start with nothing */
+    if(dir != NULL  && *dir !=0)        /* Add directory length if one was given */
+    {
+        length += strlen(dir);
+        
+        /* Add 1 if dir doesn't end with path sep */
+        if (dir[strlen(dir) - 1]!= U_FILE_SEP_CHAR) {
+            length++;
+        }
+        }
+    length += strlen(name);             /* Add the filename length */
+
+    if(type != NULL  && *type !=0) { /* Add directory length if  given */
+        length += strlen(type);
+    }
+
+        
+     /* LDH buffer Length error check */
+    if(length  > (sizeof(filename) - 1))
+    {
+            *pErrorCode = U_BUFFER_OVERFLOW_ERROR;
+            uprv_free(pData);
+            return NULL;
+    }
+   
+    /* open the output file */
+    if(dir!=NULL && *dir!=0) { /* if dir has a value, we prepend it to the filename */
+        char *p=filename+strlen(dir);
+        uprv_strcpy(filename, dir);
+        if (*(p-1)!=U_FILE_SEP_CHAR) {
+            *p++=U_FILE_SEP_CHAR;
+            *p=0;
+        }
+    } else { /* otherwise, we'll output to the current dir */
+        filename[0]=0;
+    }
+    uprv_strcat(filename, name);
+    if(type!=NULL && *type!=0) {
+        uprv_strcat(filename, ".");
+        uprv_strcat(filename, type);
+    }
+    pData->file=T_FileStream_open(filename, "wb");
+    if(pData->file==NULL) {
+        uprv_free(pData);
+        *pErrorCode=U_FILE_ACCESS_ERROR;
+        return NULL;
+    }
+
+    /* write the header information */
+    headerSize=(uint16_t)(pInfo->size+4);
+    if(comment!=NULL && *comment!=0) {
+        commentLength=(uint16_t)(uprv_strlen(comment)+1);
+        headerSize+=commentLength;
+    } else {
+        commentLength=0;
+    }
+
+    /* write the size of the header, take padding into account */
+    pData->headerSize=(uint16_t)((headerSize+15)&~0xf);
+    pData->magic1=0xda;
+    pData->magic2=0x27;
+    T_FileStream_write(pData->file, &pData->headerSize, 4);
+
+    /* write the information data */
+    T_FileStream_write(pData->file, pInfo, pInfo->size);
+
+    /* write the comment */
+    if(commentLength>0) {
+        T_FileStream_write(pData->file, comment, commentLength);
+    }
+
+    /* write padding bytes to align the data section to 16 bytes */
+    headerSize&=0xf;
+    if(headerSize!=0) {
+        headerSize=(uint16_t)(16-headerSize);
+        uprv_memset(bytes, 0, headerSize);
+        T_FileStream_write(pData->file, bytes, headerSize);
+    }
+
+    return pData;
+}
+
+U_CAPI uint32_t U_EXPORT2
+udata_finish(UNewDataMemory *pData, UErrorCode *pErrorCode) {
+    uint32_t fileLength=0;
+
+    if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
+        return 0;
+    }
+
+    if(pData!=NULL) {
+        if(pData->file!=NULL) {
+            /* fflush(pData->file);*/
+            fileLength=T_FileStream_size(pData->file);
+            if(T_FileStream_error(pData->file)) {
+                *pErrorCode=U_FILE_ACCESS_ERROR;
+            } else {
+                fileLength-=pData->headerSize;
+            }
+            T_FileStream_close(pData->file);
+        }
+        uprv_free(pData);
+    }
+
+    return fileLength;
+}
+
+/* dummy UDataInfo cf. udata.h */
+static const UDataInfo dummyDataInfo = {
+    sizeof(UDataInfo),
+    0,
+
+    U_IS_BIG_ENDIAN,
+    U_CHARSET_FAMILY,
+    U_SIZEOF_UCHAR,
+    0,
+
+    { 0, 0, 0, 0 },                 /* dummy dataFormat */
+    { 0, 0, 0, 0 },                 /* dummy formatVersion */
+    { 0, 0, 0, 0 }                  /* dummy dataVersion */
+};
+
+U_CAPI void U_EXPORT2
+udata_createDummy(const char *dir, const char *type, const char *name, UErrorCode *pErrorCode) {
+    if(U_SUCCESS(*pErrorCode)) {
+        udata_finish(udata_create(dir, type, name, &dummyDataInfo, NULL, pErrorCode), pErrorCode);
+        if(U_FAILURE(*pErrorCode)) {
+            fprintf(stderr, "error %s writing dummy data file %s" U_FILE_SEP_STRING "%s.%s\n",
+                    u_errorName(*pErrorCode), dir, name, type);
+            exit(*pErrorCode);
+        }
+    }
+}
+
+U_CAPI void U_EXPORT2
+udata_write8(UNewDataMemory *pData, uint8_t byte) {
+    if(pData!=NULL && pData->file!=NULL) {
+        T_FileStream_write(pData->file, &byte, 1);
+    }
+}
+
+U_CAPI void U_EXPORT2
+udata_write16(UNewDataMemory *pData, uint16_t word) {
+    if(pData!=NULL && pData->file!=NULL) {
+        T_FileStream_write(pData->file, &word, 2);
+    }
+}
+
+U_CAPI void U_EXPORT2
+udata_write32(UNewDataMemory *pData, uint32_t wyde) {
+    if(pData!=NULL && pData->file!=NULL) {
+        T_FileStream_write(pData->file, &wyde, 4);
+    }
+}
+
+U_CAPI void U_EXPORT2
+udata_writeBlock(UNewDataMemory *pData, const void *s, int32_t length) {
+    if(pData!=NULL && pData->file!=NULL) {
+        if(length>0) {
+            T_FileStream_write(pData->file, s, length);
+        }
+    }
+}
+
+U_CAPI void U_EXPORT2
+udata_writePadding(UNewDataMemory *pData, int32_t length) {
+    static const uint8_t padding[16]={
+        0xaa, 0xaa, 0xaa, 0xaa,
+        0xaa, 0xaa, 0xaa, 0xaa,
+        0xaa, 0xaa, 0xaa, 0xaa,
+        0xaa, 0xaa, 0xaa, 0xaa
+    };
+    if(pData!=NULL && pData->file!=NULL) {
+        while(length>=16) {
+            T_FileStream_write(pData->file, padding, 16);
+            length-=16;
+        }
+        if(length>0) {
+            T_FileStream_write(pData->file, padding, length);
+        }
+    }
+}
+
+U_CAPI void U_EXPORT2
+udata_writeString(UNewDataMemory *pData, const char *s, int32_t length) {
+    if(pData!=NULL && pData->file!=NULL) {
+        if(length==-1) {
+            length=(int32_t)uprv_strlen(s);
+        }
+        if(length>0) {
+            T_FileStream_write(pData->file, s, length);
+        }
+    }
+}
+
+U_CAPI void U_EXPORT2
+udata_writeUString(UNewDataMemory *pData, const UChar *s, int32_t length) {
+    if(pData!=NULL && pData->file!=NULL) {
+        if(length==-1) {
+            length=u_strlen(s);
+        }
+        if(length>0) {
+            T_FileStream_write(pData->file, s, length*sizeof(UChar));
+        }
+    }
+}
+
+/*
+ * Hey, Emacs, please set the following:
+ *
+ * Local Variables:
+ * indent-tabs-mode: nil
+ * End:
+ *
+ */
+