Keysym: Add apallingly bad API documentation for keysym <-> string

Signed-off-by: Daniel Stone <daniel@fooishbar.org>

Make keysym <-> string conversion public API

Signed-off-by: Daniel Stone <daniel@fooishbar.org>

XKB: Text: Use keysym <-> string conversion from keysym.c

Signed-off-by: Daniel Stone <daniel@fooishbar.org>

Test: Keysym: Add tests for new keysym <-> string conversions

Signed-off-by: Daniel Stone <daniel@fooishbar.org>

Keysym: Fix conversion for Unicode and bare numbers

Ensure that Unicode string representations are accepted and turned into
numbers, as well as hexadecimal numbers in 0xabcd1234 form; unknown
keysyms are output as 0xabcd1234 in string form.

This also ensures that strings are never returned malloc()ed.

Signed-off-by: Daniel Stone <daniel@fooishbar.org>

KeySym: Actually handle NoSymbol

Add NoSymbol into the keysym table, so keysym <-> string conversion works for
that, too; also eliminate special-casing of VoidSymbol.

This will require special-casing in libX11 to preserve its API.

Signed-off-by: Daniel Stone <daniel@fooishbar.org>

test: Fix srcdir != objdir build and test failures

filecomp would fail because it couldn't find the input files, after
compilation failed due to missing includes.

Signed-off-by: Daniel Stone <daniel@fooishbar.org>

listing: Drop unused deviceSpec argument

The server might care about this, but ListComponents is just reading xkb
files.

xkbcomp: Another fairly major rewrite of the listing mode

The listing code in xkbcomp had been setup to allocate a set of buffers
with file paths and then later parse through them to find which maps were
needed.

All the allocation (with the additional allocation for the components
list) was making it really slow, so this patch makes everything simpler
by just generating the components list as we walk the directory tree.

Rewrite listing code to generate XkbComponentListPtr

In xkbcomp, the listing code printed out the xkb files to stdout and the
caller would parse the output. Here, we can just generate a
XkbComponentListPtr and pass it back.

This should be a series of smaller commits, but there was no clean way to
do it since it's basically a complete rewrite except for the core map
matching logic.

A lot of code used for special printing modes in xkbcomp has been
shedded. Callers can massage the output as they please.

xkbcomp: Kill unused listing code and make functions static

Much of this was only called from xkbcomp and not used to generate
listings for the server.

Scale back global variables

Some of the global variables were either not used anymore or only used
in the listing code.

Add XkbNameMatchesPattern implementation from xkbfile

The xkbcomp listing code matches a glob type pattern against installed
xkb files. This adds a Xkbc implementation of the pattern matching code.

xkbcomp: Fix use of removed macros

Revert "xkbcomp: Remove listing sources"

This reverts commit c4c9e36fbf4019d802323d9053f54cbfa6d3d5e5. It turns
out that the listing code is used to support the X_kbListComponents
request (via XkbListComponents).

This will have to be refactored into some reasonable interface instead
of the current usage where the server reads xkbcomp stdout. Gross.

misc: Coding-style cleanup

Use xkbpath API for locating rules

Instead of hardcoding the XKB base directory when searching for rules in
the xkbcomp code, we can extend the xkbpath API to cover rules and reuse
it. That will make it more convenient if it's ever exposed so people can
set their XKB search paths in a reasonable way.

Program and files for testing CompileKeymapFromFile

A few simple test cases for verifying the operation of parsing a keymap
file and compiling a keyboard description from it.

Add interface to compile keyboard description from keymap files

We need to support generating a keyboard description from a keymap file
because there are just some cases where RMLVO or ktcsg is not enough.

The map choosing logic has been refactored into its own function and now
supports choosing a named or default keymap.

test: Remove extraneous includes

These programs don't actually use the internal API.

Make XkbcInitAtoms externally accessible

Applications (like the server) need to initialize the atoms system
before using the rest of the library. Maybe it should just init itself
implicitly.

Constify public API

There's no reason the arguments can't be const.

Change CompileKeymapFromRules to take XkbRMLVOSet

Let's use a nice interface now that it's available from XKBrulescommon.h.

Remove all non-public API from XKBcommon.h header

The noble intention was to expose all the new API and new generic types
in the split out kbproto headers through XKBcommon.h. It turns out that
would be a massive amount of work in the server. Someday, but first just
wedging in XkbCompileKeymap* would be good.

Most of the API is in new internal xkb*.h headers. In order to allow the
XKBcommon.h header to be used from the server, we can't pull in other
headers from kbproto since the server has its own copies. However, types
that are different (XkbDescRec, XkbAction) still have Xkbc equivalents
here, and I think they should be used in the server.

Remove KS macros available in XKBfilecommon.h now

A couple of the XkbcKS* macros become redundant with XKBfilecommon.h
split out in kbproto.

Require strdup and remove utils wrapper

This kills a couple warnings from using the uStringDup wrapper. If you
don't have strdup on your platform, you have bigger issues.

Add action datatypes as defined in the server

Some of the XkbAction types are defined differently in the server, so we
add those to XKBcommon.h and use them here like XkbcDescPtr. We'll have
to deal with the impedance mismatch on the client side later.

Coding style cleanup on key allocation functions

test: Exercise compiling from components

This could probably use a lot more real world test cases, but it does
the job for now.

xkbcomp: Don't say we're exiting when we're not

xkbcomp: Give keymap file empty name if none supplied

Ensure that the keymap file topName is not NULL since it gets blindly
dereferenced later.

xkbcomp: Ensure at least keycodes supplied in components

It seems that at least a non-empty keycodes component is required to
compile a XkbcDescPtr.

xkbcomp: Don't dereference NULL VarDefsPtr

xkbcomp: Refactor keymap file generator

test: Minor refactor to allow $EXEEXT in program names

test: Add logging and some intentionally failing cases

We want to log the output of the tests rather than letting them go to
stderr. This allows tests we expect to fail to be run.

xkbcomp: Generating components requires rules _and_ layout

This came from trial and error, but it seems that you can generate a
valid keymap with only rules and layout.

xkbcomp: Fail when converting rules to components returns an error

XkbcRF_GetComponents was returning an error but leaving the generated
components alone. This ensures that the broken XkbComponentNamesPtr is
freed and the error is passed up to the caller.

xkbcomp: Cleanup error messages

xkbcomp: Ensure user has supplied a rules name

rulescomp: Remove unneeded API

Refactor xkbpath so that it implicitly initializes

Instead of requiring the user to call XkbInitIncludePath() and
XkbAddDefaultDirectoriesToPath(), all the path entry points now implicitly
initialize the path. When initializing, the default directories are added
so it's useful.

This provides normal operation without exposing the xkbpath API. That
might happen later to allow apps to edit the XKB search path.

Remove trailing spaces in source files

Test compiler to simulate xkbcomp usage

Added a test program, rulescomp, which takes a RMLVO set and generates a
XkbcDescPtr. This is essentially what the xserver will do, except that we
still need to access some xkbcomp internal API to make it work.

Fix cleanup error in names allocation

A conditional got reversed during the coding style cleanup.

xkbcomp: Ignore generated parser

xkbcomp: Don't segfault if the debug files aren't set

Another interface that needs to be cleaned up.

xkbcomp: Declare global debugging vars

These will need to be sanitized at some point, but for now let's just get
the code running.

xkbcomp: Back out strdup warning cleanup

There are some spots in the code that use strdup without checking the
argument, so we need this to not segfault. Cleanup later...

Fix install path for XKBcommon.h

Drop keysym.h pollution from XKBcommon.h

There's really no need to pull this into a public header.

Add xkbcommon pkg-config file

xkbcomp: Clean up utils prototypes

Includes using a macro for the gcc format attributes instead of repeated
ifdef's.

xkbcomp: Remove duplicated macros

xkbcomp: Kill warnings about address always evaluating as true

Merge commit 'tilt/master'

Compile keyboard description from XKB rules, too

XkbcCompileKeymapFromRules can be used to generate a XkbDescPtr from XKB
rules instead of using components. The previous XkbcCompileKeymap has
been renamed to XkbcCompileKeymapFromComponents.

Add rules file parsing from xkbfile

Copy over the Xkb_RF* rules parsing functions from xkbfile's maprules.c.
Eventually, this will be tied into xkbcomp's path searching utilities so
you don't need to supply a full path to the rules file. Also, it this
should eventually incorporate the server's RMLVOSet.

Add rules rules file parsing from xkbfile

Copy over the Xkb_RF* rules parsing functions from xkbfile's maprules.c.
Eventually, this will be tied into xkbcomp's path searching utilities so
you don't need to supply a full path to the rules file. Also, it this
should eventually incorporate the server's RMLVOSet.

Generate keyboard description from components

Finally, we can generate a XkbcDescPtr from a XkbComponentNamesPtr. This
involves turning the components into a parsed XKB file and then passing
it into the compiler. This first conversion needs more error handling.

xkbcomp: Include Xdefs.h for Atom in tokens.h

xkbcomp: Add missing includes for Bool in xkbpath

Add XKBlib resizing functions

These were originally in XKBMalloc.c.

Copy xkbfile IsUpper/IsLower macros

xkbcomp was using Xlib's XConvertCase to check upper/lowercase. That's a
lot of code, so hopefully the xkbfile macros using _XkbKSCheckCase are
good enough. This also required that <X11/keysym.h> is included to get
all the XK_* definitions.

Copy XkbEnsureSafeMapName from xkbfile

xkbcomp: Remove listing sources

The xkbcomp listing APIs were only needed for the "xkblist" mode, which
won't be supported here.

malloc/misc/xkb: Coding style cleanup

Add XKBlib API to support keytypes

Added common variants of XkbComputeEffectiveMap, XkbInitCanonicalKeyTypes
and all their needed functions. A couple functions that were in alloc.c
moved to malloc.c to mirror the libX11 sources better.

Original code in

libX11/src/xkb/XKBMalloc.c
libX11/src/xkb/XKBMisc.c
libX11/src/xkb/XKB.c

geom: Coding-style cleanup

Add geometry Compute API from XKBlib

A small needed subset from libX11/src/xkb/XKBGeom.c.

Add xkbcommon macro for XkbKSIsKeypad and XkbKSIsDeadKey(k)

IsKeypad is used in symbols, but we'll just grab them both. It might be
better to split parts of XKBfile.h out eventually.

Add XkbModIndexText replacement

Now, I think we should have all the *Text functions we need.

Drop another unneeded format argument

Almost cleared of XkbMessage...

Add VMod Text functions from xkbfile

Copy XkbAddGeom* functions from XKBlib

These are needed by the geometry compiler in xkbcomp.

xkbcomp: s/XStringToKeysym/XkbcStringToKeysym/

Expose all the geometry allocation subroutines

We need a couple in xkbcomp, but they might also be needed externally,
too.

xkbcomp: Use xkbcommon allocation functions

s/XkbAlloc/XkbcAlloc/ so we don't know XKBlib.

Kill off usage of Display

The use of Display in xkbcomp always boiled down to passing it to
XkbInternAtom and XkbAtomGetString. This shouldn't be a problem here.

Add more *Text functions from xkbfile

This should cover all the usage in xkbcomp. The format arguments were
dropped except for the special case of XkbModMaskText, which needs to
write in XkbCFile format in HandleVModDef. This was just changed to a
Bool to avoid the need for the macros in XKBfile.h.

The function prefixes have been renamed to be unique from xkbfile.

xkbcomp: Drop unused Display argument in Atom functions

The xkbcommon Atom implementation doesn't take Display into account.

Move *Text APIs into libxkbcommon

These seem like they might be generally useful, and more will be needed
from xkbfile.

libxkbcomp: Use the internal Atom implementation

s/XkbInternAtom/XkbcInternAtom/ and s/XkbAtomGetString/XkbcAtomGetString/

libxkbcomp: s/Status/int/ since we don't have Xlib.h

libxkbcomp: Drop unused format field for *Text functions

libxkbcomp: Add non-xkbfile XkbActionTypeText

libxkbcomp: s/XPointer/char */

Replace XPointer with its definition since we don't have the privilege
of using Xlib.h. Why this is char * and not void *, I'll never know.

libxkbcomp: s/XkbDescPtr/XkbcDescPtr/

We need to use the keyboard description structure from XKBcommon.h since
it doesn't have the Display field.

libxkbcomp: Eradicate XkbFileInfo usage

The only real usage was in the frontend to generate a .xkm file. The
rest of the code just operated on the attached XkbDescPtr. Note that
here we've replaced the usage of the defined field in CompileKeymap with
the equivalent field in a XkbcDescPtr.

libxkbcomp: Include X.h and Xdefs.h for Atom and Bool

libxkbcomp: Remove usage of client-side headers

This will surely break things. Let's see just what we need to replace.

xkbcomp: Add non-xkbfile XkbConfigText

Ignore files for xkbcomp

Ignore ks_tables.h in makekeys directory now

Import xkbcomp sources for CompileKeymap

A copy of the xkbcomp sources (except the frontend) have been copied in
to provide a means to compile a XkbDescPtr. This definitely doesn't
build or do the right thing yet.

Move ks_tables.h build into makekeys subdirectory

This avoids the BUILT_SOURCES weirdness and forcing the build into the
makekeys subdirectory. Added a new make variable KS_HEADERS that lists
all the keysym headers we're going to parse.

Use X extern "C" guards around function declarations for public header

atom: Coding-style cleanup and refactor

Some coding style nits were cleaned up. Additionally, most of the
functions have been collapsed from the libxkbfile version where there's
distinction with the Xlib atom functions when Display was set. Finally,
the InitAtoms function tests whether the table has already been created
by testing the pointer rather than using a static int.

Borrow atom implementation from libxkbfile

We need an atom implementation not relying on XInternAtom and friends.
The original code is in

libxkbfile/src/xkbatom.c

alloc/galloc: Coding style cleanup

Mostly tab-to-space conversion plus a few style nits. Dropped the
register keywords as I'm pretty sure modern compilers can be trusted to
do the right thing.