47            unsigned char glyph[16][2]) {
 
   53    sscanf (hexstring, 
"%X", codept);
 
   54    length = strlen (hexstring);
 
   55    for (i = length - 1; i > 0 && hexstring[i] != 
'\n'; i--);
 
   57    for (i = 0; i < 9 && hexstring[i] != 
':'; i++);
 
   59    *width = (length - i) * 4 / 16;  
 
   61    for (row = 0; row < 16; row++) {
 
   62       sscanf (&hexstring[i], 
"%2hhX", &glyph [row][0]);
 
   65         sscanf (&hexstring[i], 
"%2hhX", &glyph [row][1]);
 
   69          glyph [row][1] = 0x00;
 
   92             unsigned char glyph[16][2],
 
   93             unsigned char glyphbits [16][16]) {
 
   95    unsigned char tmp_byte;
 
   99    for (row = 0; row < 16; row++) {
 
  100       tmp_byte = glyph [row][0];
 
  102       for (column = 0; column < 8; column++) {
 
  103          glyphbits [row][column] = tmp_byte & mask ? 1 : 0;
 
  108          tmp_byte = glyph [row][1];
 
  113       for (column = 8; column < 16; column++) {
 
  114          glyphbits [row][column] = tmp_byte & mask ? 1 : 0;
 
  151          unsigned char glyphbits [16][16],
 
  152          unsigned char transpose [2][16]) {
 
  157    for (column = 0; column < 8; column++) {
 
  158       transpose [0][column] =
 
  159                (glyphbits [ 0][column] << 7) |
 
  160                (glyphbits [ 1][column] << 6) |
 
  161                (glyphbits [ 2][column] << 5) |
 
  162                (glyphbits [ 3][column] << 4) |
 
  163                (glyphbits [ 4][column] << 3) |
 
  164                (glyphbits [ 5][column] << 2) |
 
  165                (glyphbits [ 6][column] << 1) |
 
  166                (glyphbits [ 7][column]     );
 
  167       transpose [1][column] =
 
  168                (glyphbits [ 8][column] << 7) |
 
  169                (glyphbits [ 9][column] << 6) |
 
  170                (glyphbits [10][column] << 5) |
 
  171                (glyphbits [11][column] << 4) |
 
  172                (glyphbits [12][column] << 3) |
 
  173                (glyphbits [13][column] << 2) |
 
  174                (glyphbits [14][column] << 1) |
 
  175                (glyphbits [15][column]     );
 
  178       for (column = 8; column < width; column++) {
 
  179          transpose [0][column] =
 
  180                   (glyphbits [0][column] << 7) |
 
  181                   (glyphbits [1][column] << 6) |
 
  182                   (glyphbits [2][column] << 5) |
 
  183                   (glyphbits [3][column] << 4) |
 
  184                   (glyphbits [4][column] << 3) |
 
  185                   (glyphbits [5][column] << 2) |
 
  186                   (glyphbits [6][column] << 1) |
 
  187                   (glyphbits [7][column]     );
 
  188          transpose [1][column] =
 
  189                   (glyphbits [ 8][column] << 7) |
 
  190                   (glyphbits [ 9][column] << 6) |
 
  191                   (glyphbits [10][column] << 5) |
 
  192                   (glyphbits [11][column] << 4) |
 
  193                   (glyphbits [12][column] << 3) |
 
  194                   (glyphbits [13][column] << 2) |
 
  195                   (glyphbits [14][column] << 1) |
 
  196                   (glyphbits [15][column]     );
 
  200       for (column = 8; column < width; column++)
 
  201          transpose [0][column] = transpose [1][column] = 0x00;
 
  222               unsigned char glyph [16][2],
 
  228    if (codept <= 0xFFFF) {
 
  229       sprintf (outstring, 
"%04X:", codept);
 
  233       sprintf (outstring, 
"%06X:", codept);
 
  237    for (row = 0; row < 16; row++) {
 
  238       sprintf (&outstring[i], 
"%02X", glyph [row][0]);
 
  242          sprintf (&outstring[i], 
"%02X", glyph [row][1]);
 
  268                unsigned char transpose [2][16],
 
  274    if (codept <= 0xFFFF) {
 
  275       sprintf (outstring, 
"%04X:", codept);
 
  279       sprintf (outstring, 
"%06X:", codept);
 
  283    for (column = 0; column < 8; column++) {
 
  284       sprintf (&outstring[i], 
"%02X", transpose [0][column]);
 
  288       for (column = 8; column < 16; column++) {
 
  289          sprintf (&outstring[i], 
"%02X", transpose [0][column]);
 
  293    for (column = 0; column < 8; column++) {
 
  294       sprintf (&outstring[i], 
"%02X", transpose [1][column]);
 
  298       for (column = 8; column < 16; column++) {
 
  299          sprintf (&outstring[i], 
"%02X", transpose [1][column]);
 
void hexpose(int width, unsigned char glyphbits[16][16], unsigned char transpose[2][16])
Transpose a Unifont .hex format glyph into 2 column-major sub-arrays.
void glyph2bits(int width, unsigned char glyph[16][2], unsigned char glyphbits[16][16])
Convert a Unifont binary glyph into a binary glyph array of bits.
void xglyph2string(int width, unsigned codept, unsigned char transpose[2][16], char *outstring)
Convert a code point and transposed glyph into a Unifont .hex string.
void parse_hex(char *hexstring, int *width, unsigned *codept, unsigned char glyph[16][2])
Decode a Unifont .hex file into Uniocde code point and glyph.
void glyph2string(int width, unsigned codept, unsigned char glyph[16][2], char *outstring)
Convert a glyph code point and byte array into a Unifont .hex string.