85    {0x6,0x9,0x9,0x9,0x6},  
 
   86    {0x2,0x6,0x2,0x2,0x7},  
 
   87    {0xF,0x1,0xF,0x8,0xF},  
 
   88    {0xE,0x1,0x7,0x1,0xE},  
 
   89    {0x9,0x9,0xF,0x1,0x1},  
 
   90    {0xF,0x8,0xF,0x1,0xF},  
 
   91    {0x6,0x8,0xE,0x9,0x6},   
 
   92    {0xF,0x1,0x2,0x4,0x4},  
 
   93    {0x6,0x9,0x6,0x9,0x6},  
 
   94    {0x6,0x9,0x7,0x1,0x6},   
 
   95    {0xF,0x9,0xF,0x9,0x9},  
 
   96    {0xE,0x9,0xE,0x9,0xE},  
 
   97    {0x7,0x8,0x8,0x8,0x7},  
 
   98    {0xE,0x9,0x9,0x9,0xE},  
 
   99    {0xF,0x8,0xE,0x8,0xF},  
 
  100    {0xF,0x8,0xE,0x8,0x8}   
 
  115    int startcp, endcp, thiscp;
 
  120       fprintf (stderr,
"\n%s - generate unifont.hex code points as\n", argv[0]);
 
  121       fprintf (stderr,
"four-digit hexadecimal numbers in a 2 by 2 grid,\n");
 
  122       fprintf (stderr,
"or six-digit hexadecimal numbers in a 3 by 2 grid.\n");
 
  123       fprintf (stderr,
"Syntax:\n\n");
 
  124       fprintf (stderr,
"     %s first_code_point last_code_point > glyphs.hex\n\n", argv[0]);
 
  125       fprintf (stderr,
"Example (to generate glyphs for the Private Use Area):\n\n");
 
  126       fprintf (stderr,
"     %s e000 f8ff > pua.hex\n\n", argv[0]);
 
  130    sscanf (argv[1], 
"%x", &startcp);
 
  131    sscanf (argv[2], 
"%x", &endcp);
 
  139    for (thiscp = startcp; thiscp <= endcp; thiscp++) {
 
  140       if (thiscp <= 0xFFFF) {
 
  171    d1 = (thiscp >> 12) & 0xF;
 
  172    d2 = (thiscp >>  8) & 0xF;
 
  173    d3 = (thiscp >>  4) & 0xF;
 
  174    d4 = (thiscp      ) & 0xF;
 
  177    grid[0] = grid[15] = 0x0000;
 
  180    for (row = 1; row < 15; row++) grid[row] = 0x7FFE;
 
  182    printf (
"%04X:", thiscp);
 
  188    for (row = 2; row < 7; row++) {
 
  189       rowbits = (
hexdigit[d1][digitrow] << 9) |
 
  191       grid[row] ^= rowbits; 
 
  199    for (row = 9; row < 14; row++) {
 
  200       rowbits = (
hexdigit[d3][digitrow] << 9) |
 
  202       grid[row] ^= rowbits; 
 
  206    for (row = 0; row < 16; row++) printf (
"%04X", grid[row] & 0xFFFF);
 
  232    int d1, d2, d3, d4, d5, d6; 
 
  234    d1 = (thiscp >> 20) & 0xF;
 
  235    d2 = (thiscp >> 16) & 0xF;
 
  236    d3 = (thiscp >> 12) & 0xF;
 
  237    d4 = (thiscp >>  8) & 0xF;
 
  238    d5 = (thiscp >>  4) & 0xF;
 
  239    d6 = (thiscp      ) & 0xF;
 
  242    grid[0] = grid[15] = 0x0000;
 
  245    for (row = 1; row < 15; row++) grid[row] = 0xFFFF;
 
  248    printf (
"%06X:", thiscp);
 
  254    for (row = 2; row < 7; row++) {
 
  255       rowbits = (
hexdigit[d1][digitrow] << 11) |
 
  258       grid[row] ^= rowbits; 
 
  266    for (row = 9; row < 14; row++) {
 
  267       rowbits = (
hexdigit[d4][digitrow] << 11) |
 
  270       grid[row] ^= rowbits; 
 
  274    for (row = 0; row < 16; row++) printf (
"%04X", grid[row] & 0xFFFF);
 
int main(int argc, char *argv[])
The main function.
void hexprint4(int thiscp)
Generate a bitmap containing a 4-digit Unicode code point.
void hexprint6(int thiscp)
Generate a bitmap containing a 6-digit Unicode code point.
char hexdigit[16][5]
Bitmap pattern for each hexadecimal digit.