Attachment #172704: Patch to eliminate xpdf deprecated char* coversion warnings for bug #247982

// FoFiBase

// FoFiBase

//------------------------------------------------------------------------

//------------------------------------------------------------------------

  fileData = file = (Guchar *)fileA;

  fileData = file = (Guchar *)fileA;

  len = lenA;

  len = lenA;

  freeFileData = freeFileDataA;

  freeFileData = freeFileDataA;

  }

  }

}

}

  FILE *f;

  FILE *f;

  char *buf;

  char *buf;

  int n;

  int n;

//------------------------------------------------------------------------

//------------------------------------------------------------------------

//------------------------------------------------------------------------

//------------------------------------------------------------------------

// FoFiBase

// FoFiBase

protected:

protected:

  // S = signed / U = unsigned

  // S = signed / U = unsigned

  // 8/16/32/Var = word length, in bytes

  // 8/16/32/Var = word length, in bytes

// Type 1 and 1C font data

// Type 1 and 1C font data

//------------------------------------------------------------------------

//------------------------------------------------------------------------

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

  NULL

  NULL

};

};

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

// Type 1C font data

// Type 1C font data

//------------------------------------------------------------------------

//------------------------------------------------------------------------

  ".notdef",

  ".notdef",

  "space",

  "space",

  "exclam",

  "exclam",

// Type 1 and 1C font data

// Type 1 and 1C font data

//------------------------------------------------------------------------

//------------------------------------------------------------------------

//------------------------------------------------------------------------

//------------------------------------------------------------------------

// Type 1C font data

// Type 1C font data

//------------------------------------------------------------------------

//------------------------------------------------------------------------

extern Gushort fofiType1CISOAdobeCharset[229];

extern Gushort fofiType1CISOAdobeCharset[229];

extern Gushort fofiType1CExpertCharset[166];

extern Gushort fofiType1CExpertCharset[166];

extern Gushort fofiType1CExpertSubsetCharset[87];

extern Gushort fofiType1CExpertSubsetCharset[87];

//------------------------------------------------------------------------

//------------------------------------------------------------------------

struct T42Table {

struct T42Table {

  GBool required;		// required by the TrueType spec?

  GBool required;		// required by the TrueType spec?

};

};

// Glyph names in some arbitrary standard order that Apple uses for

// Glyph names in some arbitrary standard order that Apple uses for

// their TrueType fonts.

// their TrueType fonts.

  ".notdef",        "null",           "CR",             "space",

  ".notdef",        "null",           "CR",             "space",

  "exclam",         "quotedbl",       "numbersign",     "dollar",

  "exclam",         "quotedbl",       "numbersign",     "dollar",

  "percent",        "ampersand",      "quotesingle",    "parenleft",

  "percent",        "ampersand",      "quotesingle",    "parenleft",

// FoFiTrueType

// FoFiTrueType

//------------------------------------------------------------------------

//------------------------------------------------------------------------

  FoFiTrueType *ff;

  FoFiTrueType *ff;

  ff = new FoFiTrueType(fileA, lenA, gFalse);

  ff = new FoFiTrueType(fileA, lenA, gFalse);

  return ff;

  return ff;

}

}

  FoFiTrueType *ff;

  FoFiTrueType *ff;

  int lenA;

  int lenA;

  if (!(fileA = FoFiBase::readFile(fileName, &lenA))) {

  if (!(fileA = FoFiBase::readFile(fileName, &lenA))) {

  return ff;

  return ff;

}

}

  FoFiBase(fileA, lenA, freeFileDataA)

  FoFiBase(fileA, lenA, freeFileDataA)

{

{

  tables = NULL;

  tables = NULL;

  return gid;

  return gid;

}

}

  if (!nameToGID) {

  if (!nameToGID) {

    return 0;

    return 0;

  }

  }

  if (!checkRegion(tables[i].offset, tables[i].len)) {

  if (!checkRegion(tables[i].offset, tables[i].len)) {

    return NULL;

    return NULL;

  }

  }

			      tables[i].len))) {

			      tables[i].len))) {

    return NULL;

    return NULL;

  }

  }

  return 3;

  return 3;

}

}

				   Gushort *codeToGID,

				   Gushort *codeToGID,

				   FoFiOutputFunc outputFunc,

				   FoFiOutputFunc outputFunc,

				   void *outputStream) {

				   void *outputStream) {

  (*outputFunc)(outputStream, "FontName currentdict end definefont pop\n", 40);

  (*outputFunc)(outputStream, "FontName currentdict end definefont pop\n", 40);

}

}

				  GBool ascii, FoFiOutputFunc outputFunc,

				  GBool ascii, FoFiOutputFunc outputFunc,

				  void *outputStream) {

				  void *outputStream) {

  FoFiType1C *ff;

  FoFiType1C *ff;

  if (!checkRegion(tables[i].offset, tables[i].len)) {

  if (!checkRegion(tables[i].offset, tables[i].len)) {

    return;

    return;

  }

  }

			      tables[i].len))) {

			      tables[i].len))) {

    return;

    return;

  }

  }

  delete ff;

  delete ff;

}

}

				     Gushort *cidMap, int nCIDs,

				     Gushort *cidMap, int nCIDs,

				     GBool needVerticalMetrics,

				     GBool needVerticalMetrics,

				     FoFiOutputFunc outputFunc,

				     FoFiOutputFunc outputFunc,

		56);

		56);

}

}

				     FoFiOutputFunc outputFunc,

				     FoFiOutputFunc outputFunc,

				     void *outputStream) {

				     void *outputStream) {

  FoFiType1C *ff;

  FoFiType1C *ff;

  if (!checkRegion(tables[i].offset, tables[i].len)) {

  if (!checkRegion(tables[i].offset, tables[i].len)) {

    return;

    return;

  }

  }

			      tables[i].len))) {

			      tables[i].len))) {

    return;

    return;

  }

  }

  delete ff;

  delete ff;

}

}

				  GBool needVerticalMetrics,

				  GBool needVerticalMetrics,

				  FoFiOutputFunc outputFunc,

				  FoFiOutputFunc outputFunc,

				  void *outputStream) {

				  void *outputStream) {

  (*outputFunc)(outputStream, "FontName currentdict end definefont pop\n", 40);

  (*outputFunc)(outputStream, "FontName currentdict end definefont pop\n", 40);

}

}

				  FoFiOutputFunc outputFunc,

				  FoFiOutputFunc outputFunc,

				  void *outputStream) {

				  void *outputStream) {

  FoFiType1C *ff;

  FoFiType1C *ff;

  if (!checkRegion(tables[i].offset, tables[i].len)) {

  if (!checkRegion(tables[i].offset, tables[i].len)) {

    return;

    return;

  }

  }

			      tables[i].len))) {

			      tables[i].len))) {

    return;

    return;

  }

  }

}

}

void FoFiTrueType::writeTTF(FoFiOutputFunc outputFunc,

void FoFiTrueType::writeTTF(FoFiOutputFunc outputFunc,

			    Gushort *codeToGID) {

			    Gushort *codeToGID) {

  // this substitute cmap table maps char codes 0000-ffff directly to

  // this substitute cmap table maps char codes 0000-ffff directly to

  // glyphs 0000-ffff

  // glyphs 0000-ffff

  if (!missingCmap && !missingName && !missingPost && !missingOS2 &&

  if (!missingCmap && !missingName && !missingPost && !missingOS2 &&

      !unsortedLoca && !badCmapLen && !abbrevHMTX && nZeroLengthTables == 0 &&

      !unsortedLoca && !badCmapLen && !abbrevHMTX && nZeroLengthTables == 0 &&

      !name && !codeToGID) {

      !name && !codeToGID) {

    goto done1;

    goto done1;

  }

  }

  for (i = 0; i < nNewTables; ++i) {

  for (i = 0; i < nNewTables; ++i) {

    if (newTables[i].tag == headTag) {

    if (newTables[i].tag == headTag) {

      if (checkRegion(newTables[i].origOffset, newTables[i].len)) {

      if (checkRegion(newTables[i].origOffset, newTables[i].len)) {

	checksumBuf[0] = fileChecksum >> 24;

	checksumBuf[0] = fileChecksum >> 24;

	checksumBuf[1] = fileChecksum >> 16;

	checksumBuf[1] = fileChecksum >> 16;

	checksumBuf[2] = fileChecksum >> 8;

	checksumBuf[2] = fileChecksum >> 8;

	checksumBuf[3] = fileChecksum;

	checksumBuf[3] = fileChecksum;

	(*outputFunc)(outputStream, checksumBuf, 4);

	(*outputFunc)(outputStream, checksumBuf, 4);

	(*outputFunc)(outputStream,

	(*outputFunc)(outputStream,

		      newTables[i].len - 12);

		      newTables[i].len - 12);

      } else {

      } else {

	for (j = 0; j < newTables[i].len; ++j) {

	for (j = 0; j < newTables[i].len; ++j) {

	if (n > 0) {

	if (n > 0) {

	  k = locaTable[j].origOffset;

	  k = locaTable[j].origOffset;

	  if (checkRegion(pos + k, n)) {

	  if (checkRegion(pos + k, n)) {

	  } else {

	  } else {

	    for (k = 0; k < n; ++k) {

	    for (k = 0; k < n; ++k) {

	      (*outputFunc)(outputStream, "\0", 1);

	      (*outputFunc)(outputStream, "\0", 1);

      }

      }

    } else {

    } else {

      if (checkRegion(newTables[i].origOffset, newTables[i].len)) {

      if (checkRegion(newTables[i].origOffset, newTables[i].len)) {

		      newTables[i].len);

		      newTables[i].len);

      } else {

      } else {

	for (j = 0; j < newTables[i].len; ++j) {

	for (j = 0; j < newTables[i].len; ++j) {

  gfree(locaTable);

  gfree(locaTable);

}

}

			       FoFiOutputFunc outputFunc,

			       FoFiOutputFunc outputFunc,

			       void *outputStream) {

			       void *outputStream) {

  GString *buf;

  GString *buf;

  int i;

  int i;

  (*outputFunc)(outputStream, "readonly def\n", 13);

  (*outputFunc)(outputStream, "readonly def\n", 13);

}

}

				  Gushort *codeToGID,

				  Gushort *codeToGID,

				  FoFiOutputFunc outputFunc,

				  FoFiOutputFunc outputFunc,

				  void *outputStream) {

				  void *outputStream) {

  GString *buf;

  GString *buf;

  char buf2[16];

  char buf2[16];

  int i, k;

  int i, k;

	if (!ok || !checkRegion(stringPos + 1, m)) {

	if (!ok || !checkRegion(stringPos + 1, m)) {

	  goto err;

	  goto err;

	}

	}

	nameToGID->removeInt(name);

	nameToGID->removeInt(name);

	nameToGID->add(name, i);

	nameToGID->add(name, i);

	++stringIdx;

	++stringIdx;

  }

  }

}

}

  Guint tagI;

  Guint tagI;

  int i;

  int i;

public:

public:

  // Create a FoFiTrueType object from a memory buffer.

  // Create a FoFiTrueType object from a memory buffer.

  // Create a FoFiTrueType object from a file on disk.

  // Create a FoFiTrueType object from a file on disk.

  virtual ~FoFiTrueType();

  virtual ~FoFiTrueType();

  // Returns the GID corresponding to <name> according to the post

  // Returns the GID corresponding to <name> according to the post

  // table.  Returns 0 if there is no mapping for <name> or if the

  // table.  Returns 0 if there is no mapping for <name> or if the

  // font does not have a post table.

  // font does not have a post table.

  // Return the mapping from CIDs to GIDs, and return the number of

  // Return the mapping from CIDs to GIDs, and return the number of

  // CIDs in *<nCIDs>.  This is only useful for CID fonts.  (Only

  // CIDs in *<nCIDs>.  This is only useful for CID fonts.  (Only

  // If <encoding> is NULL, the encoding is unknown or undefined.  The

  // If <encoding> is NULL, the encoding is unknown or undefined.  The

  // <codeToGID> array specifies the mapping from char codes to GIDs.

  // <codeToGID> array specifies the mapping from char codes to GIDs.

  // (Not useful for OpenType CFF fonts.)

  // (Not useful for OpenType CFF fonts.)

		       Gushort *codeToGID,

		       Gushort *codeToGID,

		       FoFiOutputFunc outputFunc, void *outputStream);

		       FoFiOutputFunc outputFunc, void *outputStream);

  // otherwise it will be left as binary data.  If <psName> is

  // otherwise it will be left as binary data.  If <psName> is

  // non-NULL, it will be used as the PostScript font name.  (Only

  // non-NULL, it will be used as the PostScript font name.  (Only

  // useful for OpenType CFF fonts.)

  // useful for OpenType CFF fonts.)

		      FoFiOutputFunc outputFunc, void *outputStream);

		      FoFiOutputFunc outputFunc, void *outputStream);

  // Convert to a Type 2 CIDFont, suitable for embedding in a

  // Convert to a Type 2 CIDFont, suitable for embedding in a

  // name (so we don't need to depend on the 'name' table in the

  // name (so we don't need to depend on the 'name' table in the

  // font).  The <cidMap> array maps CIDs to GIDs; it has <nCIDs>

  // font).  The <cidMap> array maps CIDs to GIDs; it has <nCIDs>

  // entries.  (Not useful for OpenType CFF fonts.)

  // entries.  (Not useful for OpenType CFF fonts.)

			 GBool needVerticalMetrics,

			 GBool needVerticalMetrics,

			 FoFiOutputFunc outputFunc, void *outputStream);

			 FoFiOutputFunc outputFunc, void *outputStream);

  // Convert to a Type 0 CIDFont, suitable for embedding in a

  // Convert to a Type 0 CIDFont, suitable for embedding in a

  // PostScript file.  <psName> will be used as the PostScript font

  // PostScript file.  <psName> will be used as the PostScript font

  // name.  (Only useful for OpenType CFF fonts.)

  // name.  (Only useful for OpenType CFF fonts.)

			 FoFiOutputFunc outputFunc, void *outputStream);

			 FoFiOutputFunc outputFunc, void *outputStream);

  // Convert to a Type 0 (but non-CID) composite font, suitable for

  // Convert to a Type 0 (but non-CID) composite font, suitable for

  // PostScript font name (so we don't need to depend on the 'name'

  // PostScript font name (so we don't need to depend on the 'name'

  // table in the font).  The <cidMap> array maps CIDs to GIDs; it has

  // table in the font).  The <cidMap> array maps CIDs to GIDs; it has

  // <nCIDs> entries.  (Not useful for OpenType CFF fonts.)

  // <nCIDs> entries.  (Not useful for OpenType CFF fonts.)

		      GBool needVerticalMetrics,

		      GBool needVerticalMetrics,

		      FoFiOutputFunc outputFunc, void *outputStream);

		      FoFiOutputFunc outputFunc, void *outputStream);

  // Convert to a Type 0 (but non-CID) composite font, suitable for

  // Convert to a Type 0 (but non-CID) composite font, suitable for

  // embedding in a PostScript file.  <psName> will be used as the

  // embedding in a PostScript file.  <psName> will be used as the

  // PostScript font name.  (Only useful for OpenType CFF fonts.)

  // PostScript font name.  (Only useful for OpenType CFF fonts.)

		      FoFiOutputFunc outputFunc, void *outputStream);

		      FoFiOutputFunc outputFunc, void *outputStream);

  // Write a clean TTF file, filling in missing tables and correcting

  // Write a clean TTF file, filling in missing tables and correcting

  // complete and correct, it will be written unmodified.  (Not useful

  // complete and correct, it will be written unmodified.  (Not useful

  // for OpenType CFF fonts.)

  // for OpenType CFF fonts.)

  void writeTTF(FoFiOutputFunc outputFunc, void *outputStream,

  void writeTTF(FoFiOutputFunc outputFunc, void *outputStream,

private:

private:

		   FoFiOutputFunc outputFunc,

		   FoFiOutputFunc outputFunc,

		   void *outputStream);

		   void *outputStream);

		      Gushort *codeToGID,

		      Gushort *codeToGID,

		      FoFiOutputFunc outputFunc,

		      FoFiOutputFunc outputFunc,

		      void *outputStream);

		      void *outputStream);

  Guint computeTableChecksum(Guchar *data, int length);

  Guint computeTableChecksum(Guchar *data, int length);

  void parse();

  void parse();

  void readPostTable();

  void readPostTable();

  TrueTypeTable *tables;

  TrueTypeTable *tables;

  int nTables;

  int nTables;

// FoFiType1

// FoFiType1

//------------------------------------------------------------------------

//------------------------------------------------------------------------

  return new FoFiType1(fileA, lenA, gFalse);

  return new FoFiType1(fileA, lenA, gFalse);

}

}

  int lenA;

  int lenA;

  if (!(fileA = FoFiBase::readFile(fileName, &lenA))) {

  if (!(fileA = FoFiBase::readFile(fileName, &lenA))) {

  return new FoFiType1(fileA, lenA, gTrue);

  return new FoFiType1(fileA, lenA, gTrue);

}

}

  FoFiBase(fileA, lenA, freeFileDataA)

  FoFiBase(fileA, lenA, freeFileDataA)

{

{

  name = NULL;

  name = NULL;

  int i;

  int i;

  if (name) {

  if (name) {

  }

  }

  if (encoding && encoding != fofiType1StandardEncoding) {

  if (encoding && encoding != fofiType1StandardEncoding) {

    for (i = 0; i < 256; ++i) {

    for (i = 0; i < 256; ++i) {

    }

    }

    gfree(encoding);

    gfree(encoding);

  }

  }

}

}

  if (!parsed) {

  if (!parsed) {

    parse();

    parse();

  }

  }

  return name;

  return name;

}

}

  if (!parsed) {

  if (!parsed) {

    parse();

    parse();

  }

  }

  return encoding;

  return encoding;

}

}

			     FoFiOutputFunc outputFunc, void *outputStream) {

			     FoFiOutputFunc outputFunc, void *outputStream) {

  char buf[512];

  char buf[512];

  int i;

  int i;

  // copy everything up to the encoding

  // copy everything up to the encoding

       line && strncmp(line, "/Encoding", 9);

       line && strncmp(line, "/Encoding", 9);

       line = getNextLine(line)) ;

       line = getNextLine(line)) ;

  if (!line) {

  if (!line) {

    // no encoding - just copy the whole font file

    // no encoding - just copy the whole font file

    return;

    return;

  }

  }

  // write the new encoding

  // write the new encoding

  (*outputFunc)(outputStream, "/Encoding 256 array\n", 20);

  (*outputFunc)(outputStream, "/Encoding 256 array\n", 20);

    // copy everything after the encoding

    // copy everything after the encoding

    if (line) {

    if (line) {

    }

    }

  }

  }

}

}

  while (line < (char *)file + len && *line != '\x0a' && *line != '\x0d') {

  while (line < (char *)file + len && *line != '\x0a' && *line != '\x0d') {

    ++line;

    ++line;

  }

  }

}

}

void FoFiType1::parse() {

void FoFiType1::parse() {

  char buf[256];

  char buf[256];

  char c;

  char c;

  int n, code, i, j;

  int n, code, i, j;

      encoding = fofiType1StandardEncoding;

      encoding = fofiType1StandardEncoding;

    } else if (!encoding &&

    } else if (!encoding &&

	       !strncmp(line, "/Encoding 256 array", 19)) {

	       !strncmp(line, "/Encoding 256 array", 19)) {

      for (j = 0; j < 256; ++j) {

      for (j = 0; j < 256; ++j) {

	encoding[j] = NULL;

	encoding[j] = NULL;

      }

      }

// FoFiType1C

// FoFiType1C

//------------------------------------------------------------------------

//------------------------------------------------------------------------

  FoFiType1C *ff;

  FoFiType1C *ff;

  ff = new FoFiType1C(fileA, lenA, gFalse);

  ff = new FoFiType1C(fileA, lenA, gFalse);

  return ff;

  return ff;

}

}

  FoFiType1C *ff;

  FoFiType1C *ff;

  int lenA;

  int lenA;

  if (!(fileA = FoFiBase::readFile(fileName, &lenA))) {

  if (!(fileA = FoFiBase::readFile(fileName, &lenA))) {

  return ff;

  return ff;

}

}

  FoFiBase(fileA, lenA, freeFileDataA)

  FoFiBase(fileA, lenA, freeFileDataA)

{

{

  name = NULL;

  name = NULL;

      encoding != fofiType1StandardEncoding &&

      encoding != fofiType1StandardEncoding &&

      encoding != fofiType1ExpertEncoding) {

      encoding != fofiType1ExpertEncoding) {

    for (i = 0; i < 256; ++i) {

    for (i = 0; i < 256; ++i) {

    }

    }

    gfree(encoding);

    gfree(encoding);

  }

  }

  }

  }

}

}

}

}

  return encoding;

  return encoding;

}

}

  return map;

  return map;

}

}

				FoFiOutputFunc outputFunc,

				FoFiOutputFunc outputFunc,

				void *outputStream) {

				void *outputStream) {

  int psNameLen;

  int psNameLen;

  Type1CIndexVal val;

  Type1CIndexVal val;

  GString *buf;

  GString *buf;

  char buf2[256];

  char buf2[256];

  GBool ok;

  GBool ok;

  int i;

  int i;

  (*outputFunc)(outputStream, "cleartomark\n", 12);

  (*outputFunc)(outputStream, "cleartomark\n", 12);

}

}

				   FoFiOutputFunc outputFunc,

				   FoFiOutputFunc outputFunc,

				   void *outputStream) {

				   void *outputStream) {

  int *cidMap;

  int *cidMap;

  gfree(cidMap);

  gfree(cidMap);

}

}

				FoFiOutputFunc outputFunc,

				FoFiOutputFunc outputFunc,

				void *outputStream) {

				void *outputStream) {

  int *cidMap;

  int *cidMap;

  gfree(cidMap);

  gfree(cidMap);

}

}

			       int offset, int nBytes,

			       int offset, int nBytes,

			       Type1CIndex *subrIdx,

			       Type1CIndex *subrIdx,

			       Type1CPrivateDict *pDict) {

			       Type1CPrivateDict *pDict) {

      n = 5;

      n = 5;

    }

    }

  }

  }

}

}

  Guchar *p;

  Guchar *p;

  Guchar x;

  Guchar x;

	eb->line = 0;

	eb->line = 0;

      }

      }

    } else {

    } else {

    }

    }

  }

  }

}

}

	eb->line = 0;

	eb->line = 0;

      }

      }

    } else {

    } else {

    }

    }

  }

  }

}

}

  if (!parsedOk) {

  if (!parsedOk) {

    return gFalse;

    return gFalse;

  }

  }

  // read the top dict for the first font

  // read the top dict for the first font

  readTopDict();

  readTopDict();

    encoding = fofiType1ExpertEncoding;

    encoding = fofiType1ExpertEncoding;

  } else {

  } else {

    for (i = 0; i < 256; ++i) {

    for (i = 0; i < 256; ++i) {

      encoding[i] = NULL;

      encoding[i] = NULL;

    }

    }

	  return;

	  return;

	}

	}

	if (encoding[c]) {

	if (encoding[c]) {

	}

	}

	encoding[c] = copyString(getString(charset[i], buf, &parsedOk));

	encoding[c] = copyString(getString(charset[i], buf, &parsedOk));

      }

      }

	for (j = 0; j <= nLeft && nCodes < nGlyphs; ++j) {

	for (j = 0; j <= nLeft && nCodes < nGlyphs; ++j) {

	  if (c < 256) {

	  if (c < 256) {

	    if (encoding[c]) {

	    if (encoding[c]) {

	    }

	    }

	    encoding[c] = copyString(getString(charset[nCodes], buf,

	    encoding[c] = copyString(getString(charset[nCodes], buf,

					       &parsedOk));

					       &parsedOk));

	  return;

	  return;

	}

	}

	if (encoding[c]) {

	if (encoding[c]) {

	}

	}

	encoding[c] = copyString(getString(sid, buf, &parsedOk));

	encoding[c] = copyString(getString(sid, buf, &parsedOk));

      }

      }

      if ((n = val.len) > 255) {

      if ((n = val.len) > 255) {

	n = 255;

	n = 255;

      }

      }

      buf[n] = '\0';

      buf[n] = '\0';

    } else {

    } else {

      buf[0] = '\0';

      buf[0] = '\0';

public:

public:

  // Create a FoFiType1C object from a memory buffer.

  // Create a FoFiType1C object from a memory buffer.

  // Create a FoFiType1C object from a file on disk.

  // Create a FoFiType1C object from a file on disk.

  virtual ~FoFiType1C();

  virtual ~FoFiType1C();

  // Return the font name.

  // Return the font name.

  // Return the encoding, as an array of 256 names (any of which may

  // Return the encoding, as an array of 256 names (any of which may

  // be NULL).  This is only useful with 8-bit fonts.

  // be NULL).  This is only useful with 8-bit fonts.

  // Return the mapping from CIDs to GIDs, and return the number of

  // Return the mapping from CIDs to GIDs, and return the number of

  // CIDs in *<nCIDs>.  This is only useful for CID fonts.

  // CIDs in *<nCIDs>.  This is only useful for CID fonts.

  // font.  If <ascii> is true the eexec section will be hex-encoded,

  // font.  If <ascii> is true the eexec section will be hex-encoded,

  // otherwise it will be left as binary data.  If <psName> is non-NULL,

  // otherwise it will be left as binary data.  If <psName> is non-NULL,

  // it will be used as the PostScript font name.

  // it will be used as the PostScript font name.

		      FoFiOutputFunc outputFunc, void *outputStream);

		      FoFiOutputFunc outputFunc, void *outputStream);

  // Convert to a Type 0 CIDFont, suitable for embedding in a

  // Convert to a Type 0 CIDFont, suitable for embedding in a

  // PostScript file.  <psName> will be used as the PostScript font

  // PostScript file.  <psName> will be used as the PostScript font

  // name.

  // name.

			 FoFiOutputFunc outputFunc, void *outputStream);

			 FoFiOutputFunc outputFunc, void *outputStream);

  // Convert to a Type 0 (but non-CID) composite font, suitable for

  // Convert to a Type 0 (but non-CID) composite font, suitable for

  // embedding in a PostScript file.  <psName> will be used as the

  // embedding in a PostScript file.  <psName> will be used as the

  // PostScript font name.

  // PostScript font name.

		      FoFiOutputFunc outputFunc, void *outputStream);

		      FoFiOutputFunc outputFunc, void *outputStream);

private:

private:

		     int offset, int nBytes,

		     int offset, int nBytes,

		     Type1CIndex *subrIdx,

		     Type1CIndex *subrIdx,

		     Type1CPrivateDict *pDict);

		     Type1CPrivateDict *pDict);

  void cvtGlyphWidth(GBool useOp, GString *charBuf,

  void cvtGlyphWidth(GBool useOp, GString *charBuf,

		     Type1CPrivateDict *pDict);

		     Type1CPrivateDict *pDict);

  void cvtNum(double x, GBool isFP, GString *charBuf);

  void cvtNum(double x, GBool isFP, GString *charBuf);

  void eexecWriteCharstring(Type1CEexecBuf *eb, Guchar *s, int n);

  void eexecWriteCharstring(Type1CEexecBuf *eb, Guchar *s, int n);

  GBool parse();

  GBool parse();

  void readTopDict();

  void readTopDict();

  char *getString(int sid, char *buf, GBool *ok);

  char *getString(int sid, char *buf, GBool *ok);

  GString *name;

  GString *name;

  Type1CIndex nameIdx;

  Type1CIndex nameIdx;

  Type1CIndex topDictIdx;

  Type1CIndex topDictIdx;

public:

public:

  // Create a FoFiType1 object from a memory buffer.

  // Create a FoFiType1 object from a memory buffer.

  // Create a FoFiType1 object from a file on disk.

  // Create a FoFiType1 object from a file on disk.

  virtual ~FoFiType1();

  virtual ~FoFiType1();

  // Return the font name.

  // Return the font name.

  // Return the encoding, as an array of 256 names (any of which may

  // Return the encoding, as an array of 256 names (any of which may

  // be NULL).

  // be NULL).

  // Write a version of the Type 1 font file with a new encoding.

  // Write a version of the Type 1 font file with a new encoding.

		    FoFiOutputFunc outputFunc, void *outputStream);

		    FoFiOutputFunc outputFunc, void *outputStream);

private:

private:

  void parse();

  void parse();

  GBool parsed;

  GBool parsed;

};

};

#elif defined(__EMX__) || defined(WIN32)

#elif defined(__EMX__) || defined(WIN32)

  //---------- OS/2+EMX and Win32 ----------

  //---------- OS/2+EMX and Win32 ----------

  GString *ret;

  GString *ret;

  if ((s = getenv("HOME")))

  if ((s = getenv("HOME")))

#else

#else

  //---------- Unix ----------

  //---------- Unix ----------

  struct passwd *pw;

  struct passwd *pw;

  GString *ret;

  GString *ret;

  return new GString();

  return new GString();

}

}

#if defined(VMS)

#if defined(VMS)

  //---------- VMS ----------

  //---------- VMS ----------

  //~ this should handle everything necessary for file

  //~ this should handle everything necessary for file

#endif

#endif

}

}

#ifdef VMS

#ifdef VMS

  //---------- VMS ----------

  //---------- VMS ----------

  char *p;

  char *p;

#endif

#endif

}

}

#ifdef VMS

#ifdef VMS

  //---------- VMS ----------

  //---------- VMS ----------

  return strchr(path, ':') ||

  return strchr(path, ':') ||

#endif

#endif

}

}

#ifdef WIN32

#ifdef WIN32

  //~ should implement this, but it's (currently) only used in xpdf

  //~ should implement this, but it's (currently) only used in xpdf

  return 0;

  return 0;

}

}

#ifndef PDF_PARSER_ONLY

#ifndef PDF_PARSER_ONLY

#if defined(WIN32)

#if defined(WIN32)

  //---------- Win32 ----------

  //---------- Win32 ----------

  GString *s, *s2;

  GString *s, *s2;

  char buf[32];

  char buf[32];

  FILE *f2;

  FILE *f2;

}

}

#endif

#endif

#ifdef VMS

#ifdef VMS

  return system(cmd) ? gTrue : gFalse;

  return system(cmd) ? gTrue : gFalse;

#else

#else

// GDir and GDirEntry

// GDir and GDirEntry

//------------------------------------------------------------------------

//------------------------------------------------------------------------

#ifdef VMS

#ifdef VMS

  char *p;

  char *p;

#elif defined(WIN32)

#elif defined(WIN32)

  delete name;

  delete name;

}

}

  path = new GString(name);

  path = new GString(name);

  doStat = doStatA;

  doStat = doStatA;

#if defined(WIN32)

#if defined(WIN32)

// Append a file name to a path string.  <path> may be an empty

// Append a file name to a path string.  <path> may be an empty

// string, denoting the current directory).  Returns <path>.

// string, denoting the current directory).  Returns <path>.

// Grab the path from the front of the file name.  If there is no

// Grab the path from the front of the file name.  If there is no

// directory component in <fileName>, returns an empty string.

// directory component in <fileName>, returns an empty string.

// Is this an absolute path or file name?

// Is this an absolute path or file name?

// Make this path absolute by prepending current directory (if path is

// Make this path absolute by prepending current directory (if path is

// relative) or prepending user's directory (if path starts with '~').

// relative) or prepending user's directory (if path starts with '~').

// Get the modification time for <fileName>.  Returns 0 if there is an

// Get the modification time for <fileName>.  Returns 0 if there is an

// error.

// error.

// Create a temporary file and open it for writing.  If <ext> is not

// Create a temporary file and open it for writing.  If <ext> is not

// NULL, it will be used as the file name extension.  Returns both the

// NULL, it will be used as the file name extension.  Returns both the

// should be done to the returned file pointer; the file may be

// should be done to the returned file pointer; the file may be

// reopened later for reading, but not for writing.  The <mode> string

// reopened later for reading, but not for writing.  The <mode> string

// should be "w" or "wb".  Returns true on success.

// should be "w" or "wb".  Returns true on success.

// Execute <command>.  Returns true on success.

// Execute <command>.  Returns true on success.

// Just like fgets, but handles Unix, Mac, and/or DOS end-of-line

// Just like fgets, but handles Unix, Mac, and/or DOS end-of-line

// conventions.

// conventions.

class GDirEntry {

class GDirEntry {

public:

public:

  ~GDirEntry();

  ~GDirEntry();

  GString *getName() { return name; }

  GString *getName() { return name; }

  GBool isDir() { return dir; }

  GBool isDir() { return dir; }

class GDir {

class GDir {

public:

public:

  ~GDir();

  ~GDir();

  GDirEntry *getNextEntry();

  GDirEntry *getNextEntry();

  void rewind();

  void rewind();

  return p->val.i;

  return p->val.i;

}

}

  GHashBucket *p;

  GHashBucket *p;

  int h;

  int h;

  return p->val.p;

  return p->val.p;

}

}

  GHashBucket *p;

  GHashBucket *p;

  int h;

  int h;

  return val;

  return val;

}

}

  GHashBucket *p;

  GHashBucket *p;

  GHashBucket **q;

  GHashBucket **q;

  void *val;

  void *val;

  return val;

  return val;

}

}

  GHashBucket *p;

  GHashBucket *p;

  GHashBucket **q;

  GHashBucket **q;

  int val;

  int val;

  return NULL;

  return NULL;

}

}

  GHashBucket *p;

  GHashBucket *p;

  *h = hash(key);

  *h = hash(key);

  return (int)(h % size);

  return (int)(h % size);

}

}

  unsigned int h;

  unsigned int h;

  h = 0;

  h = 0;

  void replace(GString *key, int val);

  void replace(GString *key, int val);

  void *lookup(GString *key);

  void *lookup(GString *key);

  int lookupInt(GString *key);

  int lookupInt(GString *key);

  void *remove(GString *key);

  void *remove(GString *key);

  int removeInt(GString *key);

  int removeInt(GString *key);

  int getLength() { return len; }

  int getLength() { return len; }

  void startIter(GHashIter **iter);

  void startIter(GHashIter **iter);

  GBool getNext(GHashIter **iter, GString **key, void **val);

  GBool getNext(GHashIter **iter, GString **key, void **val);

  void expand();

  void expand();

  GHashBucket *find(GString *key, int *h);

  GHashBucket *find(GString *key, int *h);

  int hash(GString *key);

  int hash(GString *key);

  GBool deleteKeys;		// set if key strings should be deleted

  GBool deleteKeys;		// set if key strings should be deleted

  int size;			// number of buckets

  int size;			// number of buckets

}

}

#endif

#endif

  char *s1;

  char *s1;

  s1 = (char *)gmalloc(strlen(s) + 1);

  s1 = (char *)gmalloc(strlen(s) + 1);

/*

/*

 * Allocate memory and copy a string into it.

 * Allocate memory and copy a string into it.

 */

 */

#ifdef __cplusplus

#ifdef __cplusplus

}

}

  fmtSpace

  fmtSpace

};

};

  "d", "x", "o", "b", "ud", "ux", "uo", "ub",

  "d", "x", "o", "b", "ud", "ux", "uo", "ub",

  "ld", "lx", "lo", "lb", "uld", "ulx", "ulo", "ulb",

  "ld", "lx", "lo", "lb", "uld", "ulx", "ulo", "ulb",

  "f", "g",

  "f", "g",

  return new GString(p, len);

  return new GString(p, len);

}

}

  va_list argList;

  va_list argList;

  GString *s;

  GString *s;

  return s;

  return s;

}

}

  GString *s;

  GString *s;

  s = new GString();

  s = new GString();

  return this;

  return this;

}

}

  va_list argList;

  va_list argList;

  va_start(argList, fmt);

  va_start(argList, fmt);

  return this;

  return this;

}

}

  GStringFormatArg *args;

  GStringFormatArg *args;

  int argsLen, argsSize;

  int argsLen, argsSize;

  GStringFormatArg arg;

  GStringFormatArg arg;

  GStringFormatType ft;

  GStringFormatType ft;

  char buf[65];

  char buf[65];

  int len, i;

  int len, i;

  argsLen = 0;

  argsLen = 0;

  argsSize = 8;

  argsSize = 8;

  //     t -- GString *

  //     t -- GString *

  //     w -- blank space; arg determines width

  //     w -- blank space; arg determines width

  // To get literal curly braces, use {{ or }}.

  // To get literal curly braces, use {{ or }}.

  // Destructor.

  // Destructor.

  ~GString();

  ~GString();

  GString *append(const char *str, int lengthA);

  GString *append(const char *str, int lengthA);

  // Append a formatted string.

  // Append a formatted string.

  // Insert a character or string.

  // Insert a character or string.

  GString *insert(int i, char c);

  GString *insert(int i, char c);

  gfree(tab);

  gfree(tab);

}

}

  int h;

  int h;

  BuiltinFontWidth *p;

  BuiltinFontWidth *p;

  return gFalse;

  return gFalse;

}

}

  unsigned int h;

  unsigned int h;

  h = 0;

  h = 0;

//------------------------------------------------------------------------

//------------------------------------------------------------------------

struct BuiltinFont {

struct BuiltinFont {

  short ascent;

  short ascent;

  short descent;

  short descent;

  short bbox[4];

  short bbox[4];

//------------------------------------------------------------------------

//------------------------------------------------------------------------

struct BuiltinFontWidth {

struct BuiltinFontWidth {

  Gushort width;

  Gushort width;

  BuiltinFontWidth *next;

  BuiltinFontWidth *next;

};

};

  BuiltinFontWidths(BuiltinFontWidth *widths, int sizeA);

  BuiltinFontWidths(BuiltinFontWidth *widths, int sizeA);

  ~BuiltinFontWidths();

  ~BuiltinFontWidths();

private:

private:

  BuiltinFontWidth **tab;

  BuiltinFontWidth **tab;

  int size;

  int size;

CharCodeToUnicode *CharCodeToUnicode::parseCMap(GString *buf, int nBits) {

CharCodeToUnicode *CharCodeToUnicode::parseCMap(GString *buf, int nBits) {

  CharCodeToUnicode *ctu;

  CharCodeToUnicode *ctu;

  ctu = new CharCodeToUnicode(NULL);

  ctu = new CharCodeToUnicode(NULL);

  p = buf->getCString();

  p = buf->getCString();

}

}

void CharCodeToUnicode::mergeCMap(GString *buf, int nBits) {

void CharCodeToUnicode::mergeCMap(GString *buf, int nBits) {

  p = buf->getCString();

  p = buf->getCString();

  parseCMap1(&getCharFromString, &p, nBits);

  parseCMap1(&getCharFromString, &p, nBits);

#endif

#endif

}

}

  GString *useNameStr;

  GString *useNameStr;

  CMap *subCMap;

  CMap *subCMap;

  return !collection->cmp(collectionA) && !cMapName->cmp(cMapNameA);

  return !collection->cmp(collectionA) && !cMapName->cmp(cMapNameA);

}

}

  CMapVectorEntry *vec;

  CMapVectorEntry *vec;

  int n, i;

  int n, i;

  // Return the CID corresponding to the character code starting at

  // Return the CID corresponding to the character code starting at

  // <s>, which contains <len> bytes.  Sets *<nUsed> to the number of

  // <s>, which contains <len> bytes.  Sets *<nUsed> to the number of

  // bytes used by the char code.

  // bytes used by the char code.

  // Return the writing mode (0=horizontal, 1=vertical).

  // Return the writing mode (0=horizontal, 1=vertical).

  int getWMode() { return wMode; }

  int getWMode() { return wMode; }

  CMap(GString *collectionA, GString *cMapNameA);

  CMap(GString *collectionA, GString *cMapNameA);

  CMap(GString *collectionA, GString *cMapNameA, int wModeA);

  CMap(GString *collectionA, GString *cMapNameA, int wModeA);

  void copyVector(CMapVectorEntry *dest, CMapVectorEntry *src);

  void copyVector(CMapVectorEntry *dest, CMapVectorEntry *src);

  void addCodeSpace(CMapVectorEntry *vec, Guint start, Guint end,

  void addCodeSpace(CMapVectorEntry *vec, Guint start, Guint end,

		    Guint nBytes);

		    Guint nBytes);

  int i;

  int i;

  for (i = 0; i < length; ++i) {

  for (i = 0; i < length; ++i) {

    entries[i].val.free();

    entries[i].val.free();

  }

  }

  gfree(entries);

  gfree(entries);

}

}

  if (length == size) {

  if (length == size) {

    if (length == 0) {

    if (length == 0) {

      size = 8;

      size = 8;

  ++length;

  ++length;

}

}

  int i;

  int i;

  for (i = 0; i < length; ++i) {

  for (i = 0; i < length; ++i) {

  return NULL;

  return NULL;

}

}

  DictEntry *e;

  DictEntry *e;

  return (e = find("Type")) && e->val.isName(type);

  return (e = find("Type")) && e->val.isName(type);

}

}

  DictEntry *e;

  DictEntry *e;

  return (e = find(key)) ? e->val.fetch(xref, obj) : obj->initNull();

  return (e = find(key)) ? e->val.fetch(xref, obj) : obj->initNull();

}

}

  DictEntry *e;

  DictEntry *e;

  return (e = find(key)) ? e->val.copy(obj) : obj->initNull();

  return (e = find(key)) ? e->val.copy(obj) : obj->initNull();

}

}

  return entries[i].key;

  return entries[i].key;

}

}

//------------------------------------------------------------------------

//------------------------------------------------------------------------

struct DictEntry {

struct DictEntry {

  Object val;

  Object val;

};

};

  int getLength() { return length; }

  int getLength() { return length; }

  // Add an entry.  NB: does not copy key.

  // Add an entry.  NB: does not copy key.

  // Check if dictionary is of specified type.

  // Check if dictionary is of specified type.

  // Look up an entry and return the value.  Returns a null object

  // Look up an entry and return the value.  Returns a null object

  // if <key> is not in the dictionary.

  // if <key> is not in the dictionary.

  // Iterative accessors.

  // Iterative accessors.

  Object *getVal(int i, Object *obj);

  Object *getVal(int i, Object *obj);

  Object *getValNF(int i, Object *obj);

  Object *getValNF(int i, Object *obj);

  int length;			// number of entries in dictionary

  int length;			// number of entries in dictionary

  int ref;			// reference count

  int ref;			// reference count

};

};

#endif

#endif

#include "GlobalParams.h"

#include "GlobalParams.h"

#include "Error.h"

#include "Error.h"

  va_list args;

  va_list args;

  // NB: this can be called before the globalParams object is created

  // NB: this can be called before the globalParams object is created

#include <stdio.h>

#include <stdio.h>

#include "config.h"

#include "config.h"

#endif

#endif

#include <stdlib.h>

#include <stdlib.h>

#include "FontEncodingTables.h"

#include "FontEncodingTables.h"

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

  "caron"

  "caron"

};

};

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

  NULL

  NULL

};

};

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

  "ydieresis"

  "ydieresis"

};

};

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

  NULL

  NULL

};

};

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

  "Ydieresissmall"

  "Ydieresissmall"

};

};

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

  NULL

  NULL

};

};

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

  NULL,

#ifndef FONTENCODINGTABLES_H

#ifndef FONTENCODINGTABLES_H

#define FONTENCODINGTABLES_H

#define FONTENCODINGTABLES_H

#endif

#endif

// Note: 'if' and 'ifelse' are parsed separately.

// Note: 'if' and 'ifelse' are parsed separately.

// The rest are listed here in alphabetical order.

// The rest are listed here in alphabetical order.

// The index in this table is equivalent to the entry in PSOp.

// The index in this table is equivalent to the entry in PSOp.

  "abs",

  "abs",

  "add",

  "add",

  "and",

  "and",

GBool PostScriptFunction::parseCode(Stream *str, int *codePtr) {

GBool PostScriptFunction::parseCode(Stream *str, int *codePtr) {

  GString *tok;

  GString *tok;

  GBool isReal;

  GBool isReal;

  int opPtr, elsePtr;

  int opPtr, elsePtr;

  int a, b, mid, cmp;

  int a, b, mid, cmp;

//------------------------------------------------------------------------

//------------------------------------------------------------------------

struct StdFontMapEntry {

struct StdFontMapEntry {

};

};

// Acrobat 4.0 and earlier substituted Base14-compatible fonts without

// Acrobat 4.0 and earlier substituted Base14-compatible fonts without

// GfxFont

// GfxFont

//------------------------------------------------------------------------

//------------------------------------------------------------------------

  GString *nameA;

  GString *nameA;

  GfxFont *font;

  GfxFont *font;

  Object obj1;

  Object obj1;

  return font;

  return font;

}

}

  ok = gFalse;

  ok = gFalse;

  tag = new GString(tagA);

  tag = new GString(tagA);

  id = idA;

  id = idA;

}

}

void GfxFont::findExtFontFile() {

void GfxFont::findExtFontFile() {

  if (name) {

  if (name) {

    if (type == fontType1) {

    if (type == fontType1) {

  }

  }

}

}

  FILE *f;

  FILE *f;

  char *buf;

  char *buf;

  return buf;

  return buf;

}

}

  char *buf;

  char *buf;

  Object obj1, obj2;

  Object obj1, obj2;

  Stream *str;

  Stream *str;

// Gfx8BitFont

// Gfx8BitFont

//------------------------------------------------------------------------

//------------------------------------------------------------------------

			 GfxFontType typeA, Dict *fontDict):

			 GfxFontType typeA, Dict *fontDict):

  GfxFont(tagA, idA, nameA)

  GfxFont(tagA, idA, nameA)

{

{

  GString *name2;

  GString *name2;

  BuiltinFont *builtinFont;

  BuiltinFont *builtinFont;

  GBool baseEncFromFontFile;

  GBool baseEncFromFontFile;

  int len;

  int len;

  FoFiType1 *ffT1;

  FoFiType1 *ffT1;

  FoFiType1C *ffT1C;

  FoFiType1C *ffT1C;

  int code, code2;

  int code, code2;

  GBool missing, hex;

  GBool missing, hex;

  Unicode toUnicode[256];

  Unicode toUnicode[256];

  CharCodeToUnicode *utu, *ctu2;

  CharCodeToUnicode *utu, *ctu2;

    }

    }

  }

  }

  if (buf) {

  if (buf) {

  }

  }

  // get default base encoding

  // get default base encoding

	} else if (obj3.isName()) {

	} else if (obj3.isName()) {

	  if (code >= 0 && code < 256) {

	  if (code >= 0 && code < 256) {

	    if (encFree[code]) {

	    if (encFree[code]) {

	    }

	    }

	    enc[code] = copyString(obj3.getName());

	    enc[code] = copyString(obj3.getName());

	    encFree[code] = gTrue;

	    encFree[code] = gTrue;

  for (i = 0; i < 256; ++i) {

  for (i = 0; i < 256; ++i) {

    if (encFree[i] && enc[i]) {

    if (encFree[i] && enc[i]) {

    }

    }

  }

  }

  ctu->decRefCnt();

  ctu->decRefCnt();

  }

  }

}

}

			     Unicode *u, int uSize, int *uLen,

			     Unicode *u, int uSize, int *uLen,

			     double *dx, double *dy, double *ox, double *oy) {

			     double *dx, double *dy, double *ox, double *oy) {

  CharCode c;

  CharCode c;

  int cmapPlatform, cmapEncoding;

  int cmapPlatform, cmapEncoding;

  int unicodeCmap, macRomanCmap, msSymbolCmap, cmap;

  int unicodeCmap, macRomanCmap, msSymbolCmap, cmap;

  GBool useMacRoman, useUnicode;

  GBool useMacRoman, useUnicode;

  Unicode u;

  Unicode u;

  int code, i, n;

  int code, i, n;

         ((GfxFontCIDWidthExcepV *)w2)->first;

         ((GfxFontCIDWidthExcepV *)w2)->first;

}

}

		       Dict *fontDict):

		       Dict *fontDict):

  GfxFont(tagA, idA, nameA)

  GfxFont(tagA, idA, nameA)

{

{

  }

  }

}

}

			    Unicode *u, int uSize, int *uLen,

			    Unicode *u, int uSize, int *uLen,

			    double *dx, double *dy, double *ox, double *oy) {

			    double *dx, double *dy, double *ox, double *oy) {

  CID cid;

  CID cid;

  gfree(fonts);

  gfree(fonts);

}

}

  int i;

  int i;

  for (i = 0; i < numFonts; ++i) {

  for (i = 0; i < numFonts; ++i) {

public:

public:

  // Build a GfxFont object.

  // Build a GfxFont object.

  virtual ~GfxFont();

  virtual ~GfxFont();

  Ref *getID() { return &id; }

  Ref *getID() { return &id; }

  // Does this font match the tag?

  // Does this font match the tag?

  // Get base font name.

  // Get base font name.

  GString *getName() { return name; }

  GString *getName() { return name; }

  virtual int getWMode() { return 0; }

  virtual int getWMode() { return 0; }

  // Read an external or embedded font file into a buffer.

  // Read an external or embedded font file into a buffer.

  // Get the next char from a string <s> of <len> bytes, returning the

  // Get the next char from a string <s> of <len> bytes, returning the