mirror of
https://github.com/unicode-org/icu.git
synced 2025-04-06 22:15:31 +00:00
515 lines
16 KiB
C++
515 lines
16 KiB
C++
// © 2016 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
/*
|
|
*******************************************************************************
|
|
*
|
|
* Copyright (C) 2005-2012, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
*
|
|
*******************************************************************************
|
|
* file name: writesrc.c
|
|
* encoding: UTF-8
|
|
* tab size: 8 (not used)
|
|
* indentation:4
|
|
*
|
|
* created on: 2005apr23
|
|
* created by: Markus W. Scherer
|
|
*
|
|
* Helper functions for writing source code for data.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <time.h>
|
|
|
|
// The C99 standard suggested that C++ implementations not define PRId64 etc. constants
|
|
// unless this macro is defined.
|
|
// See the Notes at https://en.cppreference.com/w/cpp/types/integer .
|
|
// Similar to defining __STDC_LIMIT_MACROS in unicode/ptypes.h .
|
|
#ifndef __STDC_FORMAT_MACROS
|
|
# define __STDC_FORMAT_MACROS
|
|
#endif
|
|
#include <cinttypes>
|
|
|
|
#include "unicode/utypes.h"
|
|
#include "unicode/putil.h"
|
|
#include "unicode/ucptrie.h"
|
|
#include "unicode/errorcode.h"
|
|
#include "unicode/uniset.h"
|
|
#include "unicode/usetiter.h"
|
|
#include "unicode/utf16.h"
|
|
#include "utrie2.h"
|
|
#include "cstring.h"
|
|
#include "writesrc.h"
|
|
#include "util.h"
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
ValueNameGetter::~ValueNameGetter() {}
|
|
|
|
U_NAMESPACE_END
|
|
|
|
U_NAMESPACE_USE
|
|
|
|
static FILE *
|
|
usrc_createWithoutHeader(const char *path, const char *filename) {
|
|
char buffer[1024];
|
|
const char *p;
|
|
char *q;
|
|
FILE *f;
|
|
char c;
|
|
|
|
if(path==nullptr) {
|
|
p=filename;
|
|
} else {
|
|
/* concatenate path and filename, with U_FILE_SEP_CHAR in between if necessary */
|
|
uprv_strcpy(buffer, path);
|
|
q=buffer+uprv_strlen(buffer);
|
|
if(q>buffer && (c=*(q-1))!=U_FILE_SEP_CHAR && c!=U_FILE_ALT_SEP_CHAR) {
|
|
*q++=U_FILE_SEP_CHAR;
|
|
}
|
|
uprv_strcpy(q, filename);
|
|
p=buffer;
|
|
}
|
|
|
|
f=fopen(p, "w");
|
|
if (f==nullptr) {
|
|
fprintf(
|
|
stderr,
|
|
"usrc_create(%s, %s): unable to create file\n",
|
|
path!=nullptr ? path : "", filename);
|
|
}
|
|
return f;
|
|
}
|
|
|
|
U_CAPI FILE * U_EXPORT2
|
|
usrc_create(const char *path, const char *filename, int32_t copyrightYear, const char *generator) {
|
|
FILE *f = usrc_createWithoutHeader(path, filename);
|
|
if (f == nullptr) {
|
|
return f;
|
|
}
|
|
usrc_writeCopyrightHeader(f, "//", copyrightYear);
|
|
usrc_writeFileNameGeneratedBy(f, "//", filename, generator);
|
|
return f;
|
|
}
|
|
|
|
U_CAPI FILE * U_EXPORT2
|
|
usrc_createTextData(const char *path, const char *filename, int32_t copyrightYear, const char *generator) {
|
|
FILE *f = usrc_createWithoutHeader(path, filename);
|
|
if (f == nullptr) {
|
|
return f;
|
|
}
|
|
usrc_writeCopyrightHeader(f, "#", copyrightYear);
|
|
usrc_writeFileNameGeneratedBy(f, "#", filename, generator);
|
|
return f;
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
usrc_writeCopyrightHeader(FILE *f, const char *prefix, int32_t copyrightYear) {
|
|
fprintf(f,
|
|
"%s Copyright (C) %d and later: Unicode, Inc. and others.\n"
|
|
"%s License & terms of use: http://www.unicode.org/copyright.html\n",
|
|
prefix, copyrightYear, prefix);
|
|
if (copyrightYear <= 2016) {
|
|
fprintf(f,
|
|
"%s Copyright (C) 1999-2016, International Business Machines\n"
|
|
"%s Corporation and others. All Rights Reserved.\n",
|
|
prefix, prefix);
|
|
}
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
usrc_writeFileNameGeneratedBy(
|
|
FILE *f,
|
|
const char *prefix,
|
|
const char *filename,
|
|
const char *generator) {
|
|
char buffer[1024];
|
|
const struct tm *lt;
|
|
time_t t;
|
|
|
|
const char *pattern =
|
|
"%s\n"
|
|
"%s file name: %s\n"
|
|
"%s\n"
|
|
"%s machine-generated by: %s\n"
|
|
"\n";
|
|
|
|
time(&t);
|
|
lt=localtime(&t);
|
|
if(generator==nullptr) {
|
|
strftime(buffer, sizeof(buffer), "%Y-%m-%d", lt);
|
|
fprintf(f, pattern, prefix, prefix, filename, prefix, prefix, buffer);
|
|
} else {
|
|
fprintf(f, pattern, prefix, prefix, filename, prefix, prefix, generator);
|
|
}
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
usrc_writeArray(FILE *f,
|
|
const char *prefix,
|
|
const void *p, int32_t width, int32_t length,
|
|
const char *indent,
|
|
const char *postfix) {
|
|
const uint8_t *p8;
|
|
const uint16_t *p16;
|
|
const uint32_t *p32;
|
|
const int64_t *p64; // Signed due to TOML!
|
|
int64_t value; // Signed due to TOML!
|
|
int32_t i, col;
|
|
|
|
p8=nullptr;
|
|
p16=nullptr;
|
|
p32=nullptr;
|
|
p64=nullptr;
|
|
switch(width) {
|
|
case 8:
|
|
p8=(const uint8_t *)p;
|
|
break;
|
|
case 16:
|
|
p16=(const uint16_t *)p;
|
|
break;
|
|
case 32:
|
|
p32=(const uint32_t *)p;
|
|
break;
|
|
case 64:
|
|
p64=(const int64_t *)p;
|
|
break;
|
|
default:
|
|
fprintf(stderr, "usrc_writeArray(width=%ld) unrecognized width\n", (long)width);
|
|
return;
|
|
}
|
|
if(prefix!=nullptr) {
|
|
fprintf(f, prefix, (long)length);
|
|
}
|
|
for(i=col=0; i<length; ++i, ++col) {
|
|
if(i>0) {
|
|
if(col<16) {
|
|
fputc(',', f);
|
|
} else {
|
|
fputs(",\n", f);
|
|
fputs(indent, f);
|
|
col=0;
|
|
}
|
|
}
|
|
switch(width) {
|
|
case 8:
|
|
value=p8[i];
|
|
break;
|
|
case 16:
|
|
value=p16[i];
|
|
break;
|
|
case 32:
|
|
value=p32[i];
|
|
break;
|
|
case 64:
|
|
value=p64[i];
|
|
break;
|
|
default:
|
|
value=0; /* unreachable */
|
|
break;
|
|
}
|
|
fprintf(f, value<=9 ? "%" PRId64 : "0x%" PRIx64, value);
|
|
}
|
|
if(postfix!=nullptr) {
|
|
fputs(postfix, f);
|
|
}
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
usrc_writeUTrie2Arrays(FILE *f,
|
|
const char *indexPrefix, const char *data32Prefix,
|
|
const UTrie2 *pTrie,
|
|
const char *postfix) {
|
|
if(pTrie->data32==nullptr) {
|
|
/* 16-bit trie */
|
|
usrc_writeArray(f, indexPrefix, pTrie->index, 16, pTrie->indexLength+pTrie->dataLength, "", postfix);
|
|
} else {
|
|
/* 32-bit trie */
|
|
usrc_writeArray(f, indexPrefix, pTrie->index, 16, pTrie->indexLength, "", postfix);
|
|
usrc_writeArray(f, data32Prefix, pTrie->data32, 32, pTrie->dataLength, "", postfix);
|
|
}
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
usrc_writeUTrie2Struct(FILE *f,
|
|
const char *prefix,
|
|
const UTrie2 *pTrie,
|
|
const char *indexName, const char *data32Name,
|
|
const char *postfix) {
|
|
if(prefix!=nullptr) {
|
|
fputs(prefix, f);
|
|
}
|
|
if(pTrie->data32==nullptr) {
|
|
/* 16-bit trie */
|
|
fprintf(
|
|
f,
|
|
" %s,\n" /* index */
|
|
" %s+%ld,\n" /* data16 */
|
|
" nullptr,\n", /* data32 */
|
|
indexName,
|
|
indexName,
|
|
(long)pTrie->indexLength);
|
|
} else {
|
|
/* 32-bit trie */
|
|
fprintf(
|
|
f,
|
|
" %s,\n" /* index */
|
|
" nullptr,\n" /* data16 */
|
|
" %s,\n", /* data32 */
|
|
indexName,
|
|
data32Name);
|
|
}
|
|
fprintf(
|
|
f,
|
|
" %ld,\n" /* indexLength */
|
|
" %ld,\n" /* dataLength */
|
|
" 0x%hx,\n" /* index2NullOffset */
|
|
" 0x%hx,\n" /* dataNullOffset */
|
|
" 0x%lx,\n" /* initialValue */
|
|
" 0x%lx,\n" /* errorValue */
|
|
" 0x%lx,\n" /* highStart */
|
|
" 0x%lx,\n" /* highValueIndex */
|
|
" nullptr, 0, false, false, 0, nullptr\n",
|
|
(long)pTrie->indexLength, (long)pTrie->dataLength,
|
|
(short)pTrie->index2NullOffset, (short)pTrie->dataNullOffset,
|
|
(long)pTrie->initialValue, (long)pTrie->errorValue,
|
|
(long)pTrie->highStart, (long)pTrie->highValueIndex);
|
|
if(postfix!=nullptr) {
|
|
fputs(postfix, f);
|
|
}
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
usrc_writeUCPTrieArrays(FILE *f,
|
|
const char *indexPrefix, const char *dataPrefix,
|
|
const UCPTrie *pTrie,
|
|
const char *postfix,
|
|
UTargetSyntax syntax) {
|
|
const char* indent = (syntax == UPRV_TARGET_SYNTAX_TOML) ? " " : "";
|
|
usrc_writeArray(f, indexPrefix, pTrie->index, 16, pTrie->indexLength, indent, postfix);
|
|
int32_t width=
|
|
pTrie->valueWidth==UCPTRIE_VALUE_BITS_16 ? 16 :
|
|
pTrie->valueWidth==UCPTRIE_VALUE_BITS_32 ? 32 :
|
|
pTrie->valueWidth==UCPTRIE_VALUE_BITS_8 ? 8 : 0;
|
|
usrc_writeArray(f, dataPrefix, pTrie->data.ptr0, width, pTrie->dataLength, indent, postfix);
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
usrc_writeUCPTrieStruct(FILE *f,
|
|
const char *prefix,
|
|
const UCPTrie *pTrie,
|
|
const char *indexName, const char *dataName,
|
|
const char *postfix,
|
|
UTargetSyntax syntax) {
|
|
if(prefix!=nullptr) {
|
|
fputs(prefix, f);
|
|
}
|
|
if (syntax == UPRV_TARGET_SYNTAX_CCODE) {
|
|
fprintf(
|
|
f,
|
|
" %s,\n" // index
|
|
" { %s },\n", // data (union)
|
|
indexName,
|
|
dataName);
|
|
}
|
|
const char* pattern =
|
|
(syntax == UPRV_TARGET_SYNTAX_CCODE) ?
|
|
" %ld, %ld,\n" // indexLength, dataLength
|
|
" 0x%lx, 0x%x,\n" // highStart, shifted12HighStart
|
|
" %d, %d,\n" // type, valueWidth
|
|
" 0, 0,\n" // reserved32, reserved16
|
|
" 0x%x, 0x%lx,\n" // index3NullOffset, dataNullOffset
|
|
" 0x%lx,\n" // nullValue
|
|
:
|
|
"indexLength = %ld\n"
|
|
"dataLength = %ld\n"
|
|
"highStart = 0x%lx\n"
|
|
"shifted12HighStart = 0x%x\n"
|
|
"type = %d\n"
|
|
"valueWidth = %d\n"
|
|
"index3NullOffset = 0x%x\n"
|
|
"dataNullOffset = 0x%lx\n"
|
|
"nullValue = 0x%lx\n"
|
|
;
|
|
fprintf(
|
|
f,
|
|
pattern,
|
|
(long)pTrie->indexLength, (long)pTrie->dataLength,
|
|
(long)pTrie->highStart, pTrie->shifted12HighStart,
|
|
pTrie->type, pTrie->valueWidth,
|
|
pTrie->index3NullOffset, (long)pTrie->dataNullOffset,
|
|
(long)pTrie->nullValue);
|
|
if(postfix!=nullptr) {
|
|
fputs(postfix, f);
|
|
}
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
usrc_writeUCPTrie(FILE *f, const char *name, const UCPTrie *pTrie, UTargetSyntax syntax) {
|
|
int32_t width=
|
|
pTrie->valueWidth==UCPTRIE_VALUE_BITS_16 ? 16 :
|
|
pTrie->valueWidth==UCPTRIE_VALUE_BITS_32 ? 32 :
|
|
pTrie->valueWidth==UCPTRIE_VALUE_BITS_8 ? 8 : 0;
|
|
char line[100], line2[100], line3[100], line4[100];
|
|
|
|
switch (syntax) {
|
|
case UPRV_TARGET_SYNTAX_CCODE:
|
|
snprintf(line, sizeof(line), "static const uint16_t %s_trieIndex[%%ld]={\n", name);
|
|
snprintf(line2, sizeof(line2), "static const uint%d_t %s_trieData[%%ld]={\n", (int)width, name);
|
|
snprintf(line3, sizeof(line3), "\n};\n\n");
|
|
break;
|
|
case UPRV_TARGET_SYNTAX_TOML:
|
|
snprintf(line, sizeof(line), "index = [\n ");
|
|
snprintf(line2, sizeof(line2), "data_%d = [\n ", (int)width);
|
|
snprintf(line3, sizeof(line3), "\n]\n");
|
|
break;
|
|
default:
|
|
UPRV_UNREACHABLE_EXIT;
|
|
}
|
|
usrc_writeUCPTrieArrays(f, line, line2, pTrie, line3, syntax);
|
|
|
|
switch (syntax) {
|
|
case UPRV_TARGET_SYNTAX_CCODE:
|
|
snprintf(line, sizeof(line), "static const UCPTrie %s_trie={\n", name);
|
|
snprintf(line2, sizeof(line2), "%s_trieIndex", name);
|
|
snprintf(line3, sizeof(line3), "%s_trieData", name);
|
|
snprintf(line4, sizeof(line4), "};\n\n");
|
|
break;
|
|
case UPRV_TARGET_SYNTAX_TOML:
|
|
line[0] = 0;
|
|
line2[0] = 0;
|
|
line3[0] = 0;
|
|
line4[0] = 0;
|
|
break;
|
|
default:
|
|
UPRV_UNREACHABLE_EXIT;
|
|
}
|
|
usrc_writeUCPTrieStruct(f, line, pTrie, line2, line3, line4, syntax);
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
usrc_writeUnicodeSet(
|
|
FILE *f,
|
|
const USet *pSet,
|
|
UTargetSyntax syntax) {
|
|
// ccode is not yet supported
|
|
U_ASSERT(syntax == UPRV_TARGET_SYNTAX_TOML);
|
|
|
|
// Write out a list of ranges
|
|
const UnicodeSet* set = UnicodeSet::fromUSet(pSet);
|
|
UnicodeSetIterator it(*set);
|
|
fprintf(f, "# Inclusive ranges of the code points in the set.\n");
|
|
fprintf(f, "ranges = [\n");
|
|
bool seenFirstString = false;
|
|
while (it.nextRange()) {
|
|
if (it.isString()) {
|
|
if (!seenFirstString) {
|
|
seenFirstString = true;
|
|
fprintf(f, "]\nstrings = [\n");
|
|
}
|
|
const UnicodeString& str = it.getString();
|
|
fprintf(f, " ");
|
|
usrc_writeStringAsASCII(f, str.getBuffer(), str.length(), syntax);
|
|
fprintf(f, ",\n");
|
|
} else {
|
|
U_ASSERT(!seenFirstString);
|
|
UChar32 start = it.getCodepoint();
|
|
UChar32 end = it.getCodepointEnd();
|
|
fprintf(f, " [0x%x, 0x%x],\n", start, end);
|
|
}
|
|
}
|
|
fprintf(f, "]\n");
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
usrc_writeUCPMap(
|
|
FILE *f,
|
|
const UCPMap *pMap,
|
|
icu::ValueNameGetter *valueNameGetter,
|
|
UTargetSyntax syntax) {
|
|
// ccode is not yet supported
|
|
U_ASSERT(syntax == UPRV_TARGET_SYNTAX_TOML);
|
|
(void) syntax; // silence unused variable errors
|
|
|
|
// Print out list of ranges
|
|
UChar32 start = 0, end;
|
|
uint32_t value;
|
|
fprintf(f, "# Code points `a` through `b` have value `v`, corresponding to `name`.\n");
|
|
fprintf(f, "ranges = [\n");
|
|
while ((end = ucpmap_getRange(pMap, start, UCPMAP_RANGE_NORMAL, 0, nullptr, nullptr, &value)) >= 0) {
|
|
if (valueNameGetter != nullptr) {
|
|
const char *name = valueNameGetter->getName(value);
|
|
fprintf(f, " {a=0x%x, b=0x%x, v=%u, name=\"%s\"},\n", start, end, value, name);
|
|
} else {
|
|
fprintf(f, " {a=0x%x, b=0x%x, v=%u},\n", start, end, value);
|
|
}
|
|
start = end + 1;
|
|
}
|
|
fprintf(f, "]\n");
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
usrc_writeArrayOfMostlyInvChars(FILE *f,
|
|
const char *prefix,
|
|
const char *p, int32_t length,
|
|
const char *postfix) {
|
|
int32_t i, col;
|
|
int prev2, prev, c;
|
|
|
|
if(prefix!=nullptr) {
|
|
fprintf(f, prefix, (long)length);
|
|
}
|
|
prev2=prev=-1;
|
|
for(i=col=0; i<length; ++i, ++col) {
|
|
c=(uint8_t)p[i];
|
|
if(i>0) {
|
|
/* Break long lines. Try to break at interesting places, to minimize revision diffs. */
|
|
if(
|
|
/* Very long line. */
|
|
col>=32 ||
|
|
/* Long line, break after terminating NUL. */
|
|
(col>=24 && prev2>=0x20 && prev==0) ||
|
|
/* Medium-long line, break before non-NUL, non-character byte. */
|
|
(col>=16 && (prev==0 || prev>=0x20) && 0<c && c<0x20)
|
|
) {
|
|
fputs(",\n", f);
|
|
col=0;
|
|
} else {
|
|
fputc(',', f);
|
|
}
|
|
}
|
|
fprintf(f, c<0x20 ? "%u" : "'%c'", c);
|
|
prev2=prev;
|
|
prev=c;
|
|
}
|
|
if(postfix!=nullptr) {
|
|
fputs(postfix, f);
|
|
}
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
usrc_writeStringAsASCII(FILE *f,
|
|
const char16_t* ptr, int32_t length,
|
|
UTargetSyntax) {
|
|
// For now, assume all UTargetSyntax values are valid here.
|
|
fprintf(f, "\"");
|
|
int32_t i = 0;
|
|
UChar32 cp;
|
|
while (i < length) {
|
|
U16_NEXT(ptr, i, length, cp);
|
|
if (cp == u'"') {
|
|
fprintf(f, "\\\"");
|
|
} else if (ICU_Utility::isUnprintable(cp)) {
|
|
UnicodeString u16result;
|
|
ICU_Utility::escapeUnprintable(u16result, cp);
|
|
std::string u8result;
|
|
u16result.toUTF8String(u8result);
|
|
fprintf(f, "%s", u8result.data());
|
|
} else {
|
|
U_ASSERT(cp < 0x80);
|
|
char s[2] = {static_cast<char>(cp), 0};
|
|
fprintf(f, "%s", s);
|
|
}
|
|
}
|
|
fprintf(f, "\"");
|
|
}
|