72    while (fgets (instring, 
MAXLINE, infp) != NULL) {
 
   73       sscanf (instring, 
"%X", &codept);
 
   78          for (i = 1; instring[i] != 
'\0' && instring[i] != 
':'; i++);
 
   79          if (instring[i] == 
':') {
 
   81             for (j = 0; j < 32; j++) {
 
   82                sscanf (&instring[i], 
"%2hhX", &base[codept][j]);
 
   85             if (codept > max_codept) max_codept = codept;
 
  125    while (fgets (instring, 
MAXLINE, infp) != NULL) {
 
  126       sscanf (instring, 
"%X", &codept);
 
  131          for (i = 1; instring[i] != 
'\0' && instring[i] != 
':'; i++);
 
  132          if (instring[i] == 
':') {
 
  134             for (j = 0; j < 16; j++) {
 
  135                sscanf (&instring[i], 
"%4X", &base[codept][j]);
 
  138             if (codept > max_codept) max_codept = codept;
 
  169    if (codept < 0xAC00 || codept > 0xD7A3) {
 
  170       *initial = *medial = *
final = -1;
 
  174       *initial =  codept / (28  * 21);
 
  175       *medial  = (codept /  28) % 21;
 
  176       *
final   =  codept %  28 - 1;
 
  205    if (initial >= 0 && initial <= 18 &&
 
  206        medial  >= 0 && medial  <= 20 &&
 
  207        final   >= 0 && 
final   <= 26) {
 
  210       codept += initial * 21 * 28;
 
  211       codept += medial  * 28;
 
  250                    int *cho_index, 
int *jung_index, 
int *jong_index) {
 
  263    *jong_index = jongseong < 0 ? 0x0000 :
 
  299                    int *cho_var, 
int *jung_var, 
int *jong_var) {
 
  301    int  cho_variation (
int choseong, 
int jungseong, 
int jongseong);
 
  359    static int choseong_var [TOTAL_JUNG + 1] = {
 
  397 #ifdef EXTENDED_HANGUL 
  413    if (jungseong < 0 || jungseong >= TOTAL_JUNG) {
 
  437    static int wide_vowel [TOTAL_JUNG + 1] = {
 
  475 #ifdef EXTENDED_HANGUL 
  491    if (vowel >= 0 && vowel < TOTAL_JUNG) {
 
  492       retval = wide_vowel [vowel];
 
  532       if (jongseong >= 0) {
 
  584                  unsigned char hangul_base[][32], 
unsigned char *syllable) {
 
  587    int      cho_hex, jung_hex, jong_hex;
 
  588    unsigned char glyph_byte;
 
  592                       &cho_hex, &jung_hex, &jong_hex);
 
  594    for (i = 0; i < 32; i++) {
 
  595       glyph_byte  = hangul_base [cho_hex][i];
 
  596       glyph_byte |= hangul_base [jung_hex][i];
 
  597       if (jong_hex >= 0) glyph_byte |= hangul_base [jong_hex][i];
 
  598       syllable[i] = glyph_byte;
 
  621       overlaps = (glyph1[i] & glyph2[i]) != 0;
 
  623    }  
while (i < 16 && overlaps == 0);
 
  638                 unsigned *combined_glyph) {
 
  641    for (i = 0; i < 16; i++)
 
  642       combined_glyph [i] = glyph1 [i] | glyph2 [i];
 
  661    fprintf (fp, 
"%04X:", codept);
 
  664    for (i = 0; i < 16; i++) {
 
  667       while (mask != 0x0000) {
 
  668          if (mask & this_glyph [i]) {
 
  697    fprintf (fp, 
"%04X:", codept);
 
  700    for (i = 0; i < 16; i++) {
 
  701       fprintf (fp, 
"%04X", this_glyph[i]);
 
  718           unsigned jamo, 
unsigned *jamo_glyph) {
 
  725    if (jamo >= 0x1100 && jamo <= 0x11FF) {
 
  726       glyph_index = jamo - 0x1100 + 
JAMO_HEX;
 
  728    else if (jamo >= 0xA960 && jamo <= 0xA97F) {
 
  731    else if (jamo >= 0xD7B0 && jamo <= 0xD7FF) {
 
  738    for (i = 0; i < 16; i++) {
 
  739       jamo_glyph [i] = glyph_table [glyph_index] [i];
 
  788                unsigned cho, 
unsigned jung, 
unsigned jong,
 
  789                unsigned *combined_glyph) {
 
  792    int cho_num,   jung_num,   jong_num;
 
  793    int cho_group, jung_group, jong_group;
 
  794    int cho_index, jung_index, jong_index;
 
  796    unsigned tmp_glyph[16]; 
 
  798    int  cho_variation (
int choseong, 
int jungseong, 
int jongseong);
 
  801                         unsigned *combined_glyph);
 
  805    cho_index = jung_index = jong_index = 0x000;
 
  811    if (cho >= 0x1100 && cho <= 0x115E)
 
  819    if (jung >= 0x1161 && jung <= 0x11A7)
 
  827    if (jong >= 0x11A8 && jong <= 0x11FF)
 
  840       cho_index = cho_group = 0;  
 
  843       if (jung_num < 0 && jong_num < 0) {  
 
  876    jung_index = jung_group = 0;  
 
  879       if (cho_num < 0 && jong_num < 0) {  
 
  891          else if (cho_num >= 0)
 
  902       jong_index = jong_group = 0;  
 
  905       if (cho_num < 0 && jung_num < 0) {  
 
  907          jong_index = jung_num + 0x4A8;
 
  920    combine_glyphs (glyph_table [cho_index], glyph_table [jung_index],
 
  923    if (jong_index > 0) {
 
  931          for (i = 0; i < 16; i++) {
 
  932             tmp_glyph [i] = glyph_table [jong_index] [i] >> 1;
 
Define constants and function prototypes for using Hangul glyphs.
#define NJONG_EXTB
Hangul Extended-B jongseong.
#define NCHO_EXTA
Hangul Extended-A choseong.
#define CHO_VARIATIONS
6 choseong variations
#define JONG_VARIATIONS
1 jongseong variation
#define NJONG_MODERN
28 modern Hangul Jamo jongseong
#define JAMO_EXTB_HEX
Start of U+D7B0..U+D7FF glyphs.
#define CHO_UNICODE_START
Modern Hangul choseong start.
#define JAMO_EXTA_HEX
Start of U+A960..U+A97F glyphs.
#define JUNG_EXTB_UNICODE_START
Hangul Extended-B jungseong start.
#define JUNG_HEX
Location of first jungseong (will be 0x2FB)
#define NCHO_ANCIENT
ancient Hangul Jamo choseong
#define MAXLINE
Length of maximum file input line.
#define CHO_EXTA_UNICODE_START
Hangul Extended-A choseong start.
#define NCHO_MODERN
19 modern Hangul Jamo choseong
#define JAMO_HEX
Start of U+1100..U+11FF glyphs.
#define JONG_UNICODE_START
Modern Hangul jongseong start.
#define NJUNG_MODERN
21 modern Hangul Jamo jungseong
#define JUNG_UNICODE_START
Modern Hangul jungseong start.
#define JUNG_VARIATIONS
3 jungseong variations
#define NJONG_ANCIENT
ancient Hangul Jamo jongseong
#define NJUNG_ANCIENT
ancient Hangul Jamo jungseong
#define CHO_HEX
Location of first choseong (location 0x0000 is a blank glyph)
#define JONG_EXTB_UNICODE_START
Hangul Extended-B jongseong start.
#define NJUNG_EXTB
Hangul Extended-B jungseong.
#define JONG_HEX
Location of first jongseong (will be 0x421)
#define MAX_GLYPHS
An OpenType font has at most 65536 glyphs.
void print_glyph_hex(FILE *fp, unsigned codept, unsigned *this_glyph)
Print one glyph in Unifont hexdraw hexadecimal string style.
void one_jamo(unsigned glyph_table[MAX_GLYPHS][16], unsigned jamo, unsigned *jamo_glyph)
Convert Hangul Jamo choseong, jungseong, and jongseong into a glyph.
void combined_jamo(unsigned glyph_table[MAX_GLYPHS][16], unsigned cho, unsigned jung, unsigned jong, unsigned *combined_glyph)
Convert Hangul Jamo choseong, jungseong, and jongseong into a glyph.
void print_glyph_txt(FILE *fp, unsigned codept, unsigned *this_glyph)
Print one glyph in Unifont hexdraw plain text style.
unsigned hangul_read_base8(FILE *infp, unsigned char base[][32])
Read hangul-base.hex file into a unsigned char array.
int is_wide_vowel(int vowel)
Whether vowel has rightmost vertical stroke to the right.
void hangul_hex_indices(int choseong, int jungseong, int jongseong, int *cho_index, int *jung_index, int *jong_index)
Determine index values to the bitmaps for a syllable's components.
void hangul_decompose(unsigned codept, int *initial, int *medial, int *final)
Decompose a Hangul Syllables code point into three letters.
int glyph_overlap(unsigned *glyph1, unsigned *glyph2)
See if two glyphs overlap.
void hangul_variations(int choseong, int jungseong, int jongseong, int *cho_var, int *jung_var, int *jong_var)
Determine the variations of each letter in a Hangul syllable.
void combine_glyphs(unsigned *glyph1, unsigned *glyph2, unsigned *combined_glyph)
Combine two glyphs into one glyph.
int jong_variation(int choseong, int jungseong, int jongseong)
Return the Johab 6/3/1 jongseong variation.
int cho_variation(int choseong, int jungseong, int jongseong)
Return the Johab 6/3/1 choseong variation for a syllable.
int jung_variation(int choseong, int jungseong, int jongseong)
Return the Johab 6/3/1 jungseong variation.
void hangul_syllable(int choseong, int jungseong, int jongseong, unsigned char hangul_base[][32], unsigned char *syllable)
Given letters in a Hangul syllable, return a glyph.
unsigned hangul_compose(int initial, int medial, int final)
Compose a Hangul syllable into a code point, or 0 if none exists.
unsigned hangul_read_base16(FILE *infp, unsigned base[][16])
Read hangul-base.hex file into a unsigned array.