Remove .sfd from .htaccess file

We don't serve and SFD files any more.

Add a paragraphs about the other semi-graphics Bedstead can do

They could probably do with examples as well.

Large type M and W vertex components

Remaining large type stem parts

The ones that aren't separately encoded provided a clear indication of
how the numbered stem parts are meant to relate to the named ones, so
there weren't actually many decisions to make.

Lots of diagonal bits of large type pieces

This is essentially all of them apart from the W and M pieces.  There
turn out to be obvious places to have the diagonals cross character-cell
boundaries such that they should all join up.  Whether this gives and
aesthetically tolerable outcome, I'm not so sure.

The W and M pieces are a bit confusing, because they're meant to span
two character cells vertically, but the obvious design doesn't.

Three more HP large type components

These are based on the existing arcs in obvious ways.

Initial HP large type pieces (U+1CE1A onwards)

This batch are the ones that can be implemented using the ordinary
box-drawing characters (and probably should have been unified with
them by Unicode).

Convert some 8-cell mosaic glyphs into aliases to 6-cell

Because in Bedstead the cell boundaries of 8-cell mosaic glyphs are a
superset of those for 6-cell mosaic glyphs, each of the existing
6-cell glyphs has an identical 8-cell glyph whose middle two rows of
cells are identical.  Thus, these 8-cell glyphs can be aliases for the
corresponding 6-cell glyph.  I've implemented this as a macro called
A() that can be mixed in with the existing O() macros in the section
of the glyphs table that generates U+1CD00..U+1CDE5, aliasing them to
characters in U+1FB00..U+1FB3B.  That makes the table even more
confusing, but at least it's compact.

Add remaining 8-cell mosaic characters

These are the ones scattered across Unicode and not in the main
U+1CD00..U+1CDE5 block that weren't already present.  They're aliased to
the corresponding 6-cell characters.

Notes on what the missing 8-cell mosaics are unified with

Main block of 8-cell mosaics in Symbols for Legacy Computing Supplement

These were mostly generated from UnicodeData.txt with a dodgy Perl
one-liner and an Emacs keyboard macro.  The dodgy one-liner was (wrapped
onto more lines):

grep "BLOCK OCTANT" ~/Downloads/UnicodeData.txt |
perl -pe '/OCTANT-(\d+)/; $i=""; map{vec($i,$_-1,1)=1}split(//,$1);
          $_=sprintf("%02X",ord($i))." $_";'

Now I need to find the characters elsewhere in Unicode that correspond
with the gaps in the table.

Add support for generating 8-cell mosaic graphics

This follows the pattern of the 6-cell and 4-cell versions, but without
separated mode because Unicode doesn't have that.  This required making
the bitmap data into an unsigned char array to allow for using all eight
bits.

The cell boundaries are chosen so that they line up with existing 6-cell
and 4-cell boundaries.  So we have row heights of [3,2,2,3], which is
maybe less pretty than [3,2,3,2], but is more in keeping with the
existing mosaics.  Indeed, it means that the existing 4-cell and 6-cell
contiguous characters could be expressed in 8-cell terms if I wanted to.

Enlarge radius of box drawings arcs

Before, the diagonal parts were the same as in the capital O.  But that
was already a bit square, and the shapes one would draw with the box
drawing characters will generally be bigger.  So now I've cut a bit more
off the corners.  This means that arcs that join to the right need the
recent change to add JOIN_R in order to join up properly.

With this change, if you try to draw a circle with them, you get an
octagon with side lengths 2, 2.8, 6 instead of 4, 1.4, 8, which I think
is an improvement.

Add JOIN_R and JOIN_D flags, and extend effects of JOIN_*

The new flags mark glyphs that join to the right and downwards.  The
effect of these, and a new effect of JOIN_U and JOIN_L, is to arrange
that getpix() treats pixels beyond the edge of the character cell as
repeating the last row of real pixels.

In practice, this means that a diagonal stroke touching the right or
bottom edge of the cell will now be drawn as though it turns into an
orthogonal stroke across the edge rather than as though it stops.  This
doesn't affect the outline of any existing glyph.

There is a more subtle consequence, which is that joining glyphs no
longer get edge hints on their joining edges.  I think that's an
improvement: such hints might move those edges so that they don't touch
the adjacent character, which would be rather unhelpful.

Move various small caps to dedicated Unicode code points

Specifically, this adds:

U+1D0C LATIN LETTER SMALL CAPITAL L WITH STROKE
U+1D23 LATIN LETTER SMALL CAPITAL EZH
U+1D7B LATIN SMALL CAPITAL LETTER I WITH STROKE
U+1DF04 LATIN LETTER SMALL CAPITAL L WITH BELT
U+1DF10 LATIN LETTER SMALL CAPITAL TURNED K

Three of this had private-use encodings that appeared in earlier
Bedstead releases.  These encodings have been preserved for backward
compatibility.

Add old-style numerals

I've designed new versions of 0, 1, and 2 that fit within the
x-height.  6 and 8 don't change at all (and are unmapped).  The other
digits are all moved down by two pixels so their top edges are at the
x-height and their bottom edges at the descender height.

This is very simple (and much simpler than my previous attempts), but
seems to be satisfactory.

U+01B7 LATIN CAPITAL LETTER EZH

It's just the lower-case moved up the baseline, but the small-cap is
new.

U+2C6D LATIN CAPITAL LETTER ALPHA

Used by at least one African language that we otherwise support, and
trivially derived from the lower-case.

Better UALIAS() macro

Now you _can_ pass an instance of U() as the first two arguments.

More modifier letters of quotation marks

They're aliases of the normal versions.  I think Hawaiian probably
wants one.  Also converted modifier primes into aliases.

Make all the capital Dcroat and African D into aliases of Eth

This saves a few bytes and avoids some repetition.

Add a macro, UALIAS(), for aliases with Unicode mappings

ALIAS() is now implemented in terms of UALIAS().

U+0194 LATIN CAPITAL LETTER GAMMA

Hyperglot says that completes several more African languages including
Dinka.

U+019D LATIN CAPITAL LETTER N WITH LEFT HOOK

Hyperglot says this is all we're missing from Bambara, which has 4
million speakers.

Finally solve the S-hachek problem

I had been trying to find an upper-case that was visibly distinct from
the existing lower-case, but I realised that I could do the same as we
do with accented 'o' and instead make a new lower-case version and
declare the existing glyph to be upper-case.  This seems to work
tolerably and removes the most embarrassing gaps in Bedstead's
repertoire.

U+0197 LATIN CAPITAL LETTER I WITH STROKE

With a small-cap glyph and appropriate mappings.  Hyperglot says that
adds nine more languages.

U+01B1 LATIN CAPITAL LETTER UPSILON

It's just an upside-down Omega.  Hyperglot says that gains us support
for five more languages.  The small-cap is just the already-existing
lower-case.

Added some useful African capitals

Not cities, but capital versions of some letters we already had in
lower-case for IPA.  Specifically:

U+0186 LATIN CAPITAL LETTER OPEN O
U+0189 LATIN CAPITAL LETTER AFRICAN D
U+0190 LATIN CAPITAL LETTER OPEN E
U+0196 LATIN CAPITAL LETTER IOTA
U+01B2 LATIN CAPITAL LETTER V WITH HOOK

Between them, Hyperglot thinks this gains us useful coverage of
languages with a few tens of millions of speakers, which seems like good
value to me.

The all also have small caps, and in the case of the African D all the
capital-D variants.

Proper names for Wgrave, wgrave, Wacute, wacute, Ygrave, and ygrave

Turns out that these are in AGLFN.  No compatibility aliases because
they never appeared in a release with the wrong names.

Redesign U+028B LATIN SMALL LETTER V WITH HOOK

The International Phonetic Association's preferred sans-serif font
doesn't give this character a serif at the top left, so Bedstead
shouldn't either.  Also the bottom-left corner of the letter is subtly
curved, so I've rounded off that corner a bit as well.  The result is
more like the IPA's ideal and also easier to design a capital version
of.

More-consistent 'W' glyphs

Now all of the caps and small caps have a central peak four pixels
above the baseline, and all of the lower-case have a central peak
three pixels above the baseline.  The outer arms vary as necessary to
accommodate accents and for small caps.

Add W/w with grave and acute

Hyperglot says these are needed for Welsh, and they're trivial to
draw.

There seems to be some confusion around the proper shape for small-cap
W in Bedstead; I should investigate this in more detail.

Add Y/y with grave

They're trivial and Hyperglot says they're necessary for writing Welsh.

Add icircumflex.sc as an alias of Icircumflex

Spotted by Shaperglot.  I disagree with a lot of its complaints, but
in this it was entirely correct.

Try to generate more-symmetric stem hints

When generating hints for a symmetric glyph like 'v', it's helpful if
the hits are symmetric because that means that the hinted bitmap is
also likely to be symmetric.  This is particularly visible on
Microsoft Windows where the version of 'v' before this patch ended up
horribly distorted when rendered at 20 ppem in Bedstead Condensed.  To
try to avoid such horrors, we now select hints starting at the outside
edges of the character and working inwards, instead of going from left
to right or top to bottom.  This means that where hints conflict,
we'll tend to choose the ones towards the outside edge of the
character, rather than towards the top or left.

This changes the hinting for 50 glyphs, but all in ways that look
superficially reasonable.

For more complicated characters we probably still want to think about
hint substitution, but that still scares me.

Update version to 3.252

Quick note on automated tools in CONTRIBUTING

It's apparent that the idea that you should disclose the use of such
tools is not as widespread as I'd thought, so I should make it
explicit.

Switch from asctime() to strftime()

C23 marks asctime() as deprecated and it seems polite to keep up with
that.  Using strftime() isn't noticeably more complicated: the "%c"
specifier does what we want and we don't get a spurious newline that
we have to remove again.

Replace the one use of sprintf() with snprintf()

It only acts on constant strings, so it can't actually overflow, but
this way I can assert() that it really doesn't.

Don't emit counter hints for horizontal stems

Microsoft Windows 11 pays some attention to counter hints, and the
results are disastrous.  Specifically, at awkward ppem, characters
with counter hints end up one pixel smaller that characters without
them.  That makes the counters the same size, and puts every
horizontal stem squarely on a pixel, but means that cap height is all
wobbly, which looks horrible.  Additionally, some characters ('2' and
'3', at least) end up grossly distorted, with the top of the character
either stretched way above the character cell or squashed down to the
centre line.

Turning off the counter hints solves these problems.  Windows does
then draw the 'B' with its centre-line below the centre rather than
above it, but that's not a regression from 002.009.  As far as I can
tell, FreeType 2.12.1 ignores counter hints entirely.  At least, the
output of ftlint at 11 ppem is the same before and after this change.

Vertical counter hints survive.  They're also ignored by FreeType
2.12.1 (as are all vertical stem hints), but they seem to have a
broadly positive effect in Windows.

Further SOURCE_DATE_EPOCH simplification

Rather than mucking about with errno, we can just take advantage of the
fact that on overflow, strtoull() is specified to return ULLONG_MAX,
which is guaranteed to be (much) bigger than the maximum
SOURCE_DATE_EPOCH that we can cope with.  So our usual range check can
cope with overflow as well.

Handle SOURCE_DATE_EPOCH in unsigned long long, not unitmax_t

unsigned long long is guaranteed to be big enough.  No need to go
bigger.

Slightly simplify SOURCE_DATE_EPOCH handling

Subtracting 30 years' worth of seconds from the date and then adding
2000 years is unnecessary when we can just add 1970 years instead.

Add a "Unique font identifier" string (name ID 3)

This seems to be necessary for the font viewer in MS Windows 11 to
consider the font to be valid.  The semantics of this field are not
documented in the OpenType spec, but the Apple TrueType spec does at
least give an example.  I've roughly followed Apple's example, putting
together the full name, version number, and build date that we already
have to hand and include in the font.  Between them those should
uniquely identify reasonable builds of Bedstead fonts without adding
extra complexity or non-reproducibility.

Policy on Git commit messages in CONTRIBUTING

I've never been comfortable with constructing or editing commit
messages that will appear under someone else's name, but on the other
hand I don't want to be forced either to use someone else's message
untouched or to remove their name from the "Author" field.  Allowing
myself to make clearly-marked edits seems to be a good compromise, and
square brackets are a common way of marking edits and editorial
comments.

More portable handling of SOURCE_DATE_EPOCH

Now we don't make any assumption about being on a POSIX system, and
instead have our own implementation of gmtime().  This turns out to be
shorter than the comment explaining why the previous code was more or
less valid.

While I'm in the area, also fail if the year is after 9999, since
asctime() causes undefined behaviour in those cases.

Update rom.ps for renaming of ccedilla.angular to ccedilla.square

Update date at the head of bedstead.c

Clarify 3.251 release notes

Better late than never.

Update version to 3.251

Rename "angular" cedilla as "square"

They both have angles, after all.  Also "square" sorts more
conveniently in the 'aalt' lookup.

Rough sketch of 3.251 release notes

Add private-use code points for new unmapped glyphs

Also turn seriffed Dcroats into aliases for the corresponding Eths to
slightly reduce the number of nominally distinct glyphs.

Add E with cedilla

That's a real cedilla, and hence gets the SAA5054 angular form.  It's
also the last Latin letter with a cedilla that isn't blocked by
something else.  At least, until Unicode adds a new one.

Glyphs for G, K, L, N, and R with comma below

These are the remaining characters that Unicode calls "WITH CEDILLA" but
that the standard (and code charts) say should actually have a comma
below by default.

Redesign Hcedilla and hcedilla

The Unicode code charts and all the fonts I have conveniently to hand
are agreed that the cedilla should be attached to the letter, usually
to the left leg.  So now it is in Bedstead as well.  This also allows
the body of the letter to return to its normal shape.

Add S with comma below

As with T, this is distinct from the cedilla version, but it's
visually identical in Bedstead except when you turn on 'cv96'.

Add T with comma below

If I'm going to insist that U+0162 and U+0163 really have cedillas, I
should have their unambiguously comma-below versions, U+021A and
U+021B, as well.

Convert cedillas under D to commas

According to Unicode 16.0.0 (chapter 7), U+0327 COMBINING CEDILLA is
ambiguous.  It can mean an actual cedilla, but it can also mean a
comma below.  This also applies to precomposed characters containing
it.  Unicode recommends default forms for various letters and in
particular says that for D and T (upper- and lower-case) the comma
form should be the default.

However, Unicode now has a separate U+021A LATIN CAPITAL LETTER T WITH
COMMA BELOW and recommends its use for Romanian.  So I think the
recommendation to render U+0162 LATIN CAPITAL LETTER T WITH CEDILLA with
a comma below is no longer applicable.

I have now updated Bedstead so that U+1E10 LATIN CAPITAL LETTER D WITH
CEDILLA is treated as having a comma below instead.  In practice, this
just means that it's unaffected by 'cv96'

All references to capital letters above apply equally to the
corresponding small letters.

Sort elements of the FeatureIndices array by feature tag

The OpenType spec (version 1.9.1) says, "The FeatureRecord array
should be sorted alphabetically by feature tag."  Bedstead was instead
emitting them in the order in which they appeared in the gsub_features
array, which was determined by the order the lookups need to occur in.
In particular, the 'cvXX' lookups need to occur after the 'ssXX'
lookups so as to override them properly.

Fixing this required some care to keep all the indices straight, but I
think I've managed it.

Add comments with feature tags for FeatureIndices

Use a conventional lenof() macro for lengths of static arrays

It's slightly unconventional in that it casts the result to int, which
is fine for all our arrays and avoids warnings when we use it.

Add parameter labels for 'cvXX' features

This means that now each possible variant of a character covered by a
'cvXX' feature has a human-readable name.  I don't know of anything
that uses these, so they're somewhat untested.

Small-cap and narrow forms of U+A780 (turned L)

Add white (outline) versions of card suits

The club and spade are one pixel taller than the black (filled) ones
because I couldn't come up with a convicing club in the smaller size.

Redesign glottal-stop characters

Bedstead's various glottal-stop characters were originally based on
its question mark, because that character looks a bit like a question
mark without a dot.  However, while adding a Character Variant feature
for question marks I noticed that the glottal stop and question mark
in the Unicode code charts didn't match, which was why I left the
glottal stop out of that feature.

I've now also looked at the official IPA charts from the International
Phonetic Association, and it's clear that the glottal stop does not in
general match the question mark.  In particular, the join between the
rounded section and the stem is often smooth in a question mark but is
always a right angle in the glottal stop.  I've thus re-designed
Bedstead's glyphs to follow this pattern.  I've also shortened the
crossbar on the glottal stop derivatives that have them, since that
seems to better match DejaVu Sans, which is the sans-serif font
preferred by the IPA.

Add U+23E8 DECIMAL EXPONENT SYMBOL

That seemed to be the only character needed by ALGOL 60 that I was
lacking.

Add 'ss05' which maps all of U+0020..U+007E to SAA5055 glyphs

This seems appropriate for something that wants to treat these as ASCII
glyphs with their ambiguous semantics.

This uses the existing apostrophe.curly, and also adds grave.curly (an
alias for quotereversed) and bar.broken (an alias for brokenbar).  Of
course there are also 'cvXX' features to enable each one individually as
well.

Switch to a variadic macro for generating alternate substitutions

Add character variant for curly apostrophe (SAA5051/2)

Unicode takes the position that U+0027 APOSTROPHE is always a straight
apostrophe and is you want a curly one you should use U+2019 RIGHT
SINGLE QUOTATION MARK (or U+02BC MODIFIER LETTER APOSTROPHE but let's
not get into that here).  Bedstead generally follows that, putting the
SAA5050 straight apostrophe at U+0027 and the SAA5055 curly one at
U+2019.

Older character standards, though, conflated those two and treated the
difference between them as one of font design.  In particular, ETS 300
706: May 1997, "Enhanced Teletext specification" treats position 2/7 as
being the same character in all national sub-sets of the Latin G0
primary set.  When coverting Teletext data to Unicode, ZVBI maps 2/7 to
U+0027 whichever national sub-set is in use.

This means that to faithfully display Teletext data in the way that an
SAA5051/2 would, Bedstead needs to interpret U+0027 as a curly
apostrophe.  I have accomplished this by adding a new "apostrophe.curly"
alias and including that in the 'ss01' and 'ss02' Stylistic Sets.  It
also, of course, gains a new Character Variant feature, 'cv07', so that
you can turn the curly apostrophe on and off independently.

This does cause me to wonder whether there should be a stylistic set to
map U+0020..U+007E onto the SAA5055 glyphs.

Rename parameters for CVXX macros to "V"

That makes things a little less verbose (for now).

Fill in 'cv38' with far too many kinds of capital 'D'

Add narrow small-cap J to 'cv42'

All the other J-based characters are either narrow already or
unsuitable for narrowing.

Fill out 'cv44' with narrow capital Ls

Fill out 'cv96' with all the angular cedillas

This collides with the small lower-case 't' of 'cv84' at U+0163 LATIN
SMALL LETTER T WITH CEDILLA, but I think all the combinations work.  I
do currently have both "uni0163.small.angular" and
"uni0163.angular.small" to ensure that you can apply each stylistic
set with the opposing character variant.  Maybe with more careful
interleaving I could get away with only one of those.

Stop trying to indent XML output

The indentation wasn't always correct, and made the C code ugly.  I've
now found "xmllint --format", which does a better job, so I think it's
quite reasonable to stop trying to do it myself.

Expand some comments

Now that we use strings for bitmaps, the comments can be a little less
abbreviated.

More large, accented lower-case 'o's for 'cv79'

I thought about just re-using the ".sc" glyph names, but that seemed
wrong.

Extend 'cv74' to other characters based on lower-case 'j'

I didn't do U+0254 LATIN SMALL LETTER DOTLESS J WITH STROKE because the
Unicode standard says it's based on a turned 'f', not 'j'.

Extend 'cv84' to most characters based on lower-case 't'

That's 12 additional glyphs, and I thought 't' would be one of the
simpler ones.  Still, it automatically works with 'ss01' and 'ss02' as
well.

Merge SUFFIXSUB and SUFFIXSUB1 macros

Use X-macro trick for emitting lookups for variant capital D

This will mean that adding extra characters to 'cv38' will
automatically add them to 'ss01' and 'ss02' as well.

Remove the global "variable" (macro) from 'cvXX'/'ssXX' generation

I realised that VAR2 can be a parameter to the various CVXX macros
instead.  This makes the existing code a little more complicated, but
will make the code for the three-way choice of capital D less
confusing.

The macro names are getting worse, and will definitely need to be
rationalised at some point, bit the structure is getting better.

Use a macro to emit <SingleSubst> elements

Don't emit multiple subtables for 'cv31'

I was accidentally emitting a separate <AlternateSubst> element for
each base character, which worked but was unnecessary.  A single
<AlternateSubst> for the whole lookup will make for a smaller font
file and probably faster lookups as well.

Add some extra variant question-mark glyphs

The inverted and reversed question-mark characters should obviously
change shape along with the normal one, so now they do.  This
conveniently tests the 'cvXX'/'ssXX' interaction without getting
tangled up with small caps as well.

Based on the different shapes of the glyphs in the Unicode code charts,
I've decided that glottal stops should not change their shapes along
with question marks, and should perhaps be different shapes entirely.

Construct 'ssXX' and 'cvXX' lookups using X macros

In general, we want each Stylistic Set to be constructed out of a
collection of Character Variants.  At the moment, this is fairly
simple, but if I start putting variants of more characters into these
features (for example, adding questiondown.open to go with
question.open), it will get awkward keeping them in sync.  But the two
kinds of lookup want different XML, so they can't just be copied
as-is.

One approach would be to have a C data structure that gets used to
generate both sets of lookups, but an alternative is to extend the
existing pre-processor magic to use X macros to construct the two
lookups.  This is what I've done.

At the moment, this is just using the existing macros that generate
XML, but driving them from another set of macros, one for each
Character Variant feature.  The Stylistic Sets then invoke all the
macros for the Character Variants they include.

There are a couple of open problems.  One is the (single, so far) case
where there are two variants of a character, namely 'D'.  This should
be dealt with by paramaterising the variant macro, but I've not got
around to that yet.  The other is that the macro names are largely
horrible.

Rename two 'cvXX' features based on SAA5054 shapes

The features that generate the variant ocircumflex and ccedilla glyphs
are now treated a being variants of lower-case 'o' and cedilla
respectively.  Unlike the SAA5051/2 variants, we don't yet have
variants of their base glyphs.  Indeed, for the lower-case 'o' we
probably never will, because the variant is "larger accented versions"
so the unaccented version wouldn't change.

I haven't done anything about the weird SAA5054 ugrave because I'm not
sure there's any real design principle behind it.

I've also added a comment explaining the numbering of 'cvXX' features.

Add SPDX-License-Identifier to CSS files

Add @character-variant rules to bedstead-faces.css

Add names for 'cvXX' features

Add cvXX (character variant) lookups

The idea of these is that each one allows for choosing between different
variants of a single character (or set of closely-related characters).
This allows for deciding that you want (for instance) the angular
SAA5054 "ccedilla", but not its weird conjoined "ugrave".

This seems like a good way to handle chips like the SN74S262 where some
samples seem to vary in a single character from others, as well as more
generally for making the variant glyphs easily accessible for purposes
other than precise emulation.

At the moment, each feature only provides alternatives for a single
character, but now that we have a mechanism for it, that might change.

Don't emit <LookupType> elements

TTX is quite capable of inferring the lookup type from the type of the
main child element of <Lookup>.  This should allow for specifying
different kinds of lookup using literal XML.

Generate ss0X substitutions less cleverly

These substitutions are not generated from the glyphs table, but are
specified statically.  Rather than taking a table and transforming it
into XML with C, we could just put the static XML in a string, which
is much simpler.  To avoid excessive simplicity, the string is
generated by a pile of preprocessor macros.

This causes no change to the output OTFs.

Note source of ugrave.roundjoined in a comment

Don't emit AlternateSets that will be overridden

Just in case TTX changes its behaviour in this area in the future.

Add a comment explaining the purpose of aalt_overrides

Signal names for SN74S262 pins, from RML 380Z service manual

Extend compatcheck 'GSUB' checks to handle renamed glyphs

We do this by pulling out the CFF charstring for old and new glyph
names from the new font and seeing if they're the same.

Emit AlternateSets for 'aalt' overrides

These are just emitted after the standard AlternateSets, and because
of how TTX works, they end up overriding the standard ones.  This
seems a bit dodgy to me, so I might try to do better later.