1/*
2*******************************************************************************
3*
4*   Copyright (C) 1999-2010, International Business Machines
5*   Corporation and others.  All Rights Reserved.
6*
7*******************************************************************************
8*   file name:  unewdata.c
9*   encoding:   US-ASCII
10*   tab size:   8 (not used)
11*   indentation:4
12*
13*   created on: 1999oct25
14*   created by: Markus W. Scherer
15*/
16
17#include <stdio.h>
18#include "unicode/utypes.h"
19#include "unicode/putil.h"
20#include "unicode/ustring.h"
21#include "cmemory.h"
22#include "cstring.h"
23#include "filestrm.h"
24#include "unicode/udata.h"
25#include "unewdata.h"
26
27struct UNewDataMemory {
28    FileStream *file;
29    uint16_t headerSize;
30    uint8_t magic1, magic2;
31};
32
33U_CAPI UNewDataMemory * U_EXPORT2
34udata_create(const char *dir, const char *type, const char *name,
35             const UDataInfo *pInfo,
36             const char *comment,
37             UErrorCode *pErrorCode) {
38    UNewDataMemory *pData;
39    uint16_t headerSize, commentLength;
40    char filename[512];
41    uint8_t bytes[16];
42    int length;
43
44    if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
45        return NULL;
46    } else if(name==NULL || *name==0 || pInfo==NULL) {
47        *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
48        return NULL;
49    }
50
51    /* allocate the data structure */
52    pData=(UNewDataMemory *)uprv_malloc(sizeof(UNewDataMemory));
53    if(pData==NULL) {
54        *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
55        return NULL;
56    }
57
58    /* Check that the full path won't be too long */
59    length = 0;					/* Start with nothing */
60    if(dir != NULL  && *dir !=0)	/* Add directory length if one was given */
61    {
62    	length += strlen(dir);
63
64    	/* Add 1 if dir doesn't end with path sep */
65        if (dir[strlen(dir) - 1]!= U_FILE_SEP_CHAR) {
66            length++;
67        }
68	}
69    length += strlen(name);		/* Add the filename length */
70
71    if(type != NULL  && *type !=0) { /* Add directory length if  given */
72        length += strlen(type);
73    }
74
75
76     /* LDH buffer Length error check */
77    if(length  > (sizeof(filename) - 1))
78    {
79   	    *pErrorCode = U_BUFFER_OVERFLOW_ERROR;
80   	    uprv_free(pData);
81	    return NULL;
82    }
83
84    /* open the output file */
85    if(dir!=NULL && *dir!=0) { /* if dir has a value, we prepend it to the filename */
86        char *p=filename+strlen(dir);
87        uprv_strcpy(filename, dir);
88        if (*(p-1)!=U_FILE_SEP_CHAR) {
89            *p++=U_FILE_SEP_CHAR;
90            *p=0;
91        }
92    } else { /* otherwise, we'll output to the current dir */
93        filename[0]=0;
94    }
95    uprv_strcat(filename, name);
96    if(type!=NULL && *type!=0) {
97        uprv_strcat(filename, ".");
98        uprv_strcat(filename, type);
99    }
100    pData->file=T_FileStream_open(filename, "wb");
101    if(pData->file==NULL) {
102        uprv_free(pData);
103        *pErrorCode=U_FILE_ACCESS_ERROR;
104        return NULL;
105    }
106
107    /* write the header information */
108    headerSize=(uint16_t)(pInfo->size+4);
109    if(comment!=NULL && *comment!=0) {
110        commentLength=(uint16_t)(uprv_strlen(comment)+1);
111        headerSize+=commentLength;
112    } else {
113        commentLength=0;
114    }
115
116    /* write the size of the header, take padding into account */
117    pData->headerSize=(uint16_t)((headerSize+15)&~0xf);
118    pData->magic1=0xda;
119    pData->magic2=0x27;
120    T_FileStream_write(pData->file, &pData->headerSize, 4);
121
122    /* write the information data */
123    T_FileStream_write(pData->file, pInfo, pInfo->size);
124
125    /* write the comment */
126    if(commentLength>0) {
127        T_FileStream_write(pData->file, comment, commentLength);
128    }
129
130    /* write padding bytes to align the data section to 16 bytes */
131    headerSize&=0xf;
132    if(headerSize!=0) {
133        headerSize=(uint16_t)(16-headerSize);
134        uprv_memset(bytes, 0, headerSize);
135        T_FileStream_write(pData->file, bytes, headerSize);
136    }
137
138    return pData;
139}
140
141U_CAPI uint32_t U_EXPORT2
142udata_finish(UNewDataMemory *pData, UErrorCode *pErrorCode) {
143    uint32_t fileLength=0;
144
145    if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
146        return 0;
147    }
148
149    if(pData!=NULL) {
150        if(pData->file!=NULL) {
151            /* fflush(pData->file);*/
152            fileLength=T_FileStream_size(pData->file);
153            if(T_FileStream_error(pData->file)) {
154                *pErrorCode=U_FILE_ACCESS_ERROR;
155            } else {
156                fileLength-=pData->headerSize;
157            }
158            T_FileStream_close(pData->file);
159        }
160        uprv_free(pData);
161    }
162
163    return fileLength;
164}
165
166/* dummy UDataInfo cf. udata.h */
167static const UDataInfo dummyDataInfo = {
168    sizeof(UDataInfo),
169    0,
170
171    U_IS_BIG_ENDIAN,
172    U_CHARSET_FAMILY,
173    U_SIZEOF_UCHAR,
174    0,
175
176    { 0, 0, 0, 0 },                 /* dummy dataFormat */
177    { 0, 0, 0, 0 },                 /* dummy formatVersion */
178    { 0, 0, 0, 0 }                  /* dummy dataVersion */
179};
180
181U_CAPI void U_EXPORT2
182udata_createDummy(const char *dir, const char *type, const char *name, UErrorCode *pErrorCode) {
183    if(U_SUCCESS(*pErrorCode)) {
184        udata_finish(udata_create(dir, type, name, &dummyDataInfo, NULL, pErrorCode), pErrorCode);
185        if(U_FAILURE(*pErrorCode)) {
186            fprintf(stderr, "error %s writing dummy data file %s" U_FILE_SEP_STRING "%s.%s\n",
187                    u_errorName(*pErrorCode), dir, name, type);
188            exit(*pErrorCode);
189        }
190    }
191}
192
193U_CAPI void U_EXPORT2
194udata_write8(UNewDataMemory *pData, uint8_t byte) {
195    if(pData!=NULL && pData->file!=NULL) {
196        T_FileStream_write(pData->file, &byte, 1);
197    }
198}
199
200U_CAPI void U_EXPORT2
201udata_write16(UNewDataMemory *pData, uint16_t word) {
202    if(pData!=NULL && pData->file!=NULL) {
203        T_FileStream_write(pData->file, &word, 2);
204    }
205}
206
207U_CAPI void U_EXPORT2
208udata_write32(UNewDataMemory *pData, uint32_t wyde) {
209    if(pData!=NULL && pData->file!=NULL) {
210        T_FileStream_write(pData->file, &wyde, 4);
211    }
212}
213
214U_CAPI void U_EXPORT2
215udata_writeBlock(UNewDataMemory *pData, const void *s, int32_t length) {
216    if(pData!=NULL && pData->file!=NULL) {
217        if(length>0) {
218            T_FileStream_write(pData->file, s, length);
219        }
220    }
221}
222
223U_CAPI void U_EXPORT2
224udata_writePadding(UNewDataMemory *pData, int32_t length) {
225    static const uint8_t padding[16]={
226        0xaa, 0xaa, 0xaa, 0xaa,
227        0xaa, 0xaa, 0xaa, 0xaa,
228        0xaa, 0xaa, 0xaa, 0xaa,
229        0xaa, 0xaa, 0xaa, 0xaa
230    };
231    if(pData!=NULL && pData->file!=NULL) {
232        while(length>=16) {
233            T_FileStream_write(pData->file, padding, 16);
234            length-=16;
235        }
236        if(length>0) {
237            T_FileStream_write(pData->file, padding, length);
238        }
239    }
240}
241
242U_CAPI void U_EXPORT2
243udata_writeString(UNewDataMemory *pData, const char *s, int32_t length) {
244    if(pData!=NULL && pData->file!=NULL) {
245        if(length==-1) {
246            length=(int32_t)uprv_strlen(s);
247        }
248        if(length>0) {
249            T_FileStream_write(pData->file, s, length);
250        }
251    }
252}
253
254U_CAPI void U_EXPORT2
255udata_writeUString(UNewDataMemory *pData, const UChar *s, int32_t length) {
256    if(pData!=NULL && pData->file!=NULL) {
257        if(length==-1) {
258            length=u_strlen(s);
259        }
260        if(length>0) {
261            T_FileStream_write(pData->file, s, length*sizeof(UChar));
262        }
263    }
264}
265
266/*
267 * Hey, Emacs, please set the following:
268 *
269 * Local Variables:
270 * indent-tabs-mode: nil
271 * End:
272 *
273 */
274
275