🚀 go-pugleaf

Thank you for your help. Much of my PostScript code handles that which
I call a compound string, this being any of:
-- A string;
-- The name of a glyph;
-- Any array of compound objects;
-- Code that does any of:
-- -- Leave on the stack ≥0 compound objects;
-- -- Move the currentpoint by a distance proportional to
CurrentFontSize (e.g., for kerning or superscripting);
-- -- Change the typeface (probably with selectfont), the size of the
new typeface being proportional to CurrentFontSize;
-- -- Change the current colour (usually with setgray or setrgbcolor);
-- -- Generate the path of a shape (without calling newpath or making
any changes to the clipping path), the shape's position being
determined by the currentpoint, and its size being proportional to
CurrentFontSize;
-- -- Optionally paint said shape with an unbinded call to any of
fill, eofill, stroke, ufill, ueofill, shfill.

Next define a KernTriples array to be an array, of length an integer
multiple of 3, resembling
[
/A /C -55
/A /Cacute -55
...
]
and set AdobeFontMetrics-TimesBold to the kerning data  above for
Times-Bold.

Then, with the definitions below and  and the kerning list in posts
above,
  [(Ch) /acircumflex (teau L) /eacute (oville-Barton)]
  dup == AdobeFontMetrics-TimesBold exch InsertKernCode ==
outputs
  [(Ch) /acircumflex (teau L) /eacute (oville-Barton)]
  [(Ch) /acircumflex (teau L) /eacute (o) {-10 CurrentFontSize mul
1000 div 0 rmoveto} (ville-Barton)]





% [KernTriples] CompoundString  InsertKernCode  NewCompoundString
/InsertKernCode
{
	1 dict begin
	/MostRecentGlyph /Null def
	1 InsertKernCodeRec
	end
} bind def  % InsertKernCode

% [KernTriples] CompoundString NoExecDepth  InsertKernCodeRec
NewCompoundString
/InsertKernCodeRec
{
	4 dict begin
	/NoExecDepth exch def
	/param exch def
	/KernTriples exch def

	% Glyph|Int Glyph|Int  KernAmount  Number
	/KernAmount
	{
		3 dict begin
		/Glyph1 exch def
		/Glyph0 exch def
		Glyph1 type /integertype eq {/Glyph1 ThisEncoding Glyph1 get def} if
		Glyph0 type /integertype eq {/Glyph0 ThisEncoding Glyph0 get def} if
		0
		0  3  KernTriples length 1 sub
		{
			/kt exch def
			Glyph0 KernTriples kt get eq
			{
				Glyph1 KernTriples kt 1 add get eq
				{
					pop
					KernTriples kt 2 add get
					exit
				} if  % Glyph1 KernTriples kt 1 add get eq
			} if  % Glyph0 KernTriples kt get eq
		} for  % KernTriples
		end
	} def  % KernAmount

	[ /param load  NoExecDepth  InsertKernCodeRecRec ]
	dup length 1 eq {0 get} if
	end
} def  % InsertKernCodeRec

/InsertKernCodeRecRec
{
	3 dict begin
	/NoExecDepth exch def
	/param exch def
	/ThisEncoding currentfont /Encoding get def  % redone here in case
code changes currentfont
	/param load xcheck
	{
		NoExecDepth 0 gt
		{
			{  1 dict begin /MostRecentGlyph /MostRecentGlyph def KernTriples  /
param  /NoExecDepth  InsertKernCodeRec end }
			%  0   1    2          3                4          5
6          7          8                9         10
			dup length array copy cvx
			dup  4  MostRecentGlyph  put
			dup  6  KernTriples  put
			dup  7  /param load  put  % replace /param with its current value,
a not-quite // operation
			dup  8  NoExecDepth 1 sub  put
		}
		{
			[ /param load execU ]  0  InsertKernCodeRecRec
		} ifelse  % NoExecDepth 0 gt
	}
	{
	param type /stringtype eq
	{
		MostRecentGlyph /Null ne
		{
			MostRecentGlyph  param 0 get  KernAmount
			dup 0 eq {pop}
			{
				{/KernAmount CurrentFontSize mul 1000 div 0 rmoveto}
				dup length array copy cvx
				dup  0  4 -1 roll  put
			} ifelse  % ... KernAmount ... 0 eq
		} if  % MostRecentGlyph /Null ne
		/ThisPieceStart 0 def
		0  1  param length 2 sub
		{
			/i exch def
			param i get  param i 1 add get  KernAmount
			dup 0 eq {pop}
			{
				{/KernAmount CurrentFontSize mul 1000 div 0 rmoveto}
				dup length array copy cvx
				dup  0  4 -1 roll  put
				param  ThisPieceStart  i ThisPieceStart sub 1 add  getinterval
exch
				/ThisPieceStart i 1 add def
			} ifelse  % ... KernAmount ... 0 eq
		} for
		param  ThisPieceStart  param length ThisPieceStart sub  getinterval
		/MostRecentGlyph ThisEncoding param dup length 1 sub get get store
	}
	{
	param type /nametype eq
	{
		MostRecentGlyph  param  KernAmount
		dup 0 eq {pop}
		{
			{/KernAmount CurrentFontSize mul 1000 div 0 rmoveto}
			dup length array copy cvx
			dup  0  4 -1 roll  put
		} ifelse  % ... KernAmount ... 0 eq
		/MostRecentGlyph param store
		param
	}
	{
	param type /arraytype eq
	{
		param {NoExecDepth  InsertKernCodeRecRec} forall
	}
	{
		(Error: InsertKernCodeRec parameter neither executable nor string
nor name nor array, being) OutputToLog
		/param load OutputToLog
	} ifelse  % /arraytype
	} ifelse  % /nametype
	} ifelse  % /stringtype
	} ifelse  % xcheck
	end
} bind def  % InsertKernCodeRecRec