ttf2pfb.c

字体缩放显示

  UShort    numCR = 0, numLow = 0;
  int       start, end;
  int       buflen = LINELEN, numAssigned;
  char      buf[LINELEN];

  if (force_enc != 0)
    return eVecMap_force[force_enc];

  if (enc == NULL && eVecMap[pid][eid] != NULL)
    return eVecMap[pid][eid];

  /* parse each code range line */
  while (fgets(buf, buflen, enc) != NULL)
  {
    if (buf[0] != '#' && buf[0] != '\n')
    {
      if (strrchr(buf,':') != NULL)
      {
        /* if there is no high value declared before low value */
        if (lByte != NULL)
        {
          if (cRange == NULL)
          {
            /* default code range `0x00-0x00:' */
            cRange = re_alloc(cRange, ++numCR * sizeof (EVcRange),
                              "Get_EncVec");
            cRange->high.start = cRange->high.end = 0;
          }
          /* Assign the last low value */
          (cRange + numCR - 1)->low          = lByte;
          (cRange + numCR - 1)->numLowRanges = numLow;
        }

        /* New high byte range */
        cRange = re_alloc(cRange, ++numCR * sizeof (EVcRange), "Get_EncVec");
        (cRange + numCR - 1)->numLowRanges = numLow = 0;
        lByte = NULL;

        /* Parse code range */
        numAssigned = sscanf(buf, "%i %*40s %i", &start, &end);
        if (numAssigned <= 0 || numAssigned > 2)
        {
          mesg("%s: Get_EncVec: Invalid high code range.\n", prog);
          return NULL;
        }
        else
        {
          (cRange + numCR - 1)->high.start = start;
          if (numAssigned == 1)
            (cRange + numCR - 1)->high.end = start;
          else
            (cRange + numCR - 1)->high.end = end;
        }
      }
      else
      {
        lByte = re_alloc(lByte, ++numLow * sizeof (EVLow), "Get_EncVec");
        numAssigned = sscanf(buf, "%i %*40s %i", &start, &end);
        if (numAssigned <= 0 || numAssigned > 2)
        {
          mesg("%s: Get_EncVec: Invalid long code range.\n", prog);
          return NULL;
        }
        else
        {
          (lByte + numLow - 1)->start = start;
          if (numAssigned == 1)
            (lByte + numLow - 1)->end = start;
          else
            (lByte + numLow - 1)->end = end;
        }
      }
    }
  }

  if (cRange == NULL)
  {
    cRange = re_alloc(cRange, ++numCR * sizeof (EVcRange), "Get_EncVec");
    cRange->high.start = cRange->high.end = 0;
    cRange->numLowRanges = 0;
  }

  if (lByte != NULL)
  {
    (cRange + numCR - 1)->low          = lByte;
    (cRange + numCR - 1)->numLowRanges = numLow;
  }

  encVec = re_alloc(encVec, 1 * sizeof (EncVec), "Get_EncVec");
  encVec->numCodeRanges = numCR;
  encVec->codeRange = cRange;
  return encVec;
}


/*
 * Match code ranges by a font plane.
 */

EncVec*
Get_PlaneEV(EncVec* encVec,
            int plane)
{
  UShort    numCR  = encVec->numCodeRanges;
  EVcRange* cRange = encVec->codeRange;

  EncVec*   encV = NULL;
  EVcRange* planeCR = NULL;
  EVLow*    planeLow = NULL;
  UShort    nCR = 0, nLow = 0;

  int       icr;

  if (compact)
  {
    int iChar = 0;               /* summed # of chars */
    int nChar = (plane-1) * 256; /* the first char code ranges recorded */
    int recording = 0;

    /* if compact, plane starts from 1 to be */
    /* compatible with the CJK package */
    if (plane < 1 || plane > 99)
      fatal("Get_PlaneEV: Given plane out of range");

    for (icr = 0; icr < numCR; icr++, cRange++)
    {
      UShort numLow = cRange->numLowRanges;
      int    ipl;

      for (ipl = cRange->high.start; ipl <= cRange->high.end; ipl++)
      {
        EVLow* pLow = cRange->low;
        int ilow;

        if (recording)
        { /* if we have made a hit */
          if (planeLow != NULL)
          { /* if low byte range has not been saved */
            (planeCR + nCR - 1)->low = planeLow;
            (planeCR + nCR - 1)->numLowRanges = nLow;
            planeLow = NULL;
          }

          /* each new plane starts a EVcRange if */
          /* iChar is still less than nChar */
          if (iChar <= nChar)
          {
            planeCR = re_alloc(planeCR, ++nCR * sizeof (EVcRange),
                               "Get_PlaneEV");
            (planeCR + nCR - 1)->high.start =
              (planeCR + nCR - 1)->high.end = ipl;
            (planeCR + nCR - 1)->numLowRanges = nLow = 0;
          }
        }

        /* scan each low byte range */
        for (ilow = 0; ilow < (numLow == 0 ? 1 : numLow); ilow++, pLow++)
        {
          int start, end, nLowChar;

          if (numLow == 0)
          { /* default range */
            start = 0x0;
            end   = 0xff;
          }
          else
          {
            start = pLow->start;
            end   = pLow->end;
          }
          nLowChar = end - start + 1;
          if (iChar + nLowChar > nChar)
          { /* a hit! */
            int bchar = start + nChar - iChar;
            if (planeCR == NULL)
            {
              /* the first time code range is recorded */
              planeCR = re_alloc(planeCR, ++nCR * sizeof (EVcRange),
                                 "Get_PlaneEV");
              (planeCR + nCR - 1)->high.start = ipl;
              (planeCR + nCR - 1)->high.end   = ipl;
            }

            /* adjust range boundary */
            if (recording == 0)
              start = bchar;
            else
              end = bchar;
            nChar += 0xff;

            /* recording starts */
            recording++;
          }

          iChar += nLowChar;    /* next range */

          if (recording)
          {
            /* a new low range */
            if (iChar <= nChar)
            {
              planeLow = re_alloc(planeLow, ++nLow * sizeof (EVLow),
                                  "Get_PlaneEV");
              (planeLow + nLow - 1)->start = start;
              (planeLow + nLow - 1)->end   = end;
            }
            if (recording > 1 || iChar > nChar)
            {
              /* beyond recording range */
              (planeCR + nCR - 1)->numLowRanges = nLow;
              (planeCR + nCR - 1)->low = planeLow;
              encV = re_alloc(encV, 1 * sizeof (EncVec), "Get_PlaneEV");
              encV->numCodeRanges = nCR;
              encV->codeRange = planeCR;
              return encV;
            }
          }
        }
      }
    }
    /* we must finalize the ranges */
    if (recording)
    {
      (planeCR + nCR - 1)->numLowRanges = nLow;
      (planeCR + nCR - 1)->low = planeLow;
      encV = re_alloc(encV, 1 * sizeof (EncVec), "Get_PlaneEV");
      encV->numCodeRanges = nCR;
      encV->codeRange = planeCR;
      return encV;
    }
  }
  else
  {
    for (icr = 0; icr < numCR; icr++, cRange++)
    {
      if (plane >= cRange->high.start && plane <= cRange->high.end)
      {
        encV = re_alloc(encV, 1 * sizeof (EncVec), "Get_PlaneEV");
        planeCR = re_alloc(planeCR, 1 * sizeof (EVcRange), "Get_PlaneEV");

        planeCR->high.start = planeCR->high.end = plane;
        planeCR->numLowRanges = cRange->numLowRanges;
        planeCR->low = cRange->low;
        encV->numCodeRanges = 1;
        encV->codeRange = planeCR;
        return encV;
      }
    }
  }
  return NULL;
}


/*
 * The main subroutine for generating Type 1 fonts.
 * One subfont per call.
 */

short
Generate_Font(FILE *out,
              int plane,
              FILE *enc,
              char *fname,
              int UID)
{
  EncVec*   encVec = Get_EncVec(enc);
  EncVec*   planeEncVec;
  EVcRange* cRange;
  UShort    numCR;
  UShort    code;
  int       ilow, iplan, ichar, irange;

  if (verbose)
    printf("Generating fonts...\n\n");

  if (encVec == NULL)
    return FALSE;
  if (mapping)
    planeEncVec = encVec;
  else
    if ((planeEncVec = Get_PlaneEV(encVec, plane)) == NULL)
    {
      mesg("%s: Can't find encoding vector for the font plane 0x%X.\n",
           prog, plane);
      return FALSE;
    }

  /* Header of Type1 font */
  PS_Head(out, plane, planeEncVec, fname, UID);

  numCR  = planeEncVec->numCodeRanges;
  cRange = planeEncVec->codeRange;

  for (irange = 0; irange < numCR; irange++, cRange++)
  {
    EVLow* pLow = cRange->low;
    UShort nLow = cRange->numLowRanges;

    for (iplan = cRange->high.start; iplan <= cRange->high.end; iplan++)
    {
      if (nLow == 0)
      {
        for (ichar = 0; ichar <= 0xff; ichar++)
        {
          code = iplan << 8 | ichar;
          PS_CharString(out, code);
        }
      }
      else
      {
        for (ilow = 0; ilow < nLow; ilow++, pLow++)
        {
          for (ichar = pLow->start; ichar <= pLow->end; ichar++)
          {
            code = iplan << 8 | ichar;
            PS_CharString(out, code);
          }
        }
      }
    }
  }
  PS_Tail(out);

  return TRUE;
}


/*
 * Main: process options, file I/O, etc.
 */

int
main(int argc,
     char *argv[])
{
  char *infile, *outfile, *encFile, *fname = "UNKNOWN";
  FILE *out, *enc;
  int  result, plane = 0, UID = 4999999;

  if ((prog = strrchr(argv[0], '/')))
    prog++;
  else
    prog = argv[0];

  /* set up known encoding vectors */
  Known_Encodings();

  out    = stdout;
  enc    = NULL;
  infile = outfile = encFile = NULL;

  argc--;
  argv++;

  while (argc > 0)
  {
    if (argv[0][0] == '-')
    {
      switch (argv[0][1])
      {
      case 'v':
      case 'V':
        verbose = TRUE;
        break;
      case 'c':
      case 'C':
        compact = TRUE;
        break;
      case 'k':
      case 'K':
        keep = TRUE;
        break;
      case 'm':
      case 'M':
        mapping = TRUE;
        break;
      case 'p':
      case 'P':
        result = argv[0][2];
        argc--;
        argv++;
        if (result == 'i' || result == 'I')
        {
          /* Set the platform ID. Assumed upper bound is 64 */
          if ((pid = atoi(argv[0])) < 0 || pid > 64)
            /* Check the platform and encoding IDs. */
            fatal("Invalid platform ID %d", pid);
        }
        else if (result == 'l' || result == 'L')
        {
          result = 0;
          while (argv[0][result] == '0' &&
                 toupper(argv[0][result + 1]) != 'X')
            result++; /* no octal number */
          sscanf(&argv[0][result], "%i", &plane);
        }
        break;
      case 'e':
      case 'E':
        result = argv[0][2];
        argc--;
        argv++;
        if (result == 'i' || result == 'I')
        {
          /* Set the encoding ID. */
          if ((eid = atoi(argv[0])) < 0 || eid > 64)
            fatal("Invalid encoding ID %d", eid);
        }
        else if (result == 'n' || result == 'N')
          encFile = argv[0];
        break;
      case 'u':
      case 'U':
        argc--;
        argv++;
        UID = atoi(argv[0]);
        break;
      case 'f':
      case 'F':
        result = argv[0][2];
        argc--;
        argv++;
        if (result == '\0')
          fname = argv[0];
        else if (result == 'o' || result == 'O')
        {
          switch (argv[0][0])
          {
          case 'g':
          case 'G':
            force_enc = GB;
            break;
          case 'k':
          case 'K':
            force_enc = KS;
            break;
          case 'b':
          case 'B':
            force_enc = Big5;
            break;
          case 'j':
          case 'J':
            result = argv[0][1];
            if (result == 'o' || result == 'O')
              force_enc = Johab;
            else
              force_enc = JIS;
            break;
          case 's':
          case 'S':
            force_enc = SJIS;
            break;
          case 'x':
          case 'X':
            force_enc = X;
          }
        }
        break;
      case 't':                 /* Get the TTF file name. */
      case 'T':
        argc--;
        argv++;
        infile = argv[0];
        break;
      case 'o':                 /* Set the output file name. */
      case 'O':
        argc--;
        argv++;
        outfile = argv[0];
        break;
      case 's':                 /* shift font bbox up or down */
      case 'S':
        argc--;
        argv++;
        sscanf(argv[0], "%f", &fontShift);
        break;
#ifdef DEBUG
      case 'd':                 /* character code for debugging */
      case 'D':
        argc--;
        argv++;
        sscanf(argv[0], "%i", &debug_Char_Code);
        tmpout = fopen("ch-debug.ps", "wt");
        mesg("You have specified the character code 0x%04x for debugging.\n",
             debug_Char_Code);
        mesg("A PostScript program named `ch-debug.ps' will be created.\n");
        break;
      case 'l':
      case 'L':
        showlabel = TRUE;
        break;
      case 'n':
      case 'N':
        result = argv[0][2];
        if (result == 'g' || result == 'G')
          no_glyph = TRUE;
        else if (result == 'c' || result == 'C')
          no_control = TRUE;
        break;
#endif
      default:
        Usage(1);
      }
    }
    else
      /* Set the input file name. */
      infile = argv[0];

    argc--;
    argv++;
  }

  /* Open the output file if specified. */
  if (outfile != NULL)
    /* Attempt to open the output file. */
    if ((out = fopen(outfile, "wt")) == 0)
    {
      fatal("Unable to open the output file `%s'", outfile);
      exit(FAILURE);
    }

  /* Validate the values passed on the command line. */
  if (infile == NULL)
  {
    mesg("%s: No input TTF file provided\n", prog);
    Usage(1);
  }

  if (encFile != NULL)
  {
    if ((enc = fopen(encFile, "rt")) == 0)
      fatal("No input code range file");
  }

  /* Initialize font engine */
  if (!Init_Font_Engine(infile))
  {
    if (out != stdout)
    {
      fclose(out);
      if (!keep)
        (void)unlink(outfile);
    }
    exit(FAILURE);
  }

  /* Generate the disassembled PFB font from the TrueType font */
  if (Generate_Font(out, plane, enc, fname, UID))
    result = 0;
  else
    result = 2;

  if (out != stdout)
  {
    fclose(out);
    if (result != 0)
    {
      mesg("%s: An error occurred while generating the font", prog);
      if (!keep)
        (void)unlink(outfile);
    }
  }

  TT_Close_Face(face);
  TT_Done_FreeType(engine);

  exit(result);

  return 0; /* never reached */
}


/* end of ttf2pfb.c */