/* 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;

      bool0 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;

      bool0 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;

    bool0 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;

        bool0 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;

          bool0 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;

          bool0 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 */

      }

        }

    }

      }

    {

      bool0 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;

        bool0 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)

      {

        bool0 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;

          bool0 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) */

      {

        bool0 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 */

    }

      }

    {

      bool0 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