зеркало из https://github.com/mozilla/gecko-dev.git
461 строка
11 KiB
C
461 строка
11 KiB
C
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
|
|
#define NOMAPPING 0xfffd
|
|
|
|
typedef struct {
|
|
uint16_t srcBegin; /* 2 byte */
|
|
uint16_t srcEnd; /* 2 byte */
|
|
uint16_t destBegin; /* 2 byte */
|
|
} uFormat0;
|
|
|
|
typedef struct {
|
|
uint16_t srcBegin; /* 2 byte */
|
|
uint16_t srcEnd; /* 2 byte */
|
|
uint16_t mappingOffset; /* 2 byte */
|
|
} uFormat1;
|
|
|
|
typedef struct {
|
|
uint16_t srcBegin; /* 2 byte */
|
|
uint16_t srcEnd; /* 2 byte -waste */
|
|
uint16_t destBegin; /* 2 byte */
|
|
} uFormat2;
|
|
|
|
typedef struct {
|
|
union {
|
|
uFormat0 format0;
|
|
uFormat1 format1;
|
|
uFormat2 format2;
|
|
} fmt;
|
|
} uMapCell;
|
|
|
|
/* =================================================
|
|
uTable
|
|
================================================= */
|
|
typedef struct {
|
|
uint16_t itemOfList;
|
|
uint16_t offsetToFormatArray;
|
|
uint16_t offsetToMapCellArray;
|
|
uint16_t offsetToMappingTable;
|
|
uint16_t data[1];
|
|
} uTable;
|
|
|
|
uint16_t umap[256][256];
|
|
int bInitFromOrTo = 0;
|
|
int bGenerateFromUnicodeTable = 0;
|
|
|
|
#define MAXCELLNUM 1000
|
|
|
|
static int numOfItem = 0;
|
|
uMapCell cell[MAXCELLNUM];
|
|
uint16_t format[MAXCELLNUM / 4];
|
|
uint16_t mapping[256*256];
|
|
static int mappinglen = 0;
|
|
static int formatcount[4] = {0,0,0,0};
|
|
|
|
#define SetFormat(n,f) { format[(n >> 2)] |= ((f) << ((n & 0x0003) << 2)); formatcount[f]++; }
|
|
#define GetFormat(n) ( format[(n >> 2)] >> ((n & 0x0003) << 2)) &0x00FF)
|
|
#define MAPVALUE(i) (umap[(i >> 8) & 0xFF][(i) & 0xFF])
|
|
|
|
int FORMAT1CNST = 10 ;
|
|
int FORMAT0CNST = 5 ;
|
|
void initmaps()
|
|
{
|
|
int i,j;
|
|
for(i=0;i<256;i++)
|
|
for(j=0;j<256;j++)
|
|
{
|
|
umap[i][j]= NOMAPPING;
|
|
}
|
|
for(i=0;i<MAXCELLNUM / 4;i++)
|
|
format[i]=0;
|
|
}
|
|
void SetMapValue(short u,short c)
|
|
{
|
|
if(NOMAPPING == MAPVALUE(u))
|
|
MAPVALUE(u) = c & 0x0000FFFF;
|
|
else {
|
|
fprintf(stderr, "warning- duplicate mapping %x map to both %x and %x\n", u, MAPVALUE(u), c);
|
|
}
|
|
}
|
|
void AddFormat2(uint16_t srcBegin)
|
|
{
|
|
uint16_t destBegin = MAPVALUE(srcBegin);
|
|
printf("Begin of Item %04X\n",numOfItem);
|
|
printf(" Format 2\n");
|
|
printf(" srcBegin = %04X\n", srcBegin);
|
|
printf(" destBegin = %04X\n", destBegin );
|
|
SetFormat(numOfItem,2);
|
|
cell[numOfItem].fmt.format2.srcBegin = srcBegin;
|
|
cell[numOfItem].fmt.format2.srcEnd = 0;
|
|
cell[numOfItem].fmt.format2.destBegin = destBegin;
|
|
printf("End of Item %04X \n\n",numOfItem);
|
|
numOfItem++;
|
|
/* Unmark the umap */
|
|
MAPVALUE(srcBegin) = NOMAPPING;
|
|
}
|
|
void AddFormat1(uint16_t srcBegin, uint16_t srcEnd)
|
|
{
|
|
uint16_t i;
|
|
printf("Begin of Item %04X\n",numOfItem);
|
|
printf(" Format 1\n");
|
|
printf(" srcBegin = %04X\n", srcBegin);
|
|
printf(" srcEnd = %04X\n", srcEnd );
|
|
printf(" mappingOffset = %04X\n", mappinglen);
|
|
printf(" Mapping = " );
|
|
SetFormat(numOfItem,1);
|
|
cell[numOfItem].fmt.format1.srcBegin = srcBegin;
|
|
cell[numOfItem].fmt.format1.srcEnd = srcEnd;
|
|
cell[numOfItem].fmt.format1.mappingOffset = mappinglen;
|
|
for(i=srcBegin ; i <= srcEnd ; i++,mappinglen++)
|
|
{
|
|
if( ((i-srcBegin) % 8) == 0)
|
|
printf("\n ");
|
|
mapping[mappinglen]= MAPVALUE(i);
|
|
printf("%04X ",(mapping[mappinglen] ));
|
|
/* Unmark the umap */
|
|
MAPVALUE(i) = NOMAPPING;
|
|
}
|
|
printf("\n");
|
|
printf("End of Item %04X \n\n",numOfItem);
|
|
numOfItem++;
|
|
}
|
|
void AddFormat0(uint16_t srcBegin, uint16_t srcEnd)
|
|
{
|
|
uint16_t i;
|
|
uint16_t destBegin = MAPVALUE(srcBegin);
|
|
printf("Begin of Item %04X\n",numOfItem);
|
|
printf(" Format 0\n");
|
|
printf(" srcBegin = %04X\n", srcBegin);
|
|
printf(" srcEnd = %04X\n", srcEnd );
|
|
printf(" destBegin = %04X\n", destBegin );
|
|
SetFormat(numOfItem,0);
|
|
cell[numOfItem].fmt.format0.srcBegin = srcBegin;
|
|
cell[numOfItem].fmt.format0.srcEnd = srcEnd;
|
|
cell[numOfItem].fmt.format0.destBegin = destBegin;
|
|
for(i=srcBegin ; i <= srcEnd ; i++)
|
|
{
|
|
/* Unmark the umap */
|
|
MAPVALUE(i) = NOMAPPING;
|
|
}
|
|
printf("End of Item %04X \n\n",numOfItem);
|
|
numOfItem++;
|
|
}
|
|
void printnpl()
|
|
{
|
|
printf(
|
|
"/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */\n"
|
|
"/* This Source Code Form is subject to the terms of the Mozilla Public\n"
|
|
" * License, v. 2.0. If a copy of the MPL was not distributed with this\n"
|
|
" * file, You can obtain one at http://mozilla.org/MPL/2.0/. */\n");
|
|
}
|
|
void gentable()
|
|
{
|
|
/* OK! For now, we just use format 1 for each row */
|
|
/* We need to chage this to use other format to save the space */
|
|
uint16_t begin,end;
|
|
uint16_t ss,gs,gp,state,gc;
|
|
uint16_t diff, lastdiff;
|
|
|
|
printnpl();
|
|
printf("/*========================================================\n");
|
|
printf(" This is a Generated file. Please don't edit it.\n");
|
|
printf("\n");
|
|
printf(" The tool which used to generate this file is called umaptable.\n");
|
|
printf(" You can find this tool under mozilla/intl/uconv/tools/umaptable.c.\n");
|
|
|
|
printf(" If you have any problems with this file, please file a bug\n");
|
|
printf(" under the \"Internationalization\" component in\n");
|
|
printf(" https://bugzilla.mozilla.org/enter_bug.cgi?product=Core\n");
|
|
printf("\n");
|
|
printf(" Table in Debug form \n");
|
|
|
|
for(begin = 0; MAPVALUE(begin) ==NOMAPPING; begin++)
|
|
;
|
|
for(end = 0xFFFF; MAPVALUE(end) ==NOMAPPING; end--)
|
|
;
|
|
if(end != begin)
|
|
{
|
|
lastdiff = MAPVALUE(begin) - begin;
|
|
for(gp=begin+1,state = 0 ; gp<=end; gp++)
|
|
{
|
|
int input ;
|
|
diff = MAPVALUE(gp) - gp;
|
|
input = (diff == lastdiff);
|
|
switch(state)
|
|
{
|
|
case 0:
|
|
if(input)
|
|
{
|
|
state = 1;
|
|
ss = gp -1;
|
|
gc = 2;
|
|
}
|
|
break;
|
|
case 1:
|
|
if(input)
|
|
{
|
|
if(gc++ >= FORMAT0CNST)
|
|
{
|
|
state = 2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
state = 0;
|
|
}
|
|
break;
|
|
case 2:
|
|
if(input)
|
|
{
|
|
}
|
|
else
|
|
{
|
|
AddFormat0(ss,gp-1);
|
|
state = 0;
|
|
}
|
|
break;
|
|
}
|
|
|
|
lastdiff = diff;
|
|
}
|
|
}
|
|
if(state == 2)
|
|
AddFormat0(ss,end);
|
|
|
|
for(;(MAPVALUE(begin) ==NOMAPPING) && (begin <= end); begin++)
|
|
;
|
|
if(begin <= end)
|
|
{
|
|
for(;(MAPVALUE(end)==NOMAPPING) && (end >= begin); end--)
|
|
;
|
|
for(ss=gp=begin,state = 0 ; gp<=end; gp++)
|
|
{
|
|
int input = (MAPVALUE(gp) == NOMAPPING);
|
|
switch(state)
|
|
{
|
|
case 0:
|
|
if(input)
|
|
{
|
|
gc = 1;
|
|
gs = gp;
|
|
state = 1;
|
|
}
|
|
break;
|
|
case 1:
|
|
if(input)
|
|
{
|
|
if(gc++ >= FORMAT1CNST)
|
|
state = 2;
|
|
}
|
|
else
|
|
state = 0;
|
|
break;
|
|
case 2:
|
|
if(input)
|
|
{
|
|
}
|
|
else
|
|
{
|
|
if(gs == (ss+1))
|
|
AddFormat2(ss);
|
|
else
|
|
AddFormat1(ss ,gs-1);
|
|
state = 0;
|
|
ss = gp;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if(end == ss)
|
|
AddFormat2(ss );
|
|
else
|
|
AddFormat1(ss ,end );
|
|
}
|
|
printf("========================================================*/\n");
|
|
}
|
|
void writetable()
|
|
{
|
|
uint16_t i;
|
|
uint16_t off1,off2,off3;
|
|
uint16_t cur = 0;
|
|
uint16_t formatitem = (((numOfItem)>>2) + 1);
|
|
off1 = 4;
|
|
off2 = off1 + formatitem ;
|
|
off3 = off2 + numOfItem * sizeof(uMapCell) / sizeof(uint16_t);
|
|
/* write itemOfList */
|
|
printf("/* Offset=0x%04X ItemOfList */\n 0x%04X,\n", cur++, numOfItem);
|
|
|
|
/* write offsetToFormatArray */
|
|
printf("/*-------------------------------------------------------*/\n");
|
|
printf("/* Offset=0x%04X offsetToFormatArray */\n 0x%04X,\n", cur++,off1);
|
|
|
|
/* write offsetToMapCellArray */
|
|
printf("/*-------------------------------------------------------*/\n");
|
|
printf("/* Offset=0x%04X offsetToMapCellArray */ \n 0x%04X,\n", cur++,off2);
|
|
|
|
/* write offsetToMappingTable */
|
|
printf("/*-------------------------------------------------------*/\n");
|
|
printf("/* Offset=0x%04X offsetToMappingTable */ \n 0x%04X,\n", cur++,off3);
|
|
|
|
/* write FormatArray */
|
|
printf("/*-------------------------------------------------------*/\n");
|
|
printf("/* Offset=0x%04X Start of Format Array */ \n",cur);
|
|
printf("/* Total of Format 0 : 0x%04X */\n"
|
|
, formatcount[0]);
|
|
printf("/* Total of Format 1 : 0x%04X */\n"
|
|
, formatcount[1]);
|
|
printf("/* Total of Format 2 : 0x%04X */\n"
|
|
, formatcount[2]);
|
|
printf("/* Total of Format 3 : 0x%04X */\n"
|
|
, formatcount[3]);
|
|
for(i=0;i<formatitem;i++,cur++)
|
|
{
|
|
if((i%8) == 0)
|
|
printf("\n");
|
|
printf("0x%04X, ",format[i]);
|
|
}
|
|
printf("\n");
|
|
|
|
/* write MapCellArray */
|
|
printf("/*-------------------------------------------------------*/\n");
|
|
printf("/* Offset=0x%04X Start of MapCell Array */ \n",cur);
|
|
for(i=0;i<numOfItem;i++,cur+=3)
|
|
{
|
|
printf("/* %04X */ 0x%04X, 0x%04X, 0x%04X, \n",
|
|
i,
|
|
cell[i].fmt.format0.srcBegin,
|
|
cell[i].fmt.format0.srcEnd,
|
|
cell[i].fmt.format0.destBegin
|
|
);
|
|
}
|
|
|
|
/* write MappingTable */
|
|
printf("/*-------------------------------------------------------*/\n");
|
|
printf("/* Offset=0x%04X Start of MappingTable */ \n",cur);
|
|
for(i=0;i<mappinglen;i++,cur++)
|
|
{
|
|
if((i%8) == 0)
|
|
printf("\n/* %04X */ ",i);
|
|
printf("0x%04X, ",mapping[i] );
|
|
}
|
|
printf("\n");
|
|
printf("/* End of table Total Length = 0x%04X * 2 */\n",cur);
|
|
}
|
|
|
|
void usage()
|
|
{
|
|
fprintf(stderr, "please indicate what kind of mapping mapping table you want to generate:\n");
|
|
fprintf(stderr, "\t-uf : generate *.uf (from unicode) table, or\n");
|
|
fprintf(stderr, "\t-ut : generate *.ut (to unicode) table\n");
|
|
}
|
|
void parsearg(int argc, char* argv[])
|
|
{
|
|
int i;
|
|
for(i=0;i<argc;i++)
|
|
{
|
|
if(strncmp("-uf", argv[i],3) == 0) {
|
|
if(! bInitFromOrTo) {
|
|
bGenerateFromUnicodeTable = 1;
|
|
bInitFromOrTo = 1;
|
|
} else {
|
|
usage();
|
|
exit(-1);
|
|
}
|
|
}
|
|
if(strncmp("-ut", argv[i],3) == 0) {
|
|
if(! bInitFromOrTo) {
|
|
bGenerateFromUnicodeTable = 0;
|
|
bInitFromOrTo = 1;
|
|
} else {
|
|
usage();
|
|
exit(-1);
|
|
}
|
|
}
|
|
if((strncmp("-0", argv[i],2) == 0) && ((i+1) < argc))
|
|
{
|
|
int cnst0;
|
|
if(sscanf(argv[i+1], "%d", &cnst0) == 1)
|
|
{
|
|
if(cnst0 > 0)
|
|
{
|
|
FORMAT0CNST = cnst0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "argc error !!!!\n");
|
|
exit(-1);
|
|
}
|
|
i++;
|
|
}
|
|
if((strncmp("-1", argv[i],2) == 0) && ((i+1) < argc))
|
|
{
|
|
int cnst1;
|
|
if(sscanf(argv[i+1], "%d", &cnst1) == 1)
|
|
{
|
|
if(cnst1 > 0)
|
|
{
|
|
FORMAT1CNST = cnst1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "argc error !!!!\n");
|
|
exit(-1);
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
if(! bInitFromOrTo)
|
|
{
|
|
usage();
|
|
exit(-1);
|
|
}
|
|
fprintf(stderr, "format 0 cnst = %d\n", FORMAT0CNST);
|
|
fprintf(stderr, "format 1 cnst = %d\n", FORMAT1CNST);
|
|
fprintf(stderr, "generate u%c table\n",
|
|
bGenerateFromUnicodeTable ? 'f' : 't');
|
|
}
|
|
void getinput()
|
|
{
|
|
char buf[256];
|
|
short c,u;
|
|
for (; fgets(buf,sizeof(buf),stdin);)
|
|
{
|
|
if(buf[0]=='0' && buf[1] == 'x')
|
|
{
|
|
u=-1;
|
|
sscanf(buf,"%hx %hx",&c,&u);
|
|
if (u == -1 && 0x80 <= c && c <=0x9f)
|
|
{
|
|
u = c;
|
|
}
|
|
if (u != -1)
|
|
{
|
|
if(bGenerateFromUnicodeTable)
|
|
SetMapValue(u, c);
|
|
else
|
|
SetMapValue(c, u);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
int main(int argc, char* argv[])
|
|
{
|
|
parsearg(argc, argv);
|
|
initmaps();
|
|
getinput();
|
|
gentable();
|
|
writetable();
|
|
return 0;
|
|
}
|