| /* PAUL MURRELL |
| This is from the GNU plotutils libplot-2.3 distribution |
| All references to HAVE_PROTOS removed |
| All references to "plotter" replaced with references to "GEDevDesc" |
| */ |
| |
| /* <UTF8-FIXME> This assumes single-byte encoding */ |
| |
| /* _controlify() converts a "label" (i.e. a character string), which may |
| contain troff-like escape sequences, into a string of unsigned shorts. |
| The possible troff-like escape sequences are listed in g_cntrlify.h. |
| |
| This conversion is to facilitate rendering. _controlify() is called by |
| alabel(), and the converted label is rendered by _alabel_standard(), |
| _alabel_stroke(), or _alabel_device(), depending on what sort of font is |
| currently selected. See g_alabel.c (_controlify() is called by |
| labelwidth() too). |
| |
| If the currently selected font is a font with ISO-Latin-1 encoding, the |
| valid escape sequences include escape sequences for the non-ASCII |
| ISO-Latin-1 characters. Also allowed are such escape sequences as \f0, |
| \f1, \f2, \f3, \f4, etc., which switch among the various fonts in the |
| current typeface: |
| |
| \f1 Switch to font #1, basic |
| \f2 Switch to font #2, italic |
| \f3 Switch to font #3, bold |
| \f4 Switch to font #4, bold italic |
| \f0 Switch to font #0, symbol (including Greek characters) |
| |
| \fP switches to the previously used font (there is a depth-1 stack, |
| i.e. only one previous font is remembered, as in troff). |
| |
| All typefaces include at least two fonts: fonts #0 and #1. Some may |
| include more than the above five. Each unsigned short in the converted |
| string is really an annotated character: the low byte is the character, |
| and the high byte is the font number. |
| |
| Besides font annotations, the controlified string may include control |
| codes (unsigned shorts with particular bit patterns in their high |
| bytes), which are produced by the escape sequences: |
| |
| \sp start superscript |
| \ep end superscript |
| |
| \sb start subscript |
| \eb end subscript |
| |
| \mk mark location |
| \rt return to mark |
| [useful e.g. for underlining, and filling square roots] |
| |
| There are also control codes for horizontal shifts. \r1, \r2, \r4, |
| \r6, \r8, \r^ will produce control codes that will shift right by 1 em, |
| 1/2 em, 1/4 em, 1/6 em, 1/8 em, 1/12 em, respectively. \l1, \l2, \l4, |
| \l6, \l8, \l^ are similar. |
| |
| The string of unsigned shorts, which is returned, is allocated with |
| malloc and may be freed later. */ |
| |
| /* PAUL MURRELL |
| sys-defines.h not used |
| */ |
| /* #include "sys-defines.h" */ |
| |
| /* PAUL MURRELL |
| extern.h renamed g_extern.h |
| */ |
| #include "g_extern.h" |
| #include "g_control.h" |
| #include "g_cntrlify.h" |
| #include "g_jis.h" |
| |
| /* these two array lengths must agree with values in file g_her_glyph.c */ |
| #define NUM_OCCIDENTAL_HERSHEY_GLYPHS 4400 |
| #define NUM_ORIENTAL_HERSHEY_GLYPHS 5500 |
| |
| /* PAUL MURRELL |
| Added typeface and fontindex arguments |
| */ |
| |
| attribute_hidden |
| unsigned short * _controlify (pGEDevDesc dd, const unsigned char *src, |
| int typeface, int fontindex) |
| { |
| unsigned short *dest; |
| unsigned char c, d; |
| unsigned char esc[3]; |
| int j = 0; |
| int raw_fontnum, raw_symbol_fontnum; |
| unsigned short fontword, symbol_fontword; |
| |
| /* note: string length can grow by a factor of 6, because a single |
| printable character can be mapped to a sequence of unsigned shorts, of |
| length up to 6 (see comment below) */ |
| /* PAUL MURRELL |
| replace _plot_xmalloc with R_alloc |
| */ |
| dest = (unsigned short *) R_alloc (6 * strlen ((char *)src) + 1, |
| sizeof(unsigned short)); |
| |
| /* PAUL MURRELL |
| only for Hershey fonts so removed switch ... |
| */ |
| raw_fontnum = _hershey_typeface_info[typeface].fonts[fontindex]; |
| raw_symbol_fontnum = _hershey_typeface_info[typeface].fonts[0]; |
| /* Of the following two words, `fontword' is updated whenever an escape |
| sequence like \f0, \f1, \f2 etc. is seen, since raw_fontnum is itself |
| updated. But `symbol_fontword' is fixed */ |
| fontword = (unsigned short)(raw_fontnum << FONT_SHIFT); |
| symbol_fontword = (unsigned short)(raw_symbol_fontnum << FONT_SHIFT); |
| |
| while (*src != (unsigned char)'\0') |
| { |
| /* If EUC, check first for high bit and process two-byte characters |
| separately. This approach is awkward (we duplicate a lot of code |
| here, which appears elsewhere below). */ |
| |
| if ((raw_fontnum == HERSHEY_EUC) |
| && (*src & 0x80) && (*(src + 1) & 0x80)) |
| { |
| unsigned char jis_row = *src & ~(0x80); |
| unsigned char jis_col = *(src + 1) & ~(0x80); |
| |
| if (GOOD_JIS_INDEX(jis_row, jis_col)) |
| { |
| int jis_glyphindex = 256 * jis_row + jis_col; |
| |
| if (jis_glyphindex >= BEGINNING_OF_KANJI) |
| /* in Kanji range, so check if we have it */ |
| { |
| #ifndef NO_KANJI |
| const struct kanjipair *kanji = _builtin_kanji_glyphs; |
| bool matched = false; |
| |
| while (kanji->jis != 0) |
| { |
| if (jis_glyphindex == kanji->jis) |
| { |
| matched = true; |
| break; |
| } |
| kanji++; |
| } |
| if (matched) |
| { |
| dest[j++] = (unsigned short)( RAW_ORIENTAL_HERSHEY_GLYPH | (kanji->nelson)); |
| src += 2; |
| continue; /* back to top of while loop */ |
| } |
| else /* a Kanji we don't have */ |
| { |
| /* render as standard `undefined character' glyph */ |
| dest[j++] = RAW_HERSHEY_GLYPH | UNDE; |
| src += 2; |
| continue; /* back to top of while loop */ |
| } |
| #endif /* not NO_KANJI */ |
| } |
| else |
| /* not in Kanji range, so look for it in char table */ |
| { |
| const struct jis_entry *char_mapping = _builtin_jis_chars; |
| bool matched = false; |
| |
| while (char_mapping->jis != 0) |
| { |
| if (jis_glyphindex == char_mapping->jis) |
| { |
| matched = true; |
| break; |
| } |
| char_mapping++; |
| } |
| if (matched) |
| /* the entry in the character table maps the JIS |
| character to a character (in 0..255 range) in |
| one of the fonts in the master table in g_fontdb.c */ |
| { |
| int fontnum = char_mapping->font; |
| unsigned short charnum = char_mapping->charnum; |
| |
| if (charnum & RAW_HERSHEY_GLYPH) |
| /* a raw Hershey glyph, not in any font */ |
| dest[j++] = RAW_HERSHEY_GLYPH | charnum; |
| else |
| /* a character in one of the fonts in g_fontdb.c */ |
| dest[j++] = (unsigned short)((fontnum << FONT_SHIFT) | charnum); |
| src += 2; |
| continue; /* back to top of while loop */ |
| } |
| else /* a character we don't have */ |
| { |
| /* render as standard `undefined character' glyph */ |
| dest[j++] = RAW_HERSHEY_GLYPH | UNDE; |
| src += 2; |
| continue; /* back to top of while loop */ |
| } |
| } |
| } |
| else |
| /* JIS index is OOB */ |
| { |
| src += 2; |
| continue; /* back to top of while loop */ |
| } |
| } |
| |
| /* if current font is Hershey, first try to match each ligature |
| pattern (no ligatures supported in non-Hershey fonts) */ |
| if (1) /* _plotter->drawstate->font_type == F_HERSHEY) */ |
| { |
| int i; |
| bool matched = false; |
| |
| for (i = 0; i < NUM_LIGATURES; i++) |
| if ((_ligature_tbl[i].font == raw_fontnum) |
| && (strncmp ((char *)src, _ligature_tbl[i].from, |
| strlen (_ligature_tbl[i].from)) == 0)) |
| { |
| matched = true; |
| break; |
| } |
| |
| if (matched) |
| { |
| dest[j++] = fontword | (unsigned short)_ligature_tbl[i].byte; |
| src += strlen (_ligature_tbl[i].from); |
| continue; /* back to top of while loop */ |
| } |
| } |
| |
| c = *(src++); /* no ligature, so get single new char */ |
| if (c != (unsigned char)'\\') /* ordinary char, may pass through */ |
| { |
| /* if current font is an ISO-Latin-1 Hershey font ... */ |
| if (1 /* _plotter->drawstate->font_type == F_HERSHEY */ |
| && _hershey_font_info[raw_fontnum].iso8859_1) |
| { |
| int i; |
| bool matched = false; |
| |
| /* check if this is a `raised' ISO-Latin-1 character */ |
| for (i = 0; i < NUM_RAISED_CHARS; i++) |
| if (c == _raised_char_tbl[i].from) |
| { |
| matched = true; |
| break; |
| } |
| if (matched) /* it's a raised character */ |
| { |
| /* map to string of unsigned shorts, length 3 or 6: |
| `begin superscript' control code, [`mark' |
| control code,] replacement char, [`return' |
| control code, underline,] `end superscript' */ |
| dest[j++] = |
| (unsigned short) (CONTROL_CODE | C_BEGIN_SUPERSCRIPT); |
| if (_raised_char_tbl[i].underscored) /* also underline */ |
| { |
| dest[j++] = |
| (unsigned short) (CONTROL_CODE | C_PUSH_LOCATION); |
| dest[j++] = |
| fontword | (unsigned short)_raised_char_tbl[i].to; |
| dest[j++] = |
| (unsigned short) (CONTROL_CODE | C_POP_LOCATION); |
| /* select appropriate HersheySymbol font */ |
| dest[j++] = |
| symbol_fontword | (unsigned short)VECTOR_SYMBOL_FONT_UNDERSCORE; |
| } |
| else /* just print raised char, no underline */ |
| dest[j++] = |
| fontword | (unsigned short)_raised_char_tbl[i].to; |
| |
| dest[j++] = |
| (unsigned short) (CONTROL_CODE | C_END_SUPERSCRIPT); |
| |
| continue; /* back to top of while loop */ |
| } |
| |
| /* since current font is an ISO-Latin-1 Hershey font, also |
| check if this char should be deligatured */ |
| for (i = 0; i < NUM_DELIGATURED_CHARS; i++) |
| if (c == _deligature_char_tbl[i].from) |
| { |
| matched = true; |
| break; |
| } |
| if (matched) |
| { |
| if (_deligature_char_tbl[i].except_font != raw_fontnum) |
| { |
| dest[j++] = fontword |
| | (unsigned short)_deligature_char_tbl[i].to[0]; |
| dest[j++] = fontword |
| | (unsigned short)_deligature_char_tbl[i].to[1]; |
| continue; /* back to top of while loop */ |
| } |
| } |
| } |
| |
| /* didn't do anything special, so just pass the character thru */ |
| dest[j++] = fontword | (unsigned short)c; |
| continue; /* back to top of while loop */ |
| } |
| else /* character is a backslash */ |
| { |
| int i; |
| |
| c = *(src++); /* grab next character */ |
| if (c == (unsigned char)'\0') /* ASCII NUL ? */ |
| { |
| dest[j++] = fontword | (unsigned short)'\\'; |
| break; /* string terminated with a backslash */ |
| } |
| |
| if (c == (unsigned char)'\\') |
| { |
| dest[j++] = fontword | (unsigned short)'\\'; |
| dest[j++] = fontword | (unsigned short)'\\'; |
| continue; /* saw \\, leave as is */ |
| } |
| |
| d = *(src++); |
| if (d == (unsigned char)'\0') |
| { |
| dest[j++] = fontword | (unsigned short)'\\'; |
| dest[j++] = fontword | (unsigned short)c; |
| break; /* string terminated with \c */ |
| } |
| |
| esc[0] = c; |
| esc[1] = d; |
| esc[2] = (unsigned char)'\0'; /* have an escape sequence */ |
| |
| /* is this an escape seq. (e.g. \#H0001) for a raw Hershey glyph? */ |
| if (1 /* _plotter->drawstate->font_type == F_HERSHEY */ |
| && esc[0] == '#' && esc[1] == 'H' |
| && src[0] >= '0' && src[0] <= '9' |
| && src[1] >= '0' && src[1] <= '9' |
| && src[2] >= '0' && src[2] <= '9' |
| && src[3] >= '0' && src[3] <= '9') |
| { |
| int glyphindex; |
| |
| glyphindex = (src[3] - '0') + 10 * (src[2] - '0') |
| + 100 * (src[1] - '0') + 1000 * (src[0] - '0'); |
| if (glyphindex < NUM_OCCIDENTAL_HERSHEY_GLYPHS) |
| { |
| dest[j++] = (unsigned short)(RAW_HERSHEY_GLYPH | glyphindex); |
| src += 4; |
| continue; /* back to top of while loop */ |
| } |
| } |
| |
| #ifndef NO_KANJI |
| /* is this an escape seq. (e.g. \#N0001) for a raw Japanese |
| Hershey glyph (Kanji), as numbered in Nelson's dictionary? */ |
| if (1 /* _plotter->drawstate->font_type == F_HERSHEY */ |
| && esc[0] == '#' && esc[1] == 'N' |
| && src[0] >= '0' && src[0] <= '9' |
| && src[1] >= '0' && src[1] <= '9' |
| && src[2] >= '0' && src[2] <= '9' |
| && src[3] >= '0' && src[3] <= '9') |
| { |
| int glyphindex; |
| |
| glyphindex = (src[3] - '0') + 10 * (src[2] - '0') |
| + 100 * (src[1] - '0') + 1000 * (src[0] - '0'); |
| if (glyphindex < NUM_ORIENTAL_HERSHEY_GLYPHS) |
| { |
| dest[j++] = (unsigned short)(RAW_ORIENTAL_HERSHEY_GLYPH | glyphindex); |
| src += 4; |
| continue; /* back to top of while loop */ |
| } |
| } |
| #endif /* not NO_KANJI */ |
| |
| /* is this an escape seq. (e.g. \#J0001) for a raw Japanese |
| Hershey glyph (JIS numbering, in hex)? */ |
| if (1 /* _plotter->drawstate->font_type == F_HERSHEY */ |
| && esc[0] == '#' && esc[1] == 'J' |
| && ((src[0] >= '0' && src[0] <= '9') |
| || (src[0] >= 'a' && src[0] <= 'f') |
| || (src[0] >= 'A' && src[0] <= 'F')) |
| && ((src[1] >= '0' && src[1] <= '9') |
| || (src[1] >= 'a' && src[1] <= 'f') |
| || (src[1] >= 'A' && src[1] <= 'F')) |
| && ((src[2] >= '0' && src[2] <= '9') |
| || (src[2] >= 'a' && src[2] <= 'f') |
| || (src[2] >= 'A' && src[2] <= 'F')) |
| && ((src[3] >= '0' && src[3] <= '9') |
| || (src[3] >= 'a' && src[3] <= 'f') |
| || (src[3] >= 'A' && src[3] <= 'F'))) |
| { |
| int jis_glyphindex; |
| int i, hexnum[4]; |
| int jis_row, jis_col; |
| |
| for (i = 0; i < 4; i++) |
| if (src[i] >= 'a' && src[i] <= 'f') |
| hexnum[i] = 10 + src[i] - 'a'; |
| else if (src[i] >= 'A' && src[i] <= 'F') |
| hexnum[i] = 10 + src[i] - 'A'; |
| else /* a decimal digit */ |
| hexnum[i] = src[i] - '0'; |
| |
| jis_glyphindex = (hexnum[3] + 16 * hexnum[2] |
| + 256 * hexnum[1] + 4096 * hexnum[0]); |
| jis_row = hexnum[1] + 16 * hexnum[0]; |
| jis_col = hexnum[3] + 16 * hexnum[2]; |
| |
| if (GOOD_JIS_INDEX(jis_row, jis_col)) |
| { |
| if (jis_glyphindex >= BEGINNING_OF_KANJI) |
| /* in Kanji range, so check if we have it */ |
| { |
| #ifndef NO_KANJI |
| const struct kanjipair *kanji = _builtin_kanji_glyphs; |
| bool matched = false; |
| |
| while (kanji->jis != 0) |
| { |
| if (jis_glyphindex == kanji->jis) |
| { |
| matched = true; |
| break; |
| } |
| kanji++; |
| } |
| if (matched) |
| { |
| dest[j++] = (unsigned short)(RAW_ORIENTAL_HERSHEY_GLYPH | (kanji->nelson)); |
| src += 4; |
| continue; /* back to top of while loop */ |
| } |
| else /* a Kanji we don't have */ |
| { |
| /* render as standard `undefined character' glyph */ |
| dest[j++] = RAW_HERSHEY_GLYPH | UNDE; |
| src += 4; |
| continue; /* back to top of while loop */ |
| } |
| #endif /* not NO_KANJI */ |
| } |
| else |
| /* not in Kanji range, so look for it in char table */ |
| { |
| const struct jis_entry *char_mapping = _builtin_jis_chars; |
| bool matched = false; |
| |
| while (char_mapping->jis != 0) |
| { |
| if (jis_glyphindex == char_mapping->jis) |
| { |
| matched = true; |
| break; |
| } |
| char_mapping++; |
| } |
| if (matched) |
| /* the entry in the character table maps the JIS |
| character to a character (in 0..255 range) in |
| one of the fonts in the master table in g_fontdb.c*/ |
| { |
| int fontnum = char_mapping->font; |
| unsigned short charnum = char_mapping->charnum; |
| |
| if (charnum & RAW_HERSHEY_GLYPH) |
| /* a raw Hershey glyph, not in any font */ |
| dest[j++] = RAW_HERSHEY_GLYPH | charnum; |
| else |
| /* a character in one of the fonts in g_fontdb.c */ |
| dest[j++] = (unsigned short)((fontnum << FONT_SHIFT) | charnum); |
| src += 4; |
| continue; /* back to top of while loop */ |
| } |
| else /* a character we don't have */ |
| { |
| /* render as standard `undefined character' glyph */ |
| dest[j++] = RAW_HERSHEY_GLYPH | UNDE; |
| src += 4; |
| continue; /* back to top of while loop */ |
| } |
| } |
| } |
| } |
| |
| { |
| bool matched = false; |
| |
| /* is this an escape seq. for a control code? */ |
| for (i = 0; i < NUM_CONTROLS; i++) |
| if (strcmp ((char *)esc, _control_tbl[i]) == 0) |
| { |
| matched = true; |
| break; |
| } |
| if (matched) /* it's a control code */ |
| { |
| dest[j++] = (unsigned short)(CONTROL_CODE | i); |
| continue; /* back to top of while loop */ |
| } |
| } |
| |
| /* if current font is an ISO-Latin-1 Hershey font, is this an |
| escape sequence for an 8-bit (non-ASCII) char, which due to |
| nonexistence should be deligatured? */ |
| if (1 /* _plotter->drawstate->font_type == F_HERSHEY */ |
| && _hershey_font_info[raw_fontnum].iso8859_1) |
| { |
| int i; |
| bool matched = false; |
| |
| for (i = 0; i < NUM_DELIGATURED_ESCAPES; i++) |
| if (strcmp ((char *)esc, _deligature_escape_tbl[i].from) == 0) |
| { |
| matched = true; |
| break; |
| } |
| if (matched) |
| { |
| if (_deligature_escape_tbl[i].except_font != raw_fontnum) |
| { |
| dest[j++] = fontword |
| | (unsigned short)_deligature_escape_tbl[i].to[0]; |
| dest[j++] = fontword |
| | (unsigned short)_deligature_escape_tbl[i].to[1]; |
| |
| continue; /* back to top of while loop */ |
| } |
| } |
| } |
| |
| /* if the current font is an ISO-Latin-1 font (no matter whether |
| font is a a Hershey font, a PS or PCL/Stick font, or a |
| device-specific font for which we have no table entry), is |
| this an escape seq. for an 8-bit (non-ASCII) ISO8859-1 char? */ |
| |
| /* PAUL MURRELL |
| Only concerned with Hershey fonts |
| */ |
| /* |
| if ((_plotter->drawstate->font_type == F_POSTSCRIPT |
| && _ps_font_info[raw_fontnum].iso8859_1) |
| || (_plotter->drawstate->font_type == F_HERSHEY |
| && _hershey_font_info[raw_fontnum].iso8859_1) |
| || (_plotter->drawstate->font_type == F_PCL |
| && _pcl_font_info[raw_fontnum].iso8859_1) |
| || (_plotter->drawstate->font_type == F_STICK |
| && _stick_font_info[raw_fontnum].iso8859_1) |
| || (_plotter->drawstate->font_type == F_OTHER |
| && _plotter->drawstate->font_is_iso8859_1 |
| && raw_fontnum == 1)) |
| */ |
| if (1 /* _plotter->drawstate->font_type == F_HERSHEY */ |
| && _hershey_font_info[raw_fontnum].iso8859_1) |
| { |
| bool matched = false; |
| |
| for (i = 0; i < NUM_ISO_ESCAPES; i++) |
| if (strcmp ((char *)esc, _iso_escape_tbl[i].string) == 0) |
| { |
| matched = true; |
| break; |
| } |
| if (matched) /* it's an 8-bit ISO8859-1 character */ |
| { |
| /* certain such characters are drawn in the Hershey fonts |
| as superscripts */ |
| if (1) /* _plotter->drawstate->font_type == F_HERSHEY) */ |
| { |
| int k; |
| bool matched2 = false; |
| |
| /* check if this is a `raised' ISO-Latin-1 character */ |
| for (k = 0; k < NUM_RAISED_CHARS; k++) |
| if (_iso_escape_tbl[i].byte == _raised_char_tbl[k].from) |
| { |
| matched2 = true; |
| break; |
| } |
| if (matched2) /* it's a raised character */ |
| { |
| /* map to string of unsigned shorts, length 3 or 6: |
| `begin superscript' control code, [`mark' |
| control code,] replacement char, [`return' |
| control code, underline,] `end superscript' */ |
| dest[j++] = |
| (unsigned short) (CONTROL_CODE | C_BEGIN_SUPERSCRIPT); |
| if (_raised_char_tbl[k].underscored) /* also underline */ |
| { |
| dest[j++] = |
| (unsigned short) (CONTROL_CODE | C_PUSH_LOCATION); |
| dest[j++] = |
| fontword | (unsigned short)_raised_char_tbl[k].to; |
| dest[j++] = |
| (unsigned short) (CONTROL_CODE | C_POP_LOCATION); |
| /* select appropriate HersheySymbol font */ |
| dest[j++] = |
| symbol_fontword | (unsigned short)VECTOR_SYMBOL_FONT_UNDERSCORE; |
| } |
| else /* just print raised char, no underline */ |
| { |
| dest[j++] = |
| fontword | (unsigned short)_raised_char_tbl[k].to; |
| } |
| |
| dest[j++] = |
| (unsigned short) (CONTROL_CODE | C_END_SUPERSCRIPT); |
| |
| continue; /* back to top of while loop */ |
| } |
| } |
| |
| /* won't draw this char as a superscript; just pass thru */ |
| dest[j++] = fontword | (unsigned short)(_iso_escape_tbl[i].byte); |
| continue; /* back to top of while loop */ |
| } |
| } |
| |
| /* is this an escape seq. for a `special' (non-ISO, non-Symbol) |
| Hershey glyph? Such glyphs include astronomical signs, and |
| `final s'. */ |
| if (1) /* _plotter->drawstate->font_type == F_HERSHEY) */ |
| { |
| bool matched = false; |
| |
| for (i = 0; i < NUM_SPECIAL_ESCAPES; i++) |
| if (strcmp ((char *)esc, _special_escape_tbl[i].string) == 0) |
| { |
| matched = true; |
| break; |
| } |
| if (matched) /* it's a special character */ |
| { |
| /* "\s-" is special; yields character in current font */ |
| if (_special_escape_tbl[i].byte == FINAL_LOWERCASE_S) |
| dest[j++] = |
| fontword | (unsigned short)(_special_escape_tbl[i].byte); |
| else |
| /* we select symbol font of typeface, in which we've |
| stored all other special characters */ |
| dest[j++] = symbol_fontword | (unsigned short)(_special_escape_tbl[i].byte); |
| continue; /* back to top of while loop */ |
| } |
| } |
| |
| { |
| bool matched = false; |
| |
| /* Irrespective of font type, is this an escape seq. for a char |
| in the font's corresponding symbol font? */ |
| for (i = 0; i < NUM_SYMBOL_ESCAPES; i++) |
| if (strcmp (_symbol_escape_tbl[i].string, "NO_ABBREV") != 0 |
| && strcmp ((char *)esc, _symbol_escape_tbl[i].string) == 0) |
| { |
| matched = true; |
| break; |
| } |
| if (matched) /* it's a character in the symbol font */ |
| { |
| /* select symbol font by OR'ing in the symbol fontword */ |
| dest[j++] = symbol_fontword | (unsigned short)(_symbol_escape_tbl[i].byte); |
| continue; /* back to top of while loop */ |
| } |
| } |
| |
| /* Gross kludge. In the non-Hershey fonts we handle the "\rn" |
| control sequence in a painful way. For a PS font we map it |
| into (1) a left shift, (2) the `radicalex' character in the PS |
| Symbol font, and (3) a right shift. Shift distances are taken |
| from the bbox of the radicalex char, and are slightly larger |
| than 0.5 em. For a PCL font it's similar, but the shifts are |
| much smaller. The reason it's different for PCL is that the |
| PCL radicalex character is different from the PS radicalex |
| character: the overbar is not displaced. Possibly someone at |
| HP made a mistake while reimplementing the Adobe Symbol font |
| for PCL 5? |
| |
| We don't implement \rn for Stick fonts, because they have |
| no associated symbol font. */ |
| |
| /* couldn't match; unknown escape seq., so pass through unchanged */ |
| dest[j++] = fontword | (unsigned short)'\\'; |
| dest[j++] = fontword | (unsigned short)c; |
| dest[j++] = fontword | (unsigned short)d; |
| } |
| } |
| |
| dest[j] = (unsigned short)'\0'; /* terminate string */ |
| |
| return dest; |
| } |
| |
| #ifdef UNUSED |
| int |
| #ifdef _HAVE_PROTOS |
| _codestring_len (const unsigned short *codestring) |
| #else |
| _codestring_len (codestring) |
| const unsigned short *codestring; |
| #endif |
| { |
| int i = 0; |
| |
| while (*codestring) |
| { |
| i++; |
| codestring++; |
| } |
| |
| return i; |
| } |
| #endif |