[apple/icu.git] / icuSources / tools / toolutil / unewdata.cpp

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
*
*   Copyright (C) 1999-2010, International Business Machines
*   Corporation and others.  All Rights Reserved.
*
*******************************************************************************
*   file name:  unewdata.c
*   encoding:   UTF-8
*   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];
    int32_t 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 += static_cast<int32_t>(strlen(dir));
	
    	/* Add 1 if dir doesn't end with path sep */
        if (dir[strlen(dir) - 1]!= U_FILE_SEP_CHAR) {
            length++;
        }
	}
    length += static_cast<int32_t>(strlen(name));		/* Add the filename length */

    if(type != NULL  && *type !=0) { /* Add directory length if  given */
        length += static_cast<int32_t>(strlen(type));
    }

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