ttn-do

audio-cd-control 1.1

 Usage: audio-cd-control [COMMAND]

 If COMMAND is omitted, it defaults to ‘q’.
 The recognized commands are:

  ‘q’ (query) displays track count and times for the CD.
  ‘p’ (pause) pauses a currently playing CD.
  ‘r’ (resume) resumes a currently paused CD.
  ‘s’ (stop) stops the CD player.
  ‘m’ (monitor) shows current track and time, every second.
  ‘e’ (eject) ejects the CD from the player.
  N (a number 1, 2, ...) starts playing track N.

— Procedure: act command

Do command, a symbol (q, p, r, s, m) or integer.

as-xhtml 1.0

 Usage: as-xhtml [options] INFILE

 Expand and evaluate INFILE.  Write resulting XHTML to stdout.
 Options:

  -I, --include DIR      -- add DIR to end of search path
                            (can be specified multiply)
  -o, --output FILE      -- write output to FILE
  -p, --pretty-print     -- pretty-print expansion to stderr

 The search path for ‘(#:include "FILENAME")’ directives
 is initialized to the directory of INFILE.

bit-field-diagram 2.1

 Usage: bit-field-diagram [--file FILE | BITSPEC]

 Display a bit field diagram representing BITSPEC.  Option `--file'
 means read the bitspec from FILE.  A BITSPEC is a Scheme list of
 the form:

   (CONFIGURATION* [FIELD-SPEC...])

 CONFIGURATION is an optionally-omitted list with car #:config
 followed by CONFIG-SPEC forms, described below.  FIELD-SPEC is a
 list (NAME WIDTH [BITS]), where NAME is a symbol or string, WIDTH
 an integer, and BITS an optional string to populate the diagram.
 Each character in BITS is displayed (left to right) in its
 corresponding field position.

 For example:
 $ ttn-do bit-field-diagram "((hello 5) (there 10))"
  hello     there
 +---------+-------------------+
 | | | | | | | | | | | | | | | |
 +---------+-------------------+

 Specifying CONFIG-SPEC forms, each a keyword/value pair, changes
 the appearance of the output.  Currently supported:

   #:columns-per-bit       2       this includes a bar "|"
   #:suppress-sep-bars     #f      omit internal "|"
   #:field-name-justify    #:left  can also be #:right
   #:field-name-placement  #:over  can also be #:internal or #:under
   #:height                1       lines for the body of the field
   #:group                 #f      number of bits in a group, or #f
   #:merge-group-borders?  #f      merge internal borders

 When #:merge-group-borders? is set, #:field-name-placement must be
 #:internal, otherwise an error is signalled.  A #:field-name-placement
 of #:internal automatically sets #:suppress-sep-bars.  You must set
 #:suppress-sep-bars when specifying field BITS.  When #:group is
 specified, an error is signalled if the fields do not align to it.

 Here is a more complicated example.  This form is placed in a file:

   ((#:config (#:columns-per-bit . 3)
              (#:field-name-justify . #:right)
              (#:field-name-placement . #:internal)
              (#:height . 3)
              (#:group . 16)
              (#:merge-group-borders? . #t))
    (hello 6)
    (there 10)
    (how 2)
    (are 3)
    (you 8)
    (doing 3)
    ("well i hope?" 11))

 The result is:

   +-----------------+-----------------------------+
   |            hello|                        there|
   |                 |                             |
   |                 |                             |
   +-----+--------+--+--------------------+--------+
   |  how|     are|                    you|   doing|
   |     |        |                       |        |
   |     |        |                       |        |
   +-----+--------+-----------------+-----+--------+
   |                    well i hope?|
   |                                |
   |                                |
   +--------------------------------+


 TODO: Support #:group-justify, #:border-style, #:bit-numbering,
               #:endian, per-group #:prefix and #:suffix, etc. etc.

— Procedure: bit-field-diagram out port/spec

Format a bit-field diagram to out, normally a port. As a special case, if out is #f, construct and return a new string. port/spec is either a port where a specification can be read, or a specification (structured expression) itself.

browse-grumi 1.2

 Usage: browse-grumi [-nw]

 Kick off "ttn-do grumi" on localhost:8001, and start w3m on it.
 After w3m exits, kill the grumi and clean up.  If DISPLAY is set,
 do everything in a new rxvt session.  Otherwise, or if given
 optional arg "-nw", use the current session.

 Normally, the grumi's pidfile is written in browse-grumi.d/
 (under cwd).  Env var TMPDIR, if set, overrides cwd.

bump-version 2.0

 Usage: bump-version [--more MORE] [EXPLICIT | --auto]

 normal operation
 ----------------
 In configure.ac (or configure.in), set second ‘AC_INIT’ arg to
 VERSION, computed as EXPLICIT if specified, otherwise the value
 "1+ the current one" (increment the last numerical component)
 if given option ‘--auto’ (short form: ‘-a’).

 Next, use "git config" ‘user.name’ and ‘user.email’ values and
 the first byte of .last-release to update top-level ChangeLog
 w/ the (properly-formatted) entry:

  YYYY-MM-DD  USER-NAME  <USER-EMAIL>
  Release: VERSION (tag TAG)
  * configure.ac (AC_INIT): Bump version to "VERSION" for release.

 If TAG is identical to VERSION (no "v" prefix), omit " (tag TAG)".
 Next, do "git commit -a" w/ the commit message comprising the
 (properly-formatted) last two lines of the above ChangeLog entry.
 NB: This may pull in other changes.

 If other changes are to be documented, MORE names a file whose
 contents are appended (properly-formatted) to the ChangeLog and
 commit message entries.  Short form for ‘--more’ is ‘-m’.

 Files named "ChangeLog" in subdirectories are similarly modified,
 except that the "* configure.ac" and subsequent lines are omitted,
 and only if the latest entry is NOT a "Release:" entry.

 Lastly, do "git tag TAG" w/ annotation "YYYY-MM-DD HH:MM:SS"
 followed by the second and subsequent lines of .last-release;
 and update the first line of .last-release to be TAG.


 operation when using git-version-gen
 ------------------------------------
 If configure.ac (or .in) uses git-version-gen (from gnulib),
 the operation is like the normal operation, described above,
 except that configure.ac (or .in) is not modified, and the
 (change-)log entries subsequently do not include that notice.

burn-iso 1.5

 Usage: burn-iso [options] ISO

 Options:
  -d, --device DEVICE    -- use DEVICE (default: "/dev/hdc")
  -s, --speed N          -- quickness multiplier

 DEVICE is a device filename (default: "/dev/hdc").
 Look at "wodim --devices" output if unsure.
 SPEED is a number 4 and up (48 seems to work ok).
 Omitting SPEED normally means "as fast as possible".

 This program uses wodim(1) to do the actual work.

check-topodefs 1.1

 Usage: check-topodefs [options] FILE...

 Scan each FILE for definitions and check that "usages" of those
 definitions (i.e., simple references to the name of the definition)
 do not occur in forms prior the definition.  When this is not the
 case, display to stderr:

 FILENAME:LINE:: (USAGE-TOP-LEVEL) LATER

 where USAGE-TOP-LEVEL is the name of the form (if deducible) where
 the definition of LATER is used, and FILENAME:LINE is its location.
 Options are:

   -I, --ignore NAME  -- In addition to ‘define-module’ and
                         ‘use-modules’, ignore NAME, as well.

   -D, --defkey NAME  -- Consider NAME a definition form, as well.
                         The list of standard definition forms are:
                           define     define-public,
                           define*    define*-public,
                           defmacro   defmacro-public,
                           defmacro*  defmacro*-public
                           define-macro

   -v, --verbose      -- Display progress and scan information.
                         This includes filename, definition names,
                         and "distance" information.

 Note that both ‘-I’ and ‘-D’ add to their respective lists; there is
 presently no way to specify that an item be removed.  Also, both ‘-I’
 and ‘-D’ can be given multiply; their args accumulate.

circle-frisk 1.1

 Usage: circle-frisk [--root] [FILE ...]

 Show frisk results in a window.  Each line is an edge.
 Internal modules are on the inner circle, and external the outer.
 Optional arg ‘--root’ means use the root window.  Modules move
 about; info on currently active module is sent to stdout.

concordance 1.1

 Usage: concordance [options] MBOX...

 Display concordance of MBOX ..., each a Unix-mbox format file.
 Options:

  -q, --quiet            -- don't report progress
  -x, --exclude WORDS    -- ignore WORDS, a comma-separated list of words
  -i, --case-insensitive -- downcase words on read
  -m, --minimum N        -- ignore words with length < N (default 1)
  -M, --maximum N        -- ignore words with length > N (default 59)

 Only the mail message bodies are scanned.

cron-walk 2.6

 Usage: cron-walk [OPTIONS] WHEN [DIR...]

 Options (detailed description below):
      --debug        -- enable some more output than usual
  -l, --load FILE    -- load FILE prior to starting
  -c, --config FILE  -- set options and DIRs from FILE

 Find executable .cron files under DIR(s), skipping all symlinks, and
 load them DFS-style (parent dir last) w/ single arg WHEN, first changing
 to that directory.  Output is collected and mailed out only on failure.
 Loading is done into a child process, with the ‘command-line’ proc
 rewritten.  At least one DIR must be specified (but see "-c" below).

 Command-line option "--load FILE" (or "-l FILE" for short) loads FILE
 prior to doing the walk.  This option can be given multiple times.

 Command-line option "--config FILE" (or "-c FILE" for short) means to
 read FILE to set options and directories.  The configuration file is
 series of forms, the first of which is an alist supporting keys:

 * templates (required)
   The value is a sub-alist with keys ‘lock’ and ‘log’.  The
   associated value is a string, with exactly one "~A" in it which
   will be substituted with WHEN, which specifies a filename for
   the lockfile and the logfile, respectively.
 * debug (optional)
   If specified and the value is non-‘#f’, equivalent to
   specifying --debug on the command line.
 * load (optional)
   The value is a list of files to be loaded, equivalent to
   specifying --load FILE1 --load FILE2... on the command line.

 The rest of the configuration file are a series of flat lists of the
 form: (WHEN DIR...), where WHEN is a symbol and each DIR a string.

 Dependencies: Env var "DEBUG_CRON_WALK" set causes output logs to be mailed
 regardless of .cron return value.  This can also be enabled w/ command-line
 option "--debug".  Env vars "MAILTO", "USER" and "LOGNAME" are consulted in
 that order to determine the mail recipient.

 Env var CRON_WALK_CONFIGURATION with value FILE is the same as specifying
 --config FILE.  However, the command-line option takes precedence.

— Syntax: cron! [handlers...]

(Actually, this is a special-form, not a procedure.)

Examine (command-line) and invoke one of the handlers.

handlers is one or more forms:

          ((KEY) BODY...)

key is one or more symbols. body is one or more forms, to be evaluated in order if (cadr (command-line)) matches key.

If (command-line) does not return a list of exactly two elements, display a usage message and throw an error. If no matching key is found, exit successfully, otherwise, exit with the value of the last body form evaluated. For example:

          #!/usr/local/bin/guile -s
          !#
          (use-modules ((ttn-do cron-walk) #:select (cron!)))
          (cron! ((hourly) (display "yawn, stretch") (newline))
                 ((daily)  (display "zonk") (newline)))

#!/bin/sh
if [ x$1 = x-f ] ; then
    rm -f config.cache
    set -- -r
fi
if [ x$1 = x-r ] ; then
    ./config.status --recheck && ./config.status
else
    ./config.status "$@"
fi

#!/bin/sh
cvs update "$@" 2>&1 | sed '/^?/d;/^cvs update:/d'

debian-package-downstream 1.3

 Usage: debian-package-downstream [[--recurse] PKG ...]

 Find the downstream packages for each installed package (as determined by
 "dpkg --get-selections" whose last token on the line is "install"), that
 are themselves installed, and display a summary line:

 * installed downstream count
   The number of packages downstream from this one that are actually
   installed on the system.

 * total downstream count
   The total number of packages downstream from this one, including
   those that may not actually be installed on the system.

 * package name
   A single symbol.

 * installed downstream
   List of symbols: (PKG1 PKG2 ...), possibly empty: ().
   Strictly speaking, the first field is redundant due to this one, but
   we include both anyway since it makes for easier reading by humans.

 If PKG is specified, only do analysis for those PKGs named
 (still against the entire list of installed packages, however).

 When PKG is specified, option ‘--recurse’ (or ‘-r’ for short)
 recurses into the downstreams of each PKG specified.

demo 2.1

 Usage: demo [NAME...]

 Consult ~/.demos for a list of demos, and run each demo named.
 If more than one NAME is specified, display "running demo: NAME"
 prior to running the demo.  If NAME is omitted, simply list the
 available demos.

 The ~/.demos file contains normal Scheme code, interspersed w/
 expressions of the form:

   (defdemo NAME (child FILENAME [ARGS...]))

 The ‘defdemo’ form registers a thunk under NAME in the demo list.
 The ‘child’ procedure returns a thunk suitable for running demo
 FILENAME w/ ARGS, after first changing to FILENAME's directory.

display-state-summary 1.1

 Usage: display-state-summary [DIR]

 For each file under and in directory DIR ("." if unspecified),
 display a one-line summary of the form:

 STATE MTIME FILENAME

 where STATE is a version control state, typically "Rel" or "Exp";
 MTIME is formatted using "%F %T" (eg, "2007-09-01 03:27:14"); and
 FILENAME is the relative filename from DIR.

 At this time, there is support for RCS and CVS, detected by the
 presence of subdir RCS or CVS in DIR.  If no such subdir exists,
 display an error message and exit failurefully.

display-wurld 1.3

 Usage: display-wurld [URL-LIST]

 Display an HTML "wurld" to stdout.  Optional arg URL-LIST names a file
 containing one URL per line, in which case display-wurld decorates the
 "denser" areas of the output with randomly chosen links.  If URL-LIST is
 "-" the list of links is taken from stdin.

— Procedure: html-wurld-tree [keyword value...]

          Keywords: size, gen, links

Return an html-data tree made from an ASCII-representation of a globe image. Keyword parameters, default values, and their meanings:

#:size	150	Size in pixels (NxN) of the originating image.
#:gen	#:ppmforge	Preferred backend program used to generate the image, one of #:xearth, #:xplanet or #:ppmforge. The value can also be a symbol.
#:links	#f	A list of URLs (strings), or a single filename. When specified, the single string return value is profiled for small non-whitespace intervals to be “marked up” as the text of an XHTML a element, with the reference (attribute href) taken randomly from links. If links is a filename, that file should contain one URL per line.

edit-script-header 2.0

 Usage: edit-script-header [OPTIONS] FILE ...

 Grok and modify each FILE's header (hash-bang invocation sequence)
 according to OPTIONS:

  -o, --output OTHER  -- write to file OTHER instead of modifying FILE
  -g, --guile [GUILE] -- use GUILE as the interpreter
  -G, --GUILE-guile   -- use ${GUILE-guile} construct, implies -e
  -n, --no-act        -- do not do the edit, display parse results only
  -v, --verbose       -- display progress reports
  -b, --backup EXT    -- rename output file to fooEXT before writing
  -s, --style STYLE   -- convert output to use header STYLE (see below)
  -i, --installed     -- use installed guile as the interpreter

 By default, the name of the interpreter is constructed by combining
 bindir (use "guile-tools guile-config info bindir" to see this value)
 with the name "guile", for example: "/usr/local/bin/guile".  This name
 is placed directly after the hash-bang "#!" on the first line followed
 by a space and then the meta switch "\".  The second line has the rest
 of the args, terminating with "-s" and a newline.  The third line has
 a bang-hash "!#" only.  This is the ‘direct-with-meta-switch’ style.

 Simple edits (like changing the guile interpreter from /usr/bin/guile
 to /usr/local/bin/guile, for example) are no problem.  Converting
 between styles is somewhat more tricky.  Here is a list of the styles
 that are recognized and supported (for -s option):

 * old-style-sh-wrapper

   This is primarily for executable modules, and looks something like:

   #!/bin/sh
   main='(module-ref (resolve-module '\''MODULE-NAME) '\'main')'
   exec ${GUILE-guile} -l $0 -c "(apply $main (cdr (command-line)))" "$@"
   !#

   We call it "old" because there are now better ways to invoke ‘main’
   (see ‘modern-sh-wrapper’).  Converting scripts from and to this style
   requires accompanying changes to the script's invocation convention
   that ‘edit-script-header’ does not handle.

 * modern-sh-wrapper

   This style looks something like:

   #!/bin/sh
   exec ${GUILE-guile} -e ENTRY-POINT -s $0 "$@"
   !#

   The distinguishing characteristic is ‘exec’ and ‘-s $0 "$@"’.  The
   ‘-e ENTRY-POINT’ is optional.  This style is fully convertable to
   and from the ‘direct-with-meta-switch’ style.

 * direct-with-meta-switch

   This style looks something like:

   #!/usr/local/bin/guile \
   -e ENTRY-POINT -s
   !#

   The distinguishing characteristic is the guile interpreter named in
   the first line as well as the meta switch.  The ‘-e ENTRY-POINT’ is
   optional.  This style is fully convertable to and from the
   ‘modern-sh-wrapper’ style.

 * direct-with-minus-s

   This style looks something like:

   #!/usr/local/bin/guile -s
   !#

   The distinguishing characteristic is the guile interpreter named
   in the first line as well as the ‘-s’ switch.  This style can be
   converted to and from the other ones with some restrictions.

format-atom-feed 2.0

 Usage: format-atom-feed [-e ENCODING] [SEXP]

 Format SEXP into "Atom feed" XML, and write the result to stdout.
 If SEXP is unspecified or "-", read it from stdin.

 SEXP should have (this is not validated) the format:

   (feed
    (@ (xmlns "http://www.w3.org/2005/Atom"))
    (id ID-SPEC)
    (link (@ (rel "self") (href ID-SPEC)))
    (updated UPDATED-SPEC)
    (title "Example feed")
    (author (name "J. R. Hacker") ...)
    (entry (title "Atom-Powered Robots Run Amok")
           (link (@ (rel REL) (href URL)))
           (id ID-SPEC)
           (updated UPDATED-SPEC)
           (summary "Scheming bots everywhere!"))
    ...)

 Alternatively, each ‘entry’ can have an ‘author’, in which case
 the top-level ‘feed’ need not include ‘author’.

 UPDATED-SPEC can be an integer, the number of seconds since epoch,
 as returned by procedure ‘current-time’; or ‘#t’, in which case
 the value of calling ‘current-time’ is used.  The formatted time
 is always UTC.

 REL is typically "alternate".

 ID-SPEC is a string, the "unique id" for the #:feed or #:entry,
 respectively.  This can be a URL.

 Option ‘--encoding’ (or ‘-e’) specifies ENCODING for the first line:

  <?xml version="1.0" encoding="ENCODING"?>

 If unspecified, the default is "utf-8".


 Notes:
 You can check the output using: <http://feedvalidator.org>.
 Info about Atom (spec, etc) at: <http://feedvalidator.org/docs/>.

— Procedure: format-atom-feed port enc sexp [newline-before...]

Send to port using encoding enc the sexp in Atom format¹. If port is #f, return a string, instead. Normally, the output omits inter-element whitespace. Optional args newline-before is a list of elements (symbols) prior to which a newline ‘\n’ should be output. Valid elements (which are all of them Atom elements) are:

          author           generator        rights
          category         icon             source
          content          id               subtitle
          contributor      link             summary
          email            logo             title
          entry            name             updated
          feed             published        uri

format-css 1.0

 Usage: format-css [-v | --verbose] [FILE.sexp ...]

 Format contents of each FILE.sexp, writing FILE.css.
 Contents are zero or more CSS rules, each a list
 suitable for ‘(ttn-do zzz publishing) css-tree’ expansion.
 If no files are specified, process all ‘*.sexp’ in cwd.

fortune 1.0

 Usage: fortune -l    (like "ls -l -I '*.dat' <standard-cookie-dir>")
        fortune
        fortune literature   [or other filename in standard cookie dir]
        fortune ABSOLUTE-FILENAME   [.dat assumed in same dir]

 Display fortune cookie to stdout.  Option ‘--list’ (or ‘-l’ for short)
 means instead to list the contents of the <standard-cookie-dir>, which
 is either "$HOME/local/share/games/fortunes" or the contents of file
 $HOME/.fortune-cookie-dir if the first directory is not found.  If the
 cookie dir cannot be determined, signal error.

— Procedure: create-index-file! out-name in-name delim [flags...]

Create index file out-name from cookie file in-name, separating cookies by looking for char delim on a line by itself. Optional flags are keywords:

#:random

Set bit 0 (corresponding to a mask of #x1) in the flags word in the header, but do nothing else at the moment (FIXME).

#:ordered

Set bit 1 (corresponding to a mask of #x2) in the flags word in the header, and order the offsets by sorting the cookies with string<?, ignoring non-alphanumeric leading characters.

#:rotated

Set bit 2 (corresponding to a mask of #x4) in the flags word in the header, to note that the cookies are ROT13.

Return #t on success.

— Procedure: fortune-cookie cookie-file [dat-file]

Return a randomly-chosen string extracted from cookie-file, using the index file named by appending .dat to cookie-file. Optional arg dat-file specifies the index file to use instead of the default.

function-tree 1.1

 Usage: function-tree filename [--root]
 Display two of the top-level forms in FILENAME as trees.
 Optional arg ‘--root’ means display on
 the root window instead of in a new one.

generate-C-symbol-set 1.1

 Usage: generate-C-symbol-set [options] SYMBOL...

 Options are:
 -p, --pool-name NAME      -- use NAME instead of ‘symbolpool’
 -b, --byte-type TYPE      -- use TYPE instead of ‘uint8_t’
 -g, --global              -- omit "static"
 -z, --zero                -- produce NUL-terminated entries

 Write to stdout a C data structure representing a symbol pool
 with symbols SYMBOL...  For example:

   $ generate-C-symbol-set \
     Author Date Id
   static const uint8_t symbolpool[16] =
   {
     3 /* count */,
     6,'A','u','t','h','o','r',
     4,'D','a','t','e',
     2,'I','d'
   };

 A more complicated example, using all the switches:

   $ generate-C-symbol-set -b BYTE -p keywords -g -z \
     Author Date Id
   const BYTE keywords[19] =
   {
     3 /* count */,
     6,'A','u','t','h','o','r','\0',
     4,'D','a','t','e','\0',
     2,'I','d','\0'
   };

 Note that with ‘--zero’, the pool (sub)strings are C-compatible.

— Procedure: generate-C-symbol-set configuration ls

Return a string tree representing the C code for the symbol set ls (a list of strings), customized by configuration (an alist). Recognized configuration keys (symbols) are: zero, global, byte-type and pool-name. Values are boolean for zero and global, and string for the others.

You can use flatten (see zzz publishing), to render this tree. (This is what the shell command does.)

gnuvola-wip (ttn-do) 1.6

Usage: gnuvola-wip [help | version | check | copy | uncopy] [OVERRIDE-VARS]

If invoked w/o args, default to command "check".  Note that this program
does not support `--help' or `--version'; use hyphenless variants, instead.

  help    -- Display this message and exit successfully.
  version -- Display version and exit successfully.
  check   -- Test for subdir .git; exit failurefully if not found.
  copy    -- Create $(pubrepo) if necessary (with $(git) clone),
             then push the repo there using $(git) prune, gc, push.
             Lastly, copy the description file.
  uncopy  -- Delete $(pubrepo).

Some GNUmakefile vars (and their default values) influence operation:

  git     -- git
  wip     -- ~/build/gnuvola/wip
  here    -- $(shell pwd)
  repo    -- $(notdir $(here)).git
  branch  -- master
  pubrepo -- $(wip)/$(repo)

You can override them on the command line with VAR=VALUE.

grumi 1.7

 Uso: grumi [opzioni]

 Elenca tutti i moduli disponibili.

  -G, --guile PROG    -- chiede PROG per %load-path [guile]
  -p, --port NUMERO   -- si connette alla porta tcp NUMERO
                         usando il protocollo HTTP
  -d, --daemon FILE   -- scrive il pid e la porta tcp in FILE e va al
                         fondo; per fermarlo: kill -1 `head -1 NOME`

gutenberg2mbox 2.0

 Usage: gutenberg2mbox [options] GUTENBERG-FILE

 Convert GUTENBERG-FILE to an mbox file, writing GUTENBERG-FILE.mbox.
 Lines up to and including the one that matches a preamble-end regexp,
 as well as those starting with the one that matches a postamble-begin
 regexp, are discarded.

 Each chapter becomes a message.  The first message is the title page.
 The title page is taken from the lines between the preamble and the
 first line that matches a chapter-begin regexp.

 The title is taken from the first non-empty line on the title page.
 The subject of each message is made from the first two lines of the
 chapter, in this format: LINE-1 -- LINE-2.

  -v, --verbose            -- display message subject lines
  -o, --output FILENAME    -- write output to FILENAME
      --preamble-end RX    -- use RX as the preamble-end regexp
                              [default: "^.END.THE SMALL PRINT"]
      --chapter-begin RX   -- use RX as the chapter-begin regexp
                              [default: "^Chapter "]
      --subject-skip N     -- skip N presumably-blank lines to find
                              LINE-1 and LINE-2 [default: 0]
      --postamble-begin RX -- use RX as the postamble-begin regexp

 The postamble-begin regexp is optional; there is no default for it.
 If there is an error, the output file is not written.

gxferm 2.0

 Usage: gxferm [--output FILENAME] CONFIG...

 Preprocess CONFIG... to create properly formatted ferm(1) input.
 Write output to standard output (or FILENAME, if specified).

 CONFIG... names input files containing Scheme forms to be processed, in
 order.  This table maps Scheme forms to "normal ferm input expressions":


  (define SYMBOL 'VALUE)                def $VAR = EXPR;
   ;; note quote ^


  ,SYMBOL                               $VAR


  (+ (A B C)                            A B C {
     (= D E F)                            D E F;
     (= G H I))                           G H I;
                                        }


  (define-macro (SIMPLE A1 A2)          def &SIMPLE (A1, A2) =
    (X Y ,A1 Z ,A2))                      X Y $A1 Z $A2;


  ,(SIMPLE P1 P2)                       &SIMPLE (P1, P2)
   ;; forms may follow, .e.g:
   ;; (= ,(SIMPLE (P1 P2)) DROP)


  (define-macro (BLOCK A1 A2)           def &BLOCK (A1, A2) = {
    (+ (J K)                              J K {
       (= W ,A1 X)                          W $A1 X;
       (= Y ,A2 Z)))                        Y $A3 Z;
                                          }
                                        }


  ,(BLOCK P1 P2)                        &BLOCK (P1, P2);
   ;; must conclude a chain, .e.g:
   ;; (+ () ,(BLOCK P1 P2))


 Unrecognized forms produce a "WARNING: UNRECOGNIZED" to stderr.
 A ‘+’ or ‘=’ form may be "commented out" by one or two single quotes.
 One will produce a "WARNING: IGNORING" (to stderr); two, nothing.

htmlize-scheme 1.3

 Usage: htmlize-scheme [options] FILE...

 Load htmlization-map files, process FILE, write FILE.html.
 Options are:
  -l, --load HMAP    -- load htmlization map file HMAP
  -d, --hmap-dir DIR -- load all *.hmap files in DIR
      --css CSS      -- if CSS begins with a space character,
                        use it literally, otherwise, take it
                        as a filename and use its contents
      --elisp FILE   -- arrange for the inferior Emacs to
                        do ‘(load-file FILE)’

 In FILE.html, mappings specified in hmap files are substituted using
 the hmap-specified stem and leaf.  At least one HMAP must be loaded.

 This program relies on htmlize.el, which does not always generate the
 correct colors for the <style> block due to tricky (i.e., unresolved)
 font-lock issues when used in batch mode.  As a kludge, you can use
 ‘--css CSS’ to completely replace that block with the contents of file
 CSS (automatically wrapped with a <style> element).  As a special
 case, if CSS begins with a space, it is taken to be the literal string.

 The htmlization-map file contains Scheme code define a mapping between
 a piece of typed ‘html anchor’ text and its url leaf.  At the moment,
 the only supported type is #:module-name.  When TEXT is recognized,
 it is replaced with: <a href="FULL">TEXT</a>, where FULL is formed by
 concatenating the stem with the LEAF.

 To define a mapping, use the Scheme proc ‘define-mapping’.

 You can customize the default processing done by htmlize.el by
 specifying ‘--elisp FILE’, which is loaded where indicated in
 the Emacs Lisp sequence:

  (progn
    (setq vc-handled-backends nil)
    (require 'htmlize)
    (require 'scheme)
    ;;;
    ;;; maybe do (load-file FILE) here
    ;;;
    (pushnew '("." . scheme-mode) auto-mode-alist :test 'equal) ; yuk
    (let ((enable-local-variables nil)
          (enable-local-eval nil))
      (htmlize-many-files command-line-args-left)))

— Procedure: define-mapping name [keyword value...]

          Keywords: stem, type, recognize, lookup, data

Define a mapping named name, a keyword or symbol. Valid keywords are:

#:stem string

This is the constant prefix for all targets in name.

#:type type

type is a keyword. At this time, only #:module-name is supported. That is the default value (thus, at this time, this keyword is entirely optional).

#:recognize recog

(for #:type #:module-name)
If recog is a string, use it as the regexp to recognize text. Otherwise (presuming type is #:module-name), if recog is a symbol, use it to construct a regexp that matches (RECOG ...), i.e., the module name whose first element is recog. If recog is #f or left unspecified, compose the regexp from the first symbol in each of the keys specified in the #:data value (see below).

#:lookup lookup

lookup is a procedure that takes two arguments: data (see below) and key. It should return the leaf associated with key, or #f if not found. This is typically assoc-ref, assv-ref or assq-ref. If recog is #f, this MUST be one of those for the constructed-regexp hack to work. key will be a the recognized text read as a Scheme object. For example, when type is #:module-name, key is a list of symbols.

#:data data

data is passed to lookup as the first arg. When type is #:module-name, this MUST be an alist for the constructed-regexp hack to work.

The following errors may occur during operation:

• no htmlize-scheme mappings loaded
• bad part for mapping: name

imgtxtlink 1.1

 Usage: imgtxtlink [options...] image

 Covert IMAGE file to text and decorate it with hyperlinks.
 Recognized options (defaults in square braces):

 -o, --output FILENAME  -- write to FILENAME [IMAGE.html]
 -s, --scale SPEC       -- pass SPEC to pnmscale
 -i, --invert           -- include pnminvert(1) in processing
     --bgcolor COLOR    -- page background color
     --text COLOR       -- page text color
 -l, --links FILENAME   -- look in FILENAME for urls
                           [single url: ttn-do homepage]

 This program uses commands from Netpbm for image manipulation.

— Procedure: string<-image-command source [invert?]

Concatentate source, a shell command that writes image data to stdout, with a series of shell commands from the Netpbm package. Optional arg invert? non-#f means to include a call to pnminvert in the pipeline.

Execute the pipeline in a subshell and return its output as a string.

— Procedure: randomly-hyperlinked string list-of-links [link-tree]

Profile string for small non-whitespace intervals to be “marked up” as the text of an HTML A element, with reference taken randomly from list-of-links (list of strings). As as special case, if the car of list-of-links is the symbol file-lines, then the cadr is taken to be a filename which must contain one link (URL) per line.

Return an html-data tree (nested list of strings). Optional third arg link-tree specifies a procedure to use instead of href (see zzz xhtml-tree) to construct hyperlink references. It should take arguments url and text (both strings), and return a tree (nested list of strings).

local-build 2.0

 Usage: local-build [options] TARBALL[...] [-- configure-options...]

 Do the standard build and install process for GNU programs, namely
 "configure ; make ; make install".  For each TARBALL (.tar.gz or .tgz),
 unpack the package in the current directory and build in place.
 The prefix is ‘$HOME/local’.

 Options:
   --make-cmd CMD    -- Use CMD to build instead of simply "make".
   --no-install      -- Skip "make install".
   --check           -- Do "make check" before "make install".
   --clean           -- Do "make clean" after "make install".

 Additional options to the configure script can be specified
 by appending them after the argument "--".

 Examples:
   $ local-build rcs-5.7.tar.gz cvs-1.10.tar.gz
   $ local-build --no-install \
                 --make-cmd=/home/gnutex/bin/make-and-install-gcc \
                 gcc-2.95.2.tar.gz \
                 -- --with-gnu-as

ls-tarballs 1.0

 Usage: ls-tarballs [DIR]

 List the .tar.gz files in DIR (or "." if unspecified),
 grouping by STEM and summarizing version numbers.
 The output format is:

   YYYY-MM-DD STEM     COUNT -- RELEASES

 where YYYY-MM-DD is the mtime of the latest STEM-*.tar.gz,
 COUNT is count of the tarballs with the same STEM, and
 RELEASES is a compacted comma-separated list of version numbers
 (the part of the filename besides STEM- and ".tar.gz").

 Version numbers are normalized to a list of integers, so that
 "edb-1.26p1.tar.gz", for example, has internal representation
 ‘(1 26 1)’, and displayed with dot as separator, e.g., "1.26.1".

 The space between STEM and COUNT is adjusted for columnar output.

magic 1.1

 Usage: magic [options] [FILE...]

 Display results of scanning FILE, or "data" if type and other
 attributes cannot be determined.  By default definitions are
 read from ~/.magic (see magic(5) for information on its format),
 or, preferentially, from ~/.magic.ttn-do-magic, if it exists.

 Options are:

  -m, --magic-file MAGIC  -- read definitions from MAGIC instead
                             of default ~/.magic
  -C, --compile           -- used in conjunction with -m MAGIC
                             to write out MAGIC.ttn-do-magic

 The output is similar, but not identical, to that of file(1).

 Presently, this program understands ~/.magic.ttn-do-magic in
 either .ttn-do-magic-1 or .ttn-do-magic-2 format, and writes
 in .ttn-do-magic-2 format only.

maintainer-tools-versions 1.0

 Usage: maintainer-tools-versions [ADDITIONAL-PROGRAMS...]

 Call autoconf, automake, libtool and guile and any specified
 ADDITIONAL-PROGRAMS with single arg ‘--version’ and collect the
 first line (respectively) output.

 Display each line with a "# " (hash space) prefix.

make-boot-set 1.0

 Usage: make-boot-set DIR

 Write sequence of floppies with the Debian boot set in DIR.
 A possible money-making scheme, in the right clueless environment.

make-pgtable 2.2

 Usage: make-pgtable [OPTIONS] TABLE...

 Create PostgreSQL table(s) in a database.
 OPTIONS can be one or more of:
   -l, --list        list all db and table names and exit successfully
   -L, --list-fully  like ‘--list’ but also include defs
   -s, --show-defs   show defs for TABLE but do not create it
   -d, --db NAME     use db NAME [default: value of USER env var]
   -x, --go-away     delete table
   -e, --echo        display the SQL command before dispatch

 The name of the meta-file required by make-pgtable can be specified
 by env var ${USER}_PGTABLE_DEFS, where ${USER} is the value of env
 var USER, upcased.  For example:

   "jrhacker" => "JRHACKER_PGTABLE_DEFS"

 See docs for module (ttn-do zzz various-db) for a description of the
 meta-file format.

mark-up-news-excerpt 1.0

 Usage: mark-up-news-excerpt [--download-dir URL] -e excerpt-file

 Process EXCERPT-FILE, which must be in a special format,
 and display to stdout the XHTML tree of its "Latest release"
 paragraph and NEWS outline.

 The EXCERPT-FILE format is line-oriented UTF-8 text:

   HEADER

   * TAG   TEXT
   ...

   - VERSION | DATE
     - ITEM
     ...

   FOOTER

 Both HEADER and FOOTER are ignored, although it is probably a
 good idea to put a "Local variables" block in the FOOTER to make
 sure the file stays UTF-8.

 The "markup section" begins with an asterisk in column 0 followed
 by a TAG (e.g., ‘code’), followed by the text that must be marked
 up.  Between TAG and TEXT must appear one or more space (U+0020)
 characters.  See module (ttn-do zzz xhtml-tree) for more info.

 In the "Latest release" paragraph, VERSION and DATE are formatted
 as "VERSION (DATE)".  If ‘--download-dir URL’ (‘-d’ for short) is
 given, that text is hyperlinked to URL.

 In addition to the explicit markup, the ITEMs are automatically
 processed to mark ‘foo’ and "bar" with ‘~code’.  In the first
 case, the left (U+2018) and right (U+2019) single-quotes are
 placed outside the ‘~code’, while in the second case, the double
 quotes (U+0022) are placed inside the ‘~code’.

— Procedure: mark-up-news-excerpt excerpt-file [download-dir]

Return an expression (unevaluated tree) made from marking up excerpt-file (a string). The tree includes elements to produce a "Latest release:" paragraph (including a hyperlink to download-dir, if specified) followed by the outline of news items. Evaluation of this tree requires access to XHTML procs (see zzz xhtml-tree).

mmci 1.2.0

 Usage: mmci --repo DIR [options] [NEWDIR]

 Abstract the "cvs add" procedure to also handle RCS files and
 Emacs-style backup files.  Options is zero or more of:

   -r, --repo RELDIR  NEWDIR/* should go into CVSROOT/RELDIR/*.
                      RELDIR can have multiple /-separated components.
                      This argument is required.

   -n, --dry-run      Display commands mmci would do,
                      but don't actually do them.

   -v, --verbose      Display commands as they are executed.
                      By default, mmci works quietly.

   -d, --cvsroot DIR  Use DIR as CVSROOT.  If this is omitted, env
                      var CVSROOT must be set.  The CVSROOT must
                      point to a local dir (no ":" methods).

   -x, --exclude RX   Ignore files that match regular expression RX.
                      Matching is done on the non-directory part of the
                      filename.  This option may be given multiple times.

   -H, --symlinks-ok  Do not ignore symlinks.

 NEWDIR names a single relative directory of the current working
 directory to be (recursively) processed.  If omitted, default is "."
 (i.e., the current working directory).  Files already in CVS (as
 evidenced by their name appearing in CVS/Entries) are ignored, as are
 most files cvs normally ignores.  A notable exception is Emacs-style
 backup files (foo, foo~, and foo.~N~), which are checked in with
 successive revisions based on the files' mtimes.  Files under RCS
 control (RCS/*,v) are copied directly.  New files are checked into
 RCS temporarily and processed as such.

 Typically, you would use mmci like so:

   mmci -n -r my-module/stuff stuff     # dry run ("would-do ...")
   mmci -v -r my-module/stuff stuff     # do it, verbosely
   mv stuff stuff.orig
   cvs co -d stuff my-module/stuff      # inspect for errors
   rm -rf stuff.orig

 Note that mmci will create directory ‘my-module/stuff’ for you.

 Although mmci tries not to disturb the original working directory,
 for new files, the permissions may sometimes end up read-only.
 It's a good idea to take a snapshot of the directory first.


 Builtin Exclusions
 ------------------
 Here is the list of all the built-in regexps.  They were snarfed
 from CVS info page and converted to Guile's regexp syntax, with
 these removed removed: "*~", "core", "RCS" and "CVS"; and these
 added: "*.lo" and ".deps".

 ^SCCS$
 ^CVS.adm$
 ^RCSLOG$
 ^tags$
 ^TAGS$
 ^\.deps$
 ^\.nse_depinfo$
 ^\.make\.state$
 .*\.old$
 .*\.bak$
 .*\.BAK$
 .*\.orig$
 .*\.rej$
 .*\.a$
 .*\.olb$
 .*\.o$
 .*\.obj$
 .*\.so$
 .*\.exe$
 .*\.Z$
 .*\.elc$
 .*\.ln$
 ^#.*
 ^\.#.*
 ^,.*
 ^_\$.*
 ^\.del-.*
 ^cvslog\..*
 .*\$$

 At this time, there is no way (aside from modifying the source code)
 to reduce this list.  The ‘--exclude’ option appends to it.

mogrify 1.0

 Usage: mogrify

 Do nothing and exit successfully.

— Syntax: editing-buffer buffer [body...]

Consider buffer the current buffer and execute body. In body, applications of one of the following procs are handled specially.

          (insert-file-contents filename [visit? [beg [end [replace?]]]])
          (toggle-read-only [arg])
          (search-forward string [bound [noerror [repeat]]])
          (match-end [n])
          (match-data)
          (set-match-data m)
          (buffer-lines)               ; => (STRING ...)
          (buffer-substring beg end)
          (search-backward string [bound [noerror [repeat]]])
          (match-string n)
          (forward-char n)
          (backward-char n)
          (forward-line [n])
          (beginning-of-line [n])
          (end-of-line [n])
          (re-search-forward regexp [bound [noerror [repeat]]])
          (match-beginning [n])
          (match-end [n])
          (delete-region beg end)
          (buffer-port)
          (replace-match newtext)
          (insert [obj...])            ; gb/char/string/symbol/number/sexp
          (looking-at regexp)
          (delete-char n)
          (erase-buffer)
          (goto-char pos)
          (buffer-string)
          (point-min)
          (point-max)
          (char-after [pos])
          (char-before [pos])
          (point)
          (bolp)                       ; beginning/end of line/buffer
          (eolp)
          (bobp)
          (eobp)
          (write-to-port port [beg [end]])
          (flush-lines regexp)         ; leaves point at eob
          (keep-lines regexp)          ; likewise
          (save-buffer)                ; buffer must be "visiting a file"
                                       ;  else error (see `find-file' et al)

These calls are all translated by editing-buffer to procedures that take gap-buffer buffer as initial argument (so that the "first" arg above would actually be passed as the second arg, and so on).

If buffer is #t, create and use a new (empty) gap-buffer. If buffer is not a gap-buffer object and not #t, it is passed to make-gap-buffer and the result used for editing.

The value is that of the last form in body, or the gap-buffer object if there are no body forms.

— Object Property: filename: object

Return the (string) filename associated with object, or #f. This is an object property so you can set! it; that's what find-file and find-file-read-only do on the buffer objects they return to effect visiting.

— Procedure: editing-buffer-manager [buffer]

Return a procedure that encapsulates a new editing buffer (or buffer, if specified). The returned proc takes a (symbolic) command and arguments (if any), dispatching internally. For example:

          (define MGR (editing-buffer-manager))
          (MGR 'insert "foo")
          (MGR 'write-to-port #t)
          
          ===
          
          (editing-buffer "foo"
            (write-to-port #t))

In addition to the commands supported by editing-buffer, there are some special commands:

mgr

Return the internal editing buffer. Here, mgr is the manager procedure itself (i.e., (mgr mgr)).

#f

Forget the internal editing buffer (possibly exposing it to garbage collection). Subsequent invocations will signal a "no more buffer" error.

#t

Return the internal editing buffer, forgetting it, as well. Subsequent invocations will signal a "no more buffer" error.

— Procedure: find-file-read-only filename

Find filename into a buffer and make it read-only. This causes the buffer to visit the file. Move point to beginning of buffer and return the buffer.

— Procedure: find-file filename

Find filename into a buffer. This causes the buffer to visit the file. If the file is not readable, return #f. If the file is read-only, make the buffer read-only as well. Move point to beginning of buffer and return the buffer.

mq 1.1

 Usage: mq [options] [FILENAME]

 Display an empty "floorplan" (X window) on which you can draw
 and erase "furniture".  The scale is one pixel per centimeter,
 with minimum size 10cm x 10cm.

 Options are [default value in square braces]:

 -g, --geometry WxH   -- Make the top-level window W by H pixels.
                         [800x600]
     --bpp N          -- Use N bits per pixel; N = 8, 16, 24, 32.
                         [32]  Note that alpha blending is ugly
                         for bpp 16, and non-existent for bpp 8.

 To draw, press and hold down the ‘c’ key, move the mouse to the
 opposite corner of the rectangle, and release the key.  Other keys:
   q   -- query size (also works with in-between space)
   s   -- shift (move) -- hold down (like ‘c’)
   r   -- resize -- hold down (like ‘c’) "near" a corner
   x   -- erase
   ESC -- quit

 If FILENAME is specified, read previously-saved data from there
 (ignoring --geometry), and save current data there on quit.

new-cvsroot 1.1

 Usage: new-cvsroot NEW-ROOT

 Replace contents of all CVS/Root files under cwd w/ NEW-ROOT.

pg2edb 0.1

 NOTE: This program is still EXPERIMENTAL.

 Usage: pg2edb [options] TABLE

 Analyze PostgreSQL table TABLE; display inferred defs to stdout;
 dump combined schema/data to stdout in EDB "inherent data" format.

 -d, --database NAME  -- connect to db name (default: user name)
 -o, --output FILE    -- write "inherent data" format to FILE
 -E, --encoding ENC   -- use client encoding ENC (default: "UNICODE")

phone 2.0

 Usage: phone REGEXP

 Grep for REGEXP in ~/.phone database.

pp 1.1

 Usage: pp [options] FILE...

 Pretty print contents of FILE... to stdout.
 The contents are read as "normal" Scheme sexps.

 Options:
  -p, --preserve-comments  -- output top-level whitespace and
                              comments (including a script's
                              initial #!...!# header) undisturbed
  -s, --sed SCRIPT         -- do "sed SCRIPT FILE" for input
  -k, --keyword-hack       -- do ‘s/#:/:#/g’ for input and
                              ‘s/:#/#:/g’ for output (yuk!)

— Procedure: pp sexp [port]

Pretty-print sexp to the current output port, or port if specified. If the underlying Guile supports it, all strings in the output have certain characeters escaped, e.g., with ‘#\newline’ represented as ‘\n’ (two chars: #\\ and #\n).

ppmglobe 1.0

 Usage: ppmglobe [options]

 Write to stdout ppm image data representing a random globe.
 Options [defaults] are:

 -g, --generator PROGRAM  -- use PROGRAM (xearth, xplanet, or
                             ppmforge) to generate the image
                             [ppmforge]

 -s, --size N             -- image is roughly NxN pixels [360]

 If PROGRAM is not available, write to stderr the message
 "program unavailable: PROGRAM" and exit failurefully.

primes 1.0

 Usage: primes LIMIT

 Display prime numbers in the range [2,LIMIT], one per line.
 If LIMIT is less than two or not a number, do nothing.

— Procedure: primes limit

Return a list of prime numbers in the range [2,limit].

#!/bin/sh
exec make --no-print-directory "$@"

random-info-node 1.3

 Usage: random-info-node [--list] [--sexp] INFO

 Display a random info node from INFO file to stdout.
 Optional arg "--list" (or "-l") means to instead display a list of nodes.
 Optional arg "--sexp" (or "-s") means to display the list as a sexp.

 If INFO ends with ".gz" it is read using "gzip -dc".

randomish-wep-key 1.2

 Usage: randomish-wep-key [--count N] BITLEN

 Display to stdout a somewhat randomly-produced WEP key of BITLEN bits.
 The output is in hexadecimal, so it's a good idea to choose a BITLEN
 that is a multiple of four.  Also, there is a "-" separating every
 group of four hex digits, like so: abcd-1234-99...

 Optional arg --count N specifies how many to keys (one per line) to
 write.  A negative N means to continue until interrupted.

rcs-fast-export 0.2

 rcs-fast-export [OPTIONS] [FILE...]

 Write "fast import" format data from RCS repositories to stdout.
 FILE should be either the repository filename (typically foo,v),
 or the working file name, or a directory name, in which case its
 {RCS/}*,v (if any) are scanned, without descending into subdirs.
 If no FILE is specified, scan "." (the current directory).

 Options:
  -A, --authors FILE   -- Read FILE for author information.
  -p, --prefix RELDIR  -- Prefix each filename with RELDIR.

 Each line in the authors file has the form:

  USERNAME=FULL-INFO

 where USERNAME should correspond to the Unix username, and
 FULL-INFO should include actual name and email address, such
 as "J. R. Hacker <jrh@example.com>", but without the quotes.
 See git-cvsimport(1) for more info.

 Normally, to compute the relative filename of the exported
 repository, rcs-fast-export strips the common root directory of
 all the working filenames (both specified and discovered).
 The option --prefix RELDIR adds RELDIR to the beginning of
 each exported filename. For example, given the two filenames:

  /etc/foo/bar/RCS/f1,v
  /etc/foo/f2  (presuming /etc/foo/RCS/f2,v exists)

 then the working files are /etc/foo/bar/f1, /etc/foo/f2;
 the common root is /etc/foo; and the exported filenames
 are (normally, with "-p baz/qux", e.g.):

   bar/f1, f2
   baz/qux/bar/f1, baz/qux/f2

 RELDIR must not be absolute.

 Limitations:

 - No tags (symbolic names) handling.

 - State changes may show up as empty commits.

 - The branch created is "from-rcs-BRNUM", where BRNUM is the
   part of the RCS revision prior to the last integer, with
   "." replaced by "-".  For example, for revision "1.3.5.7",
   the BRNUM will be "1-3-5".

   Furthermore, branch detection is not file-specific.  This
   means that foo:1.3.5.7 and bar:1.3.5.7 will eventually map
   to the same branch (BRNUM "1-3-5").

 - Incomplete error checking, recovery, diagnostics, testing.
   In other words, code enhancement opportunities abound!

read-xpilot-robots 1.1

 Usage: read-xpilot-robots FILE

 Read xpilot robots file FILE into a list, each element of which
 having the form:

     (NAME TYPE SHIP PARA)

 where NAME and TYPE are strings, SHIP is a list of sublists of
 integers, and PARA is a list of integers.  When invoked from the
 shell, display each form to stdout, one per line.

— Procedure: read-xpilot-robots port

Read input in xpilot robots file format from port. Return a list of sexps.

refresh-hardlinks 1.2

 Usage: refresh-hardlinks [--quiet] DESTDIR

 Find files in DESTDIR matching regexp "[A-Z][A-Za-z0-9]*" and refresh them
 by replacing them with hardlinks to same-named files in the current working
 directory.  If cwd file is a symlink, chase it to find a non-symlink file.

 Additionally for every FILE found, if there exists FILE.txt, refresh that
 as well.  Files in DESTDIR that do not exist in the cwd are silently left
 alone.  Option ‘--quiet’ (‘-q’ for short) suppresses output.

report-zonkables 1.3

 Usage: report-zonkables [options] [ZONKABLES-TEXT-DB-TABLE-FILE]

 Read text db table file ZONKABLES-TEXT-DB-TABLE-FILE and display to
 stdout status of the entries listed therein.  Consult file NEWS in
 the current directory to map release number to calendar date (rn2cd).
 If ZONKABLES-TEXT-DB-TABLE-FILE is omitted, use ".USER.zonkables",
 where USER is the result of ‘(passwd:name (getpwuid (getuid)))’.
 Recognized options:

     --init         -- display the db header form to stdout (see below)
 -n, --news FILE    -- scan FILE for rn2cd mapping [NEWS]
 -x, --exit-count   -- exit value is the count of zonkables

 The NEWS file should contain lines of the form (note hyphen and bar):

 - VERSION | YYYY-MM-DD

 If the YYYY-MM-DD pattern is not found, the current date is used.
 The ZONKABLES-TEXT-DB-TABLE-FILE must start with the following form:

 (text-db-table-config
  (delim . "\n")
  (fields (#:announced sexp)             ; version
          (#:execution sexp)             ; quarters (each 3 months)
          (#:type sexp)
          (#:name rest-lines-trim)))

 You can use the ‘--init’ option to write this form to stdout instead
 of the normal report.  In the normal report, each entry is displayed
 on its own line with the general format:

 VERSION (DATE) QUARTERS (EXPIRE-DATE) -- TYPE ‘NAME’ STATUS

 where STATUS is "planned", "(immediately) zonkable!", "not yet" or
 "weird!".  The latter occurs if report-zonkables gets confused.
 VERSION is from #:announced, DATE is from the NEWS file, QUARTERS
 is from #:execution, EXPIRE-DATE is computed from DATE and QUARTERS,
 TYPE is from #:type, and NAME is from #:name.

— Procedure: report-zonkables! filename

Scan filename, which must name a file in zonkables text db table format, and display current zonkables analysis to the current output port.

rescue-xcb 1.2

 Usage: rescue-xcb INPUT-DIR OUTPUT-DIR

 Read INPUT-DIR/*.xml and write OUTPUT-DIR/*.eaab.
 Filenames undergo s/_/-/g.

rm-rf 1.0

 Usage: rm-rf [-v | --verbose] DIR

 Like shell command ‘rm -rf DIR’.

 From Scheme, there is one proc exported (besides ‘main’):

   (rm-rf! verbose? dir)

 DIR can actually be a single filename.  VERBOSE? non-#f means display
 messages of the form "removing ..." to the current output port for each
 file and directory deleted.  The messages are similar to those produced
 by GNU rm(1), but not an exact duplicate.

— Procedure: rm-rf! verbose? dir

Recursively delete dir. Display progress messages if verbose? is non-#f.

run-signed-batch-job 2.1

 Usage: run-signed-batch-job [OPTIONS]

 Read standard input for a GPG-signed job message and execute it if
 the signer is trusted and if the cache file does not have a duplicate
 signature.  New signatures are added to the cache file.  Mail results.

 Options:
  -t, --trusted-signer SIGNER  -- accept jobs from SIGNER (can use multiply)
  -c, --sig-cache FILE         -- cache sigs in FILE
  -l, --logfile FILE           -- write transaction log to FILE (required)
  -m, --mailto ADDR            -- mail results to ADDR
  -s, --slack SECONDS          -- timeout on each command (default: 4)

scm2bin 3.4

 Usage: scm2bin --help
        scm2bin --version
        scm2bin [OPTIONS] SCM
  where SCM is a scheme (.scm) program, and OPTIONS
  (defaults in square brackets) is zero or more of:
   -v, --verbose           -- display more info than usual
   -o, --output FILE       -- use FILE for output [scm2bin.out]
   -C, --save-c FILE       -- write composed C code to FILE
   -r, --rpath [DIR]       -- pass "-rpath DIR" to linker
                              [directory where libguile.so is installed]

 scm2bin creates a "binary executable file" named scm2bin.out that
 encapsulates the code from SCM, the filename of a Scheme program.
 This file can be run from the shell like so: ./scm2bin.out ARGS...
 Option ‘--output FILE’ specifies an alternative output filename.

 Internally, program invocation depends on its input.  In all
 cases, all forms are evaluated sequentially.  Then, do:

 * simple script without ‘main’
   (exit #t)

 * simple script with ‘main’
   (unmask-signals)
   (exit (main (command-line)))

 * module (first form is ‘define-module’) with ‘main’
   (define-module (guile-user))
   (define-macro (@ ...) ...)
   (unmask-signals)
   (exit ((@ MODULE-NAME main) (command-line)))

 A module without ‘main’ results in an error:
 No ‘main’ procedure defined in module MODULE-NAME

 The default compiler is gcc.  Option ‘--gcc PROGRAM’ overrides this.

 Option ‘--rpath DIR’ means to to pass "--rpath DIR" to the linker.
 This is useful if you have installed Guile in an unusual (or otherwise
 not normally frequented by the dynamic linker/loader) place.

— Procedure: write-punily x

Behave like (write x), but with less whitespace. An exception is made for certain whitespace characters appearing in a string. They are expanded to their two-character "escaped" form:

              #\bel  \a     #\newline  \n     #\ht  \t
              #\np   \f     #\cr       \r     #\vt  \v

Additionally, ‘#\nul’ is written as ‘\0’.

Return a boolean indicating whether or not x is rear delimiting, i.e., can be safely followed (on the output stream) without requiring intervening whitespace. This is the case for strings, vectors and most lists. A particular case is:

          (write-punily 'symbol)   ;; aka (quote symbol)
          -| 'symbol
          ⇒ #f

serve-debiso 2.2

 Usage: serve-debiso

 Mount *.iso files under /mnt/debiso
 and then serve them via http on port 42424.

 This relies on proper autofs/automount setup.
 (If things aren't working, see /etc/auto.master et al.)

sgfc 1.0

 Usage: sgfc [--check-only] [SGF-FILE]

 Read SGF-FILE and write it out (if well-formed) to stdout.
 If SGF-FILE is omitted or "-", read from standard input.
 Optional arg ‘--check-only’ means don't write anything.

— Variable: *properties*

A list of properties for Smart Game Format version 4, i.e., “SGF FF[4]”. Each element has the form:

          (CODE DESCRIPTION CONTEXT TYPE [SUBTYPE...])

What all this means, we still need to document. (TODO)

— Define: *format-changes*

A vector describing the changes between successive SGF versions. This probably should be completely internalized. Don't use it!

— Procedure: read-sgf port

Return the collection of game trees parsed from reading filename.

— Procedure: write-sgf collection

Write the collection of game trees to filename.

— Procedure: children tree

Return a list of children game trees for tree, or #f if tree has no children.

— Procedure: nodes tree

Return a list of nodes (minimum is one) for tree.

— Procedure: get node prop

In node, return a list of all values for property prop. The list may be empty or it may contain several values.

— Procedure: get-one node prop

In node, return the value associated with the first occurance of prop.

— Procedure: analyze tree [prefix]

Display to the current output port a simple analysis of tree. (This is more for debugging support than anything serious.) Optional arg prefix specifies the number of spaces to insert at the beginning of the line, for recursive analysis of children trees.

sizzweb 1.12

 Usage: sizzweb -r DIR [options...]

   -p, --port=PORT     -- Listen on PORT [8001]; to specify a UNIX
                          domain socket, use "-p unix:FILENAME"
   -r, --docroot DIR   -- Specify DIR as filesystem root (required)
   -u, --ulibdir DIR   -- Look in DIR for servlets.scm [$HOME/.sizzweb.d]
   -d, --daemon FILE   -- Write pid and tcp port to FILE, go into background
   -l, --logfile FILE  -- Append logs to FILE [stdout if not --daemon]
       --funky         -- Don't use this unless you have read the source
   -b, --boredom N     -- Hang up after N inactive seconds (minimum 15)

 To stop sizzweb when invoked with -d FILE, use: kill -1 `head -1 FILE`
 (note the backticks).  To reload servlets.scm, use kill -2.

snap-iso 1.2

 Usage: snap-iso [OPTIONS] SPECFILE [SELECTION]

 Create an ISO9660 image file, using SELECTION from SPECFILE.  If not
 specified, SELECTION is taken to be "default".  Run two sizing passes,
 one with du(1) and one with genisoimage(1), before the actual creation.
 Options are:

  -o, --output FILE   -- write FILE (by default the filename has the
                         form BASE.SEL.iso, where BASE is the basename
                         of SPECFILE, and SEL is the selection name)
  -w, --warning-exit  -- cause genisoimage sizing pass warnings to result
                         in failureful exit (by default they are ignored)
  -m, --missing FILE  -- write "no such file" filenames signalled by the
                         du sizing pass to FILE
  -T, --tmpdir DIR    -- use DIR for staging and output
  -n, --noact         -- exit after sizing passes, leaving directory
                         BASE.SEL.snap-iso (see ‘-o’ for explanation)
  -q, --quiet         -- say (almost) nothing

 SPECFILE names a file containing "selections" that define directories
 and files to be included/excluded in the ISO image.  Directory- and
 file-names are written as Scheme symbols.  A selection has the form:

   (NAME COMPONENT ...)

 NAME is a keyword, such as "#:default".  COMPONENT may be another
 selection name (keyword), a relative directory- or file-name, or a
 vector of the form:

   #(PARENT #:except CHILD ...)

 PARENT is a directory name.  CHILD names a subdirectory or file in the
 PARENT directory; it cannot contain the slash (directory separator)
 character.  The keyword #:except is required syntax.

 The special name #:OMIT must be followed by absolute filenames.  These
 are ignored by the genisoimage sizing pass and the ISO-creation command,
 but not by the du sizing pass.

#!/bin/sh
exec strace -f -e open "$@" 2>&1 | sed /o.such.file/d

#!/bin/sh
exec strace -f -e open "$@" 2>&1

todo 1.1

 Usage: todo [OPTIONS] [PROJECT]

 Summarize of PROJECT's todo file.  PROJECT is a regular expression
 that may match one or more todo file names registered in the meta
 data file (see ‘--meta’ below).  If PROJECT is omitted, all projects
 are selected.

 Options are:
  -L, --list            -- display mtime and name of each todo file
                           regsitered and exit successfully
  -M, --meta FILE       -- use FILE for meta data [$HOME/.todo.list]
  -i, --involved [USER] -- select USER-involved items
  -p, --personal [USER] -- select USER-responsible items
  -t, --todo            -- select unfinished items (status "-")
  -d, --done            -- select finished items (status "+")
  -r, --review          -- select review items (marker "R")
  -w, --who             -- also show who is associated w/ the item
  -n, --no-parent       -- do not show parent chain

 The todo file format is a line-based outline where each heading
 is zero or more pairs of leading spaces followed by ‘-’ (hyphen).
 Something like:

 - a                  0
   - b                1
     - c              2
   - d                1
 - e                  0
   - f                1
     - g              2
   - h                1

 NOTE: Outlines that "skip" levels signal an error.
 In other words, this will fail:

 - a               0
   - b             1
       - c         3       <-- skipped 2 -- error!
   - d             1

— Procedure: make-text-outline-reader re [specs...]

Use txtoutline-reader (see zzz txtoutline) on re and specs and return a procedure that scans a file given its filename.

urxvt-setfont 1.1

 Usage: urxvt-setfont TTF-FONT-SPEC

 Set the (current) urxvt's font to TTF-FONT-SPEC.
 For example:
  urxvt-setfont "DejaVu Sans Mono-12"

 See also: urxvt(1), urxvt(7).

valid-ucs-p 1.0

 Usage: valid-ucs-p [--utf8] FILENAME...

 Check that each file in FILENAME... contains valid UCS data.
 Optional arg ‘--utf8’ means check only that the file contains
 valid UTF8 data (some of which may not be valid UCS).

 If there are no problems, exit successfully (and silently).
 Otherwise, display a message to stderr, one of:
   FILENAME:LNO:COL: KEY (HEX-BYTE-VALUE...)
 where HEX-BYTE-VALUE is a hexadecimal integer and KEY is
 one of: ‘invalid-utf8’, ‘invalid-ucs’; and exit failurefully.

— Procedure: scan!-proc skip-ucs-check?

Return a procedure p capable of reading from a port and checking for valid UCS data. If skip-ucs-check? is non-#f, check for valid UTF8 data only.

Procedure p may throw invalid-utf8 or invalid-ucs, with a single list argument: (bytes port lno col), where bytes is the list of offending bytes read from port at line number lno, column col.

— Procedure: check-ports skip-ucs-check? ports

Check each port in ports using the procedure p returned calling scan!-proc with arg skip-ucs-check?. ports may also be a single input-port.

If scanning results in invalid-utf8 or invalid-ucs errors, display the location of the error in the form:

          FILENAME:LNO:COL: KEY (HEX-BYTE-VALUE...)

where key is either invalid-utf8 or invalid-ucs, and hex-byte-value is a hexadecimal integer in the range [0,255]; then do (exit #f).

vcg-convert 1.1

 Usage: vcg-convert COMMAND [FILENAME]

 If COMMAND is ‘to-sexp’ then FILENAME is taken to be in vcg
 format; display its sexp format representation to stdout.
 This discards C++-style comments (ie, "/*...*/" and "//...").

 If COMMAND is ‘to-vcg’ then FILENAME is taken to be in sexp
 format; display its vcg format representation to stdout.

 If FILENAME is omitted or "-" (single hyphen), read from stdin.

 Presently, operation relies on the external program sed(1).
 This means to say that there is a hackish text transform going on
 in the background instead of ``proper'' parsing/unparsing, resulting
 in strange behavior for certain valid inputs.

wcat 1.4

 Usage: wcat [--headers | -h] [--zcat | -z] [URL ...]

 Cat out web arguments.  Modelled after wwwcat in the guile-www
 distribution, but distinctly better (supports --help and --version :-).

 Optional arg --headers (or -h for short) means use HEAD instead
 of GET, and output the header (no body) using the format:

   PROTOCOL/VERSION RESPONSE-CODE RESPONSE-MESSAGE
   HEADER-NAME: HEADER-VALUE
   ...

 Optional arg --zcat (or -z for short) means filter output
 through "gzip -d -c -f".

whirlpool-sum 2.1

 Usage: whirlpool-sum [ -c CHECKFILE | FILE... ]

 If given a list of filenames, for each FILE, display the digest
 (128 hex digits corresponding to 64 bytes) followed by two spaces
 followed by the filename and newline.  For example (backslash and
 newline added for readability):

 $ whirlpool-sum COPYING
 9e4bbb1ab48b0df77d0f5df1229a5c6314f0d65c4c96bcf7cbd870fd03\
 97036664eaea9c7318285f82ad7715473b1298c36735cebeb0a04d8a65\
 ad9b31106bd1  COPYING

 If given ‘-c CHECKFILE’, read CHECKFILE and check the sums of
 the files listed therein.  On mismatch, display the message
 "Whirlpool check failed for 'FILENAME'" to the stderr.

 The Whirlpool algorithm was developed by
   Paulo S. L. M. Barreto (pbarreto@scopus.com.br) and
   Vincent Rijmen (vincent.rijmen@cryptomathic.com).

 P.S.L.M. Barreto, V. Rijmen,
 ``The Whirlpool hashing function,''
 First NESSIE workshop, 2000 (tweaked version, 2003),
 http://www.larc.usp.br/~pbarreto/whirlpool.zip

 This program implements version 3.0 (2003.03.12) of the algorithm.

— Procedure: string-digest string

Compute the WHIRLPOOL digest of string. Return a vector of length 64, with each element a byte value (0–255), representing the digest.

— Procedure: file-digest filename

Return the string-digest of the contents of filename.

write-html-directory-index 1.9

 Usage: write-html-directory-index [options] [DIR ...]

 Write index.html in each DIR (or the current directory if none specified),
 incorporating: a hyperlinked listing of parent directories under docroot;
 a listing of files in the directory, including size, modification date,
 "file type" (e.g. "text/plain" or "application/x-tar"), and the filename
 hyperlinked; and the preformatted content of any README or LEGGIMI files
 in the directory.  Display "wrote: INDEX" for each index file written.
 The directory listing omits index.html and the README (or LEGGIMI) file.

 Several options change the bahavior (default values in square braces):

   -r, --docroot DIR   -- Use DIR as the root; the chain of parent dirs
                          stops there [/home/ttn/build/gnuvola]
   -o, --output FILE   -- Write index to FILE [index.html]
   -x, --exclude FILE  -- Also omit FILE from the listing;
                          this option can be given multiple times
   -l, --label FILE    -- Use contents of FILE (if found) instead of
                          README or LEGGIMI (completely replacing them);
                          this option can be given multiple times
   -q, --quiet         -- Don't say "wrote: INDEX"

 For -o, -x, and -l, signal error if FILE contains a directory component.

 Caveats:
 - Not tested w/ symlinked (sub)directories.
 - The order of specified labels has no bearing on which file is
   actually chosen, should there be more than one in the directory.

— Procedure: directory-index-tree ignored labels upath dir

Return a string-tree representing the directory listing for dir. ignored and labels are lists; upath and dir are strings, with or without trailing a slash. Normally, upath is part of dir, e.g.:

          UPATH:                        /software/ttn-do/
          DIR:   /home/ttn/build/gnuvola/software/ttn-do/

x-list-extensions 1.1

 Usage: x-list-extensions [--name-only] [--details]

 Write extension info to stdout in the format:

   OP EV ER  NAME

 where OP, EV, and ER are hexadecimal values (CARD8, 00 through ff)
 representing the extension's major opcode, first-event and first-error.
 If an extension is not "present", show "-- -- --" instead of OP, EV, ER.
 Likewise, if an extension has no allocated first-event or first-error,
 show "--" in its place.

 Optional arg ‘--name-only’ means omit OP, EV, ER info.
 Optional arg ‘--details’ means show version (and/or other info)
 if available, following the name, in parentheses.

xearth-mapdata-to-text-db-table 1.0

 Usage: xearth-mapdata-to-text-db-table [--no-body] MAPDATA

 Write to stdout a series of sexps suitable for reading using
 proc ‘read-text-db-table’, representing the data mined from
 MAPDATA, the mapdata.c file (from xearth-1.1 or similar).

 Option ‘--no-body’ (‘-n’ for short) means to stop output after
 displaying the header (text-db-table configuration) sexp.  For
 xearth-mapdata-to-text-db-table 1.0, this results in the output:

  (text-db-table-config
    (delim . "\n")
    (fields (type sexp) (init sexp) (path sexp)))

 The ‘type’ value is a keyword, either #:land or #:water.

 The ‘init’ value is a vector #(x y z) that indicates a point on the
 unit sphere (each of x, y, and z has been scaled by 30000), where the
 x axis points "to the right" (towards 0 N 90 E), the y axis points
 "up" (towards the north pole), and the z axis points "out of the
 screen" (towards 0 N 0 E).  This is the starting point of the curve.

 The ‘path’ value is a vector of triples #(dx dy dz); the #(x y z)
 triple for each successive point in the curve is obtained by adding
 #(dx dy dz) onto the previous #(x y z) values.

xlsatoms 1.0

 Usage: xlsatoms

 Display atoms from the X server, one per line.

xlsfonts 1.0

 Usage: xlsfonts [--unsorted | -u]

 Write all (up to 9999 in number) font names to stdout, one per line.
 Optional arg ‘-u’ means display unsorted.

xml2sexp 1.4

 Usage: xml2sexp [options] XMLFILE...

 Pretty-print contents of XMLFILE... to stdout.
 If XMLFILE is "-", read from standard input.
 If XMLFILE ends with ".gz", filter it through "gzip -dc" first.
 The contents are read as xml and written as a sexp.

 Options:
 -f, --name-format [FMT] -- do (simple-format cep FMT filename) and
                            (newline cep), where cep is the current
                            error port, prior to the normal output for
                            each XMLFILE; disabled if XMLFILE is "-"

 -w, --keep-whitespace   -- do NOT ignore ‘character-data’ nodes where
                            all characters are ‘char-whitespace?’

 -e, --empty STRING      -- suppress "XML_ERROR_NO_ELEMENTS" error
                            on empty files; display STRING followed
                            by newline, instead

 -x, --omit NODETYPE     -- ignore NODETYPE, one of:
                              character-data
                              comment
                            this option may be specified multiply

 -s, --sxml N            -- output SXML N normal form, where N
                            is one of 0, 1, 2, 3 (EXPERIMENTAL)

— Procedure: xml2sexp options port

Read XML from port and return a sexp.

options is an alist with symbolic keys keep-whitespace, empty, omit; these control behavior identically to the command-line options of the same name described above. The value for keep-whitespace is a boolean, whereas that for omit is a list of symbols.

xout 1.2

 Usage: xout [options] [args ...]

 Display ARGS (text) in an X window.  Options are:

 -f, --file FILENAME  -- Take first ARG to be a filename; display
                         its (text) contents.  If FILENAME is "-"
                         (a single hyphen), read from stdin.

     --font NAME      -- Use font NAME (default: "fixed").

 -U, --utf8           -- Decode text as UTF-8 (default: LATIN-1).

 Actually, the "default encoding LATIN-1" really means no decoding.
 Keyboard commands are:

  SPC            -- next page
  backspace      -- previous page
  i              -- speckle (uses GetImage/PutImage, may be slow)
  ESC, Q, C-q    -- quit

xprop 1.3

 Usage: xprop [options]

 Display properties from the X server root window, one per line.
 Options are:

      --id 0xWID       -- display window properties from WID, a
                          hex number, instead of the root window

 These types of property values are recognized:
 ATOM, CARDINAL, INTEGER, STRING, UTF8_STRING, WINDOW,
 WM_STATE, WM_HINTS, WM_SIZE_HINTS.

 Display values of unrecognized types as raw (uninterpreted) data,
 i.e., zero or more hex integers.  If the data has STRING format,
 then each string is represented as a list of hex integers.

 Usage: xprop [options] --jam PROPERTY TYPE VALUE

 In this case, don't display properties.  Instead, set PROPERTY
 (with TYPE) to VALUE on the server, then exit.  PROPERTY and TYPE
 are symbols or numbers, and VALUE is a Scheme expression, such as a
 string or a uniform vector.  Here are some command-line examples:

  $ ... --jam WM_CLIENT_MACHINE STRING '"foo-bar-baz"'
  $ ... --jam WM_CLIENT_LEADER WINDOW '#u(#x400013)'

 Note that double quotes are required for a Scheme string; the
 single quotes are for the shell.

 Usage: xprop [options] --zonk PROPERTY...

 In this case, don't display properties.  Instead, delete each
 specified PROPERTY (a symbol or integer) on the server, then exit.

— Scheme Procedure: getsid pid

Return the session id associated with pid.

— Scheme Procedure: gethostname

Return the host name as a string, or #f if there were problems.

— Scheme Procedure: sendfile outfd infd offset count

Call sendfile(2) with args outfd, infd, offset and count, all non-negative integers. Return the number of bytes actually written.

— Scheme Procedure: sendfile/never-fewer outfd infd offset count

Call sendfile(2) with args outfd, infd, offset and count, all non-negative integers. Loop until all bytes are sent (or error).

— Scheme Procedure: iovec sequence [opts...]

Return an iovec derived from sequence, a list or vector. This object is suitable for passing to readv and writev. Each element of sequence must be either a uniform vector with one of the prototypes: #\a (string), #\nul (byte vector), s (short int), -1 (long int), 1 (unsigned long int), l (long long int); or one of the following forms, where uve is a suitable uniform vector previously described:

(uve start)

Select elements of uve from index start to the end of uve.

(uve start stop)

Select elements of uve from index start up to but not including index stop.

(uve start . count)

Select count elements of uve from index start.

opts are alterating keywords and values:

#:start s-idx

#:end e-idx

Use elements in the range s-idx (inclusive) to e-idx (exclusive) of sequence for the iovec. It is an error for e-idx to be less than s-idx.

#:oneshot bool

If bool is non-#f, the iovec is marked as oneshot.

A oneshot iovec cannot be re-used; after the i/o operation (readv or writev) finishes processing all the elements, subsequent calls do nothing and simply return #f.

For a non-oneshot iovec, on the other hand, after the i/o operation finishes (and returns #f), the internal index is reset to zero so that subsequent calls proceed from the beginning, normally.

The default (if #:oneshot is unspecified) is to construct a oneshot iovec.

— Scheme Procedure: readv fdes iovec [count]

Read from fdes data specified by iovec using readv(2). Return number of bytes successfully read, or #f if there is no more space to read into. If the underlying system call returns -1, signal error. Update the starting position of iovec by side-effect. Optional arg count specifies how many elements of iovec to process (default is “remaining count”).

— Scheme Procedure: writev fdes iovec [count]

Write to fdes data specified by iovec using writev(2). Return number of bytes successfully written, or #f if there is nothing more to be written. If the underlying system call returns -1, signal error. Update the starting position of iovec by side-effect. Optional arg count specifies how many elements of iovec to process (default is “remaining count”).

— Scheme Procedure: flock/exclusive fdes [nblockp]

Call flock(2) on fdes, with operation LOCK_EX.

— Scheme Procedure: flock/shared fdes [nblockp]

Call flock(2) on fdes, with operation LOCK_SH.

— Scheme Procedure: flock/unlock fdes [nblockp]

Call flock(2) on fdes, with operation LOCK_UN.

— Scheme Procedure: getopt-long args grammar

Parse the command line given in args (which must be a list of strings) according to the option specification grammar.

The grammar argument is expected to be a list of this form:

((option (property value) ...) ...)

where each option is a symbol denoting the long option, but without the two leading dashes (e.g. version if the option is called --version).

For each option, there may be list of arbitrarily many property/value pairs. The order of the pairs is not important, but every property may only appear once in the property list. The following table lists the possible properties:

(single-char char)

Accept -char as a single-character equivalent to --option. This is how to specify traditional Unix-style flags.

(required? bool)

If bool is true, the option is required. getopt-long will raise an error if it is not found in args.

(value bool)

If bool is #t, the option accepts a value; if it is #f, it does not; and if it is the symbol optional, the option may appear in args with or without a value.

(merge-multiple? bool)

If bool is #t and the value property is not #f, all (one or multiple) occurrances are merged into a list with order retained. If #f, each instance of the option results in a separate entry in the resulting alist.

(predicate func)

If the option accepts a value (i.e. you specified (value #t) for this option), then getopt-long will apply func to the value, and throw an exception if it returns #f. func should be a procedure which accepts a string and returns a boolean value; you may need to use quasiquotes to get it into grammar.

— Scheme Procedure: option-ref options key default

Search options for a command line option named key and return its value, if found. If the option has no value, but was given, return #t. If the option was not given, return default. options must be the result of a call to getopt-long.

— Scheme Procedure: check-hv args config [flags...]

Check args (list of strings) for second element being ‘--help’ or ‘--version’. If found, display the respective information, using config, to stdout and then exit successfully. If not found, return #f. The recognized config keys are:

package

A string describing program affiliation (for ‘--version’).

version

A string to use instead of the default "VERSION UNKNOWN". Output, depending on whether or not package is specified, is:

               PROGRAM (PACKAGE) VERSION
               PROGRAM VERSION

where program is (basename (car args)).

help

Either a (typically multi-line) string, a thunk that produces a string, or the symbol commentary, which means use file-commentary from module (ice-9 documentation) to obtain the string.

All strings are trimmed of leading and trailing whitespace.

Lastly, flags are zero or more symbols that further change the default behavior:

• no-exit means don't exit; instead, after doing output return #t.
• v-before means for ‘--help’, first do the output for --version.

— Scheme Procedure: qop<-args args option-spec

Do (getopt-long args option-spec), and return a procedure qop that encapsulates the result. You can then call qop in various ways:

(qop #t)

Return the raw result of the getopt-long call.

(qop key)

Return the value associated with key, or #f.

As a special case, if key is the empty list, then return the (possibly empty) list of strings comprising the non-option args. Note that getopt-long stops processing args if it sees ‘--’ (hyphen, hyphen); all elements following it are considered non-option.

(qop key proc)

If key has an associated value, call proc with the value and return its result. Otherwise, return #f. This is a shorthand for (and=> (qop key) proc).

— Scheme Procedure: qop<-alist alist

Return a procedure qop that encapsulates alist, an association list with eq?-comparable keys. This is like qop<-args, except that (qop #t) simply returns alist.

— Scheme Syntax: whatever [body...]

Evaluate body. The value is explicitly “unspecified”.

— Scheme Syntax: FE ls1 [... lsN] proc

Basically: (for-each proc ls1 ... lsN)
proc is an n-ary procedure, where n is the number of lists.

— Scheme Syntax: HFE k v ht) body[...]

Expand to hash-for-each like so:

          (HFE (k v ht) foo...)
          ⇒
          (hash-for-each (lambda (k v) foo...) ht)

— Scheme Syntax: condition-case var bodyform [handlers...]

Execute bodyform and return its value if no error happens. Each element of handlers looks like (condition-name body) where the body is one or more Scheme expressions.

A handler is applicable to an error if condition-name is one of the error's condition names. If an error happens, run the first applicable handler.

The car of a handler may be a list of condition names instead of a single condition name. Then it handles all of them. As a special case, for the last handler specified in handlers, the car may also be the symbol else, which matches any condition name.

Note that unlike the Emacs Lisp condition-case (from which the Scheme design and documentation draw grateful inspiration), var must be specified (it cannot be #f).

When a handler handles an error, control returns to the condition-case and it executes the handler's body with var bound to (signaled-condition . signal-data) from the error, returning the value of the last body form.

— Scheme Procedure: fs s [args...]

Apply simple-format to format string s and args. Return a string.

— Scheme Procedure: fso s [args...]

Apply simple-format to format string s and args. Send the result to the current output port.

— Scheme Procedure: fse s [args...]

Apply simple-format to format string s and args. Send the result to the current error port.

— Scheme Procedure: make-fso port

Return a procedure that acts like fso for port.

     (let loop ((item (get)) (acc '()))
       (if (finished? item)
           (reverse! acc)
           (loop (get) (cons item acc))))

     (let ((acc (accumulator)))
       (let loop ((item (get)))
         (or (finished? item)
             (begin (acc item) (loop (get)))))
       (acc))

— Scheme Procedure: accumulator

Return an accumulator.

— Scheme Procedure: forms<-port port

Return a list of forms read from port.

— Scheme Procedure: safe-rewind port

Flush port (with force-output) if an output port, then seek to its initial position (zero). Return port.

— Scheme Procedure: temporary-file-port

Return a new read/write temporary file port, i.e., one backed by the filesystem, and automatically deleted on process exit.

— Scheme Procedure: directory-vicinity directory

Return a procedure p that returns, given filename, a string constructed from appending directory and filename, adding an intervening #\/ (slash) if directory does not end with one.

          (map (directory-vicinity "foo")
               '("bar" "baz" "/qux"))
          ⇒ ("foo/bar" "foo/baz" "foo//qux")
          
          (map (directory-vicinity "dir/")
               '("a" "/b"))
          ⇒ ("dir/a" "dir//b")

NB: If filename is absolute, the result has two slashes.

— Scheme Procedure: dir-exists? name

Return #t iff directory name exists.

— Scheme Procedure: mkdir-p dir

Create a directory dir, as well as any missing parent dirs.

— Scheme Procedure: directory-files dir

Return list of file names in directory dir.

— Scheme Procedure: filtered-files filter dir

Apply filter to filenames in dir; return list of non-#f values. filter is a procedure applied to each file name – it should return #f if that file name is to be omitted from the overall list, or a value to be collected. The file name list is not sorted.

— Scheme Procedure: filtered-files-in-vicinity dir filter [options...]

In dir, apply filter to each file name; return list of non-#f values. filter is a procedure applied to to each filename – it should return #f if that file name is to be omitted from the overall list. Otherwise, its return value can be a string, or #t which is synonymous with the filename with the dir prefixed. The file name list is not sorted. options are zero or more keywords that modify the behavior:

#:filter-prefixed

Pass to filter each file with dir already prefixed.

#:collect-nodir

For the case when filter returns #t, collect the filename without the dir prefix.

NB: The argument order is opposite that of filtered-files.

— Scheme Procedure: not-dot-not-dotdot file

Return #f if file is "." or "..", otherwise return file. The directory component (prefix up to and including the /, if any) is ignored.

— Scheme Procedure: extract-stem-proc ext [transform]

Return a procedure that filters based on ext, a string. The procedure takes a filename and if it ends in .EXT (note dot), returns the portion of the filename before the dot, otherwise #f. Optional arg transform controls precisely how the returned filename is to be processed. If transform is omitted or #f, the extension is discarded. If it is #t, the extension is left alone. If it is a string, the stem is concatenated with it. If it is a procedure, that procedure is applied to the stem, and it's return value, which need not be a string, is collected.

— Scheme Procedure: filename-sans-end-sep-proc sep-char

Take sep-char and return a procedure that, given filename, returns a copy of it w/o the ending sep-char.

— Scheme Procedure: file-newer-than-file? file1 file2

Return #t if file file1 is newer than file file2. If file1 does not exist, the answer is #f; otherwise, if file2 does not exist, the answer is #t.

— Scheme Syntax: save-cwd [body...]

Evaluate body and restore the original cwd afterward. It is an error to specify a null body.

— Scheme Syntax: with-cwd dir [body...]

Change directory to dir, evaluate body and restore cwd. Return what body returns. It is an error to specify a null body.

— Scheme Procedure: filename-absolute-or-in-vicinity name dir

If name begins with "/", return it. Otherwise, return a new string composed by taking name in vicinity of dir.

— Scheme Procedure: filename-sans-end-slash name

Return name, a string, stripping the terminating "/" character. If there is no "/", just return name.

— Scheme Procedure: filename-components string

Return a list of filename components parsed from string. Components are delimited by "/", which is discarded. Null string components are also discarded.

— Scheme Procedure: filename-components-append ls

Return a string composed by prefixing each element of ls with "/".

— Scheme Procedure: expand-file-name name [default-directory]

Convert filename name to absolute, and canonicalize it. Second arg default-directory is directory to start with if name is relative (does not start with slash); if default-directory is #f or missing, (getcwd) is used. File name components that are . are removed, and so are file name components followed by .., along with the .. itself; note that these simplifications are done without checking the resulting file names in the file system. An initial ~/ expands to your home directory. An initial ~USER/ expands to USER's home directory.

— Scheme Procedure: reset-tilde-cache! [size]

Reset the cache expand-file-name uses for the results of expanding ~ and ~USER. Optional arg size specifies the hash table bucket count to use (default is 7).

— Scheme Procedure: substitute-env-vars string

Substitute environment variables referred to in string. $FOO where FOO is an environment variable name means to substitute the value of that variable. The variable name should be terminated with a character not a letter, digit or underscore; otherwise, enclose the entire variable name in braces. For instance, in ab$cd-x, $cd is treated as an environment variable.

Use $$ to insert a single dollar sign.

— Scheme Procedure: expand-file-name-substituting-env-vars name [default-directory]

Substitute env vars in string then expand it as a filename. See substitute-env-vars and expand-file-name.

— Scheme Procedure: grep re strings [flags...]

Return list of matches to regexp re from strings list. Optional flags are keywords (or symbols with the same name) which modify regexp matching:

#:invert

the result list is those strings that do NOT match

#:fold-case

consider upper and lower case to be identical

#:count

return length of result list instead of list

#:literal

re specifies a literal string to match

Return list order is the same as in the input list.

— Scheme Procedure: grep-matches re strings [flags...]

Return non-#f match results of regexp-exec of regexp re on strings list. Optional flags are keywords (or symbols with the same name) which modify regexp matching:

#:invert

the result list is composed entirely of #t values, with length equal to the number of strings that do NOT match (useful with count flag below)

#:fold-case

consider upper and lower case to be identical

#:count

return length of result list instead of list

#:literal

re specifies a literal string to match

Return list order is the same as in the input list.

— Scheme Procedure: grep-l re files

Search for regular expression re in files. Return a list of those that match. re specifies a regular expression that matches on one line (multi-line results not currently supported). files is a list, each element of which can either be a filename or a seekable port. In the returned list, if the element is a port, its read offset is left at the beginning of the line of the first match.

— Scheme Procedure: flatten tree [out]

Walk tree depth-first, displaying elements if they are strings. Signal "bad type" error for non-string, non-list elements. Optional second arg out is a procedure to use instead of display.

— Scheme Procedure: flatten-to port tree

Flatten to port (using flatten) the tree, a nested list of strings. If port is #f return a string, instead.

— Scheme Procedure: spew-html! html-data outfile [log]

Flatten the tree html-data into file named outfile. However, if outfile exists and the result is not different, then avoid modifying outfile, i.e., preserve its modification time. If outfile is newly written, set its mode to #o644.

Optional arg log is a procedure that takes a string, one of "outfile unchanged" or "wrote outfile".

— Scheme Procedure: update-page! template-file outfile [log]

“Load” template-file (evaluating it in the “current module”), and pass it as the html-data arg, along with outfile and log, to spew-html!.

— Scheme Procedure: update-all-html-data-pages! pages

For each filename in the list pages, do update-page! on it with the template file named filename-data. For example, specifying ("index.html" "foo-bar-baz") processes index.html-data to create index.html, and foo-bar-baz-data to create foo-bar-baz.

— String: :DQ

The double-quote character #\", as a string.

— String: :LF

The newline character #\newline, as a string.

— String: :NULL

The null string, "".

— Scheme Procedure: symbol<-kw/sym keyword-or-symbol

Return keyword-or-symbol as a symbol.

— Scheme Procedure: string<-kw/sym keyword-or-symbol

Return keyword-or-symbol as a string.

— Scheme Procedure: peel list

Scan list of the form:

          ([attr-name attr-value ...] [body...])

Each attr-name is either a keyword or a symbol. Each attr-value is either a string, a (possibly) nested list of strings, a symbol or a number. When there are no more attribute names, the rest of the list (which may be null) is taken as the body.

Return a pair whose car is the attributes, formatted (in a tree) as NAME="VALUE"; and whose cdr is the body.

— Scheme Procedure: expand elem [keyword value...]

          Keywords: xbsc, neck, prep-body,
          no-end-tag-if-null-body?, end-tag, tail

Return a proc p that expands into a tree based on elem. Precisely, p partitions its arglist with peel into attributes and body and returns the tree:

          ("<" elem attributes [" /"] ">"
           [neck]
           [body ["</" elem ">"]]
           [tail])

Other args are keywords. Here is a list (with default value):

#:xbsc #f

Non-#f means “XMLish (blech) start close”, i.e., the start tag should be rendered as ‘<ELEM />’ instead of of ‘<ELEM>’ (with space and slash before closing angle bracket). Typically, this is specified in conjunction with #:end-tag :NULL.

#:neck :NULL

This is inserted between the initial tag and is not subjected to prep-body. Typically :LF when specified.

#:prep-body #f

This can be a procedure that is passed body and returns a transformed tree. It can also be a a pair whose car is the symbol map and whose cdr is a procedure taking one arg. The effective body is computed by mapping this procedure over all the top-level elements of body.

#:no-end-tag-if-null-body? #f

Non-#f specifies that if body is the empty list, the ‘</ELEM>’ end tag should be omitted entirely.

#:end-tag #f

Specifies an alternative end tag.

#:tail :NULL

A value to be appended at the very end of the tree. Typically :LF when specified.

— Scheme Procedure: list<- arg

If arg is already a list, return it. Otherwise return (list arg).

— Scheme Procedure: css-tree rule

Return a tree made from expanding CSS rule, a list of the form:

          (target [property value...])

In this form, target can be a string or a flat list of strings; property can be a string, symbol, or keyword, and value can be a string or a nested list of strings.

— Scheme Procedure: YYYY

Return current year, as a string.

— Scheme Procedure: copyright [prefix...]

Return tree with optional prefix:

          ("Copyright (C) " prefix YEAR " Thien-Thi Nguyen")

— Scheme Procedure: copyright-since year

Call copyright, specifying as prefix the range of years beginning with year, if that is not the current year. If it is the current year, specify no prefix.

— Scheme Procedure: smhdwy diff [sep]

Return a tree describing the time duration diff (number of seconds). Blocks are (suffix, name, max value, number of seconds):

s	seconds	59	1, (*)
m	minutes	59	60, (* 60)
h	hours	23	3600, (* 60 60)
d	days	90	86400, (* 60 60 24)
w	weeks	104	604800, (* 60 60 24 7)
y	years	(none)	31536000, (* 60 60 24 365)

Note that the number of seconds for years is approximate. If diff is negative, the tree begins with "-". Optional arg sep (a string) means to recurse on the remainder of the time, inserting sep between each block. Some examples:

          (flatten (smhdwy 12313)) ⇒ "3h"
          (flatten (smhdwy -341231343)) ⇒ "-10y"
          (flatten (smhdwy -3412314 ",")) ⇒ "-39d,11h,51m,54s"

— Scheme Procedure: daemonize rest play pidfile [etc...]

If pidfile is non-#f, check that it (filename) does not exist, and that its directory is writeable. Signal "already exists" or "directory not writeable", respectively, otherwise. Then, do a primitive-fork.

For parent:

• If pidfile is non-#f, write child pid and elements of etc to pidfile, one element per line.
• Call rest with one arg, the child pid. Return what rest returns.

For child:

• Set the session id with setsid.
• Close i/o ports, as determined by current-input-port, current-output-port and current-error-port.
• Construct a proc bye like so:

                 (lambda ignored
                   (and (file-exists? pidfile)
                        (delete-file pidfile))
                   (raise SIGKILL))
  

• Do (sigaction SIGTERM bye).
• Call proc play with one arg, proc bye. Return what play returns.

— Scheme Procedure: txtoutline-reader re specs

Return a proc that reads from port and returns a list of trees. Scanning recognizes an outline format where each heading is zero or more pairs of leading spaces followed by ‘-’ (hyphen). Something like:

          - a                  0
            - b                1
              - c              2
            - d                1
          - e                  0
            - f                1
              - g              2
            - h                1

In this example the levels are shown to the right. The result for such a file would be the form:

(("a" ("b" "c") "d") ("e" ("f" "g") "h"))

Basically, anything at the beginning of a list is a parent, and the remaining elements of that list are its children. NOTE: Outlines that “skip” levels signal an error. In other words, this will fail:

          - a               0
            - b             1
                - c         3       <-- skipped 2 -- error!
            - d             1

re is a regular expression (string) that is used to identify a header line of the outline, as opposed to a whitespace line or intervening text. re must begin w/ a sub-expression to match the level prefix of the line. You can use level-submatch-number in specs (explained below) to specify a number other than 1, the default.

Normally, the level of the line is taken directly as the length of its level prefix. This often results in adjacent levels not mapping to adjacent numbers, which confuses the tree-building portion of the program, which expects top-level to be 0, first sub-level to be 1, etc. You can use level-substring-divisor or compute-level in specs to specify a constant scaling factor or specify a completely alternative procedure, respectively.

specs is an alist which may contain the following key/value pairs:

          - level-submatch-number number
          - level-substring-divisor number
          - compute-level proc
          - body-submatch-number number
          - extra-fields ((field-1 . submatch-1)
                          (field-2 . submatch-2) ...)
          - more-lines? bool

The proc value associated with key compute-level should take a Scheme match structure (as returned by regexp-exec) and return a number, the normalized level for that line. If this is specified, it takes precedence over other level-computation methods.

Use body-submatch-number if re specifies the whole body, or if you want to make use of the extra fields parsing. The extra-fields value is a sub-alist, whose keys name additional fields that are to be recognized. These fields along with level are set as object properties of the final string (the body) that is consed into the tree. If a field name ends in ‘?’ (question mark) the field value is set to be #t if there is a match and the result is not an empty string, and #f otherwise.

Normally, only header lines are considered. Use more-lines? with a non-#f value to specify that non-header lines be included as well. The structure of the output will be the same, however headers that are not immediately followed by another will result in strings with embedded (and possibly trailing) newline characters.

— Scheme Procedure: shell-quote-argument arg

Quote arg for passing as argument to an inferior shell.

— Scheme Procedure: args->normalized-list [args...]

For args, trim surrounding whitespace, join together separated by space, then split apart on space boundaries. For example:

          (args->normalized-list "rsync a b c"
                                 " d "
                                 "e"
                                 "f g h")
          ⇒ ("rsync" "a" "b" "c" "d" "e" "f" "g" "h")

— Scheme Procedure: call-process program [keyword value...]

          Keywords: inp, outp, errp, norm, args

Call program synchronously in separate process. Unless given #:outp 0, wait for program to terminate and return a numeric exit status.

#:inp (current-input-port)

Input port. #f means /dev/null.

#:outp (current-output-port)

Output port. #f means discard output; 0 (zero) means discard, don't wait for program to terminate, and return #f.

#:errp (current-error-port)

Error output port. #f means discard output.

#:norm #f

Non-#f means program and args should be passed through args->normalized-list.

#:args ()

List of additional args to pass to program.

— Scheme Procedure: call-process->buffers program [keyword value...]

          Keywords: inb, outb, errb, norm, args

Call program synchronously in separate process. Return a numeric exit status. Keywords are:

#:inb #f

Input buffer.

#:outb #f

Output buffer

#:errb #f

Error output buffer.

#:norm #f

Non-#f means that program and args should be passed through args->normalized-list.

#:args ()

List of additional args to pass to program.

— Scheme Procedure: make-buffered-caller program [keyword value...]

          Keywords: inb, args

Return a procedure capable of calling program. When called, the program stdout and stderr are captured to buffers. The key #:inb (default #f) specifies an input buffer to use for the call. The key #:args (default the empty list) specifies additional args to pass.

The returned procedure takes one of the following commands (either a keyword or similarly-named symbol):

#:redefine NEW-DEF

Redefine the called program and its args. new-def is one or more strings.

#:execute

Call program, clearing buffers first. Return raw exit status of the program. See status:exit-val for more info.

#:execute/no-init

Same as #:execute, but do not clear buffers first.

#:outbuf

Return output buffer object.

#:outbuf-string

Return output buffer as a string.

#:outbuf-lines

Return output buffer as a list of strings.

#:errbuf

Return error output buffer.

#:errbuf-string

Return error output buffer as a string.

#:errbuf-lines

Return error output buffer as a list of strings.

#:exit-val

Return exit status from the last execution. Signal an error if #:execute (or #:execute/no-init) command has not yet been issued since closure creation or most recent #:redefine.

The #:outbuf-lines and #:errbuf-lines commands use newline to separate.

— Scheme Procedure: shell-command->string cmd

Run shell command cmd and return its output as a string.

— Scheme Procedure: fshell-command->string s [args...]

Like shell-command->string, with the command formed by applying simple-format to s and args.

— Scheme Procedure: shell-command->list cmd [handle-delim...]

Run shell command cmd and return its output as a list of strings.

— Scheme Procedure: port-lines port [handle-delim...]

Return a list of strings, representing the lines read from port.

— Scheme Procedure: file-lines filename [handle-delim...]

Return a list of strings, representing the lines found in filename.

— Scheme Procedure: system* [args...]

Echo args to make a string and pass it to system.

— Scheme Procedure: sysfmt [args...]

Apply simple-format to args and pass to system. The car of args is the format string.

— Scheme Procedure: find-program name

Search env var PATH for executable program name. If found, return the absolute name, otherwise #f.

— Scheme Procedure: cluster-mangler who root [tweaks]

Return a procedure p that manages the cluster at/under root, an absolute directory name. p accepts a single arg, command, a symbol. All commands return non-#f if successful. Optional arg tweaks is for command make-cluster, described below. Recognized commands (keywords ok, too):

make-cluster

If the directory root does not exist, create the cluster with encoding UNICODE via external command initdb under root and modify two files therein:

pg_hba.conf

Set the contents to local all login trust, where login is for the current user, per (getpwuid (getuid)).

postgresql.conf

Set option listen_addresses (if present) to nothing, and the option unix_socket_directory to root. If tweaks is specified, it should be a list of spec forms (option . value) where option is a symbol and value is a string, to set additionally. Normally, if option is not found in the file, it is ignored. You can force it to be added at the end, however, by using the form (#t spec), that is, consing a #t onto a normal spec form.

The overall effect of these changes is to disable network access and allow only (albeit further unrestricted) Unix-domain access.

daemon-up

First, make sure the cluster exists (via make-cluster). If creation fails signal “make-cluster FAILED” error. Then, if the daemon is not up, start it (like pg_ctl start), specifying root/log as the log file, and attempt (up to five times) to connect to database template1. If all attempts fail, display a message to the current error port and return #f.

daemon-down

If the daemon is up, bring it down (like pg_ctl stop).

drop-cluster

First, make sure the daemon is down. If the daemon cannot be taken down, signal “daemon-down FAILED” error. Then, delete root and all files under it.

tweaker

This command does not do anything; instead, it returns a procedure p that takes one arg, tweaks, a list of spec forms as described in make-cluster, above. Procedure p actually does the work of modifying postgresql.conf (and saving it). Why have two ways of doing the same thing? Good question.

Other commands signal “bad command” error. Argument who is either #f to specify silent operation, or a short string to be used for certain progress messages.

      ((DB-1 (TABLE DEF ...) (TABLE DEF ...) ...)
       (DB-2 (TABLE DEF ...) (TABLE DEF ...) ...) ...)

— Scheme Procedure: get-meta-file

Return the meta-file filename.

— Scheme Procedure: set-meta-file! filename

Set the meta-file to be filename.

— Scheme Procedure: personal-pgtable-all

Return a list of all the definitions described in the meta-file.

— Scheme Procedure: personal-pgtable-defs db table

Return the definitions for database db, table table.

— Scheme Procedure: personal-pgtable-manager db table

Return a “pgtable manager” procedure (see Single-Table Abstraction) for database db, table table.

— Scheme Procedure: personal-pgtable-worker db table

Return a “pgtable worker” procedure (see Single-Table Abstraction) for database db, table table.

       (text-db-table-config
         (meta . META)            ; optional; META is opaque, default #f
         (delim . "\f")
         (fields (NAME1 TYPE1)
                 (NAME2 TYPE2)
                 ...))

— Scheme Procedure: read-text-db-table filename/port [flags...]

Read a text-db-table from filename/port, return a list of records. Each record is an alist whose keys are the field names, in order. filename/port can be a filename (string), or an input port. In the latter case, it is left open when done.

As a side effect, the property text-db-table-meta (procedure with setter) for the returned list is set to the table's metadata, if any.

flags is a list of zero or more keywords that change the default behavior. These are the recognized flags:

#:list

Return each record as a list instead of as an alist.

#:closure

Return each record as a closure (procedure) that accepts one arg sel. If #:list is specified, sel is a 0-based integer to index into the record's data. Otherwise, sel names a field in the record's data.

— Scheme Procedure: -connect [server]

Connect to the X server. If server is omitted, use the value of the env var DISPLAY.

If there are problems, display a reason to the current error port and return #f. Otherwise, return a connection object, a vector of the form:

          #(PORT SETUP EXTENSIONS)

port is the socket used for low-level communication. Accessing it directly is probably a good way to screw things up; You Have Been Warned! setup is an alist detailing server specifics. extensions is a list of extensions (each a symbol) available on the server.

The env var XAUTHORITY names a file to be read for authorization records. Presently, this has only been tested with auth type MIT-MAGIC-COOKIE-1.

— Scheme Procedure: -disconnect conn

Disconnect from conn. Using conn afterwards is an error.

— Scheme Procedure: -synchronous-request-proc conn [opts...]

Return a procedure that can do a synchronous request on conn. Normally, the procedure takes two arguments, name and alist. These specify a request, such as PolySegment (a symbol); and the data to fill in the fields of that request.

Some fields cannot be specified (including them in alist is an error), while others are computed automatically. The rest default to 0 (zero).

If the request has no expected reply, the procedure returns #f. Otherwise, it awaits the reply and returns it as an alist.

opts are symbols that configure the procedure.

plist-input

Specifies that the procedure should take a list of alternating symbols and values (a plist) as the second arg.

keyword-style

Specifies that the procedure should take any number of args after the name, as alternating keywords and values.

A value may be an integer, or a vector of sub-alists (or plists, or kwlists, as appropriate).

— Scheme Procedure: -simple-io-manager conn [opts...]

Return a procedure that manages (simply) i/o on conn. See -synchronous-request-proc for documentation on opts.

The returned procedure has the signature (one . rest); behavior is controlled by the first arg one, with rest having subsequent meanings. Here is a table:

#:gobble!

Check conn and read pending input onto the read queue. Return #t if the read queue is non-empty (which may be the case from prior operations).

#:flush!

Send the contents of the write queue to conn.

#:set-stale-rdq-window-size! n

By default, the read queue maintains a two-entry window for handling “stale” messages from the server. If you see the ‘unexpected answer’ error, it means the server has sent a message whose serial id has passed beyond stale (to “forgotton”). In that case, try increasing the window size with this command.

#:set-error-handler! handler

By default, spurious errors, i.e., those not or no-longer associated with a request, are displayed to stderr and the program exits failurefully.

This specifies instead that handler, a procedure, should be called with one argument, an alist of error details, including (but not limited to) keys %id, %current-serial and %error-name. The difference in values of the first two gives you an idea of how far back in the protocol stream the error happened.

If handler is #f, revert to default behavior.

#:set-external-event-queue! handler

Initially, events are added to an internal queue (DWR: without bound!). This sends them, one by one, to handler, and arranges for handler to receive future events. handler can be a queue object (satisfying (ice-9 q) q?); a procedure that takes one argument; or #f to resume internal queuing.

request data[...]

Add to the write queue the request (a symbol) with fields specified by data. Return a cookie that identifies the request. See -synchronous-request-proc for documentation on the data format.

cookie

Wait until a reply (or error) associated with cookie is available and return it (FIXME: there may be multiple errors, but this only returns the first error or reply).

— Scheme Procedure: -x x tree

Return x (-: which marks the spot :-) from the alist tree. x can take many forms:

()

Return tree.

symbol

Return (assq-ref tree x).

integer

Return (vector-ref tree x).

list

Use (car x) to extract a subtree and recurse on it with (cdr x). For example:

               (define CONN (-connect))
               (define SETUP (vector-ref CONN 1))
               (-x '(roots 0 width-in-pixels) SETUP) ⇒ 1280

— Scheme Procedure: -internal-data name

Return direct access to internal data structure table (a symbol). These should be treated as read-only, and best avoided unless you don't mind having to dig into the source a bit. Valid tables are:

ENUMS

Hash table mapping symbols to alists. The alist in turn maps symbols to integers.

MASKS

Hash table mapping struct names to alists. The alist in turn maps field names to enum names (both symbols).

ERRORS

Hash table mapping error names to error codes (integers).

EVENTS

Hash table mapping event names to opcodes (integers).

REQUESTS

Hash table mapping request names to opcodes (integers).

Note that struct, event and request names may be a simple symbol such as SCREEN; or a list of symbols, such as (Composite RedirectSubwindows req). Also, for every request there may be up to two structs, one whose name ends with req, and (possibly) one with ans.

Use hash-ref for hash tables.

— Scheme Procedure: -wire<-event type alist

Return a new 32-byte string made by packing event type (a symbol) data alist, suitable for the value of the event field in a SendEvent protocol request.

If alist contains keys that do not correspond to fields in the event type, signal "invalid alist fields" error.

As a special case, if type is ClientMessage and an alist key is /client-message-data, the associated value should be a list of integers in the format specified in the format field:

          
format 
max list length 
valid value range
          
8 
20 
[0,#xff]
          
16 
10 
[0,#xffff]
          
32 
5 
[0,#xffffffff]
          

If the format is not recognized, or if the list of numbers is too long, signal error.

— Scheme Procedure: -event-type event

Return the type (a symbol) of event. This uses the EventMask enum.

— Scheme Procedure: -event-synthetic? event

Return #f if event originated from the server, or #t if it was generated due to a SendEvent request.

— Scheme Procedure: -event-data event

Return the event data, an alist.

     (define +ENUMS+ (-internal-data 'ENUMS))
     
     (define +gravity+ (hash-ref +ENUMS+ 'Gravity))
     (assq-ref +gravity+ 'Center) ⇒ 5
     
     (define +z+ (hash-ref +ENUMS+ '(XTEST Cursor)))
     +z+ ⇒ ((None . 0) (Current . 1))

AccessControl                 QueryShapeOf
Allow                         ScreenSaver
ArcMode                       SendEventDest
AutoRepeatMode                SetMode
BackPixmap                    StackMode
BackingStore                  SubwindowMode
Blanking                      Visibility
ButtonIndex                   VisualClass
ButtonMask                    WindowClass
CW                            (Composite Redirect)
CapStyle                      (DAMAGE ReportLevel)
Circulate                     (GLX GC)
ClipOrdering                  (GLX PBCDT)
CloseDown                     (GLX PBCET)
ColorFlag                     (GLX RM)
ColormapAlloc                 (MIT-SCREEN-SAVER Event)
ColormapState                 (MIT-SCREEN-SAVER Kind)
ConfigWindow                  (MIT-SCREEN-SAVER State)
CoordMode                     (RANDR Rotation)
EventMask                     (RANDR SM)
Exposures                     (RANDR SetConfig)
Family                        (RECORD CS)
FillRule                      (RECORD HType)
FillStyle                     (RENDER CP)
FontDraw                      (RENDER PictOp)
GC                            (RENDER PictType)
GX                            (RENDER PolyEdge)
GetPropertyType               (RENDER PolyMode)
Grab                          (RENDER Repeat)
GrabMode                      (RENDER SubPixel)
GrabStatus                    (SHAPE SK)
Gravity                       (SHAPE SO)
HostMode                      (SYNC ALARMSTATE)
ImageFormat                   (SYNC CA)
ImageOrder                    (SYNC TESTTYPE)
InputFocus                    (SYNC VALUETYPE)
JoinStyle                     (XEVIE Datatype)
KB                            (XFIXES CursorNotify)
Kill                          (XFIXES CursorNotifyMask)
LedMode                       (XFIXES SaveSetMapping)
LineStyle                     (XFIXES SaveSetMode)
MapIndex                      (XFIXES SaveSetTarget)
MapState                      (XFIXES SelectionEvent)
Mapping                       (XFIXES SelectionEventMask)
MappingStatus                 (XTEST Cursor)
ModMask                       (XVideo AttributeFlag)
Motion                        (XVideo ImageFormatInfoFormat
NotifyDetail                  (XVideo ImageFormatInfoType)
NotifyMode                    (XVideo Type)
Place                         (XpExtension Attr)
PolyShape                     (XpExtension Detail)
PropMode                      (XpExtension EvMask)
Property                      (XpExtension GetDoc)

— X Struct: ARC

          ((fixed (x INT16)
                  (y INT16)
                  (width CARD16)
                  (height CARD16)
                  (angle1 INT16)
                  (angle2 INT16)))

— X Struct: CHAR2B

          ((fixed (byte1 CARD8) (byte2 CARD8)))

— X Struct: CHARINFO

          ((fixed (left-side-bearing INT16)
                  (right-side-bearing INT16)
                  (character-width INT16)
                  (ascent INT16)
                  (descent INT16)
                  (attributes CARD16)))

— X Struct: COLORITEM

          ((fixed (pixel CARD32)
                  (red CARD16)
                  (green CARD16)
                  (blue CARD16)
                  (flags BYTE)
                  (-pad #(1 BYTE))))

— X Struct: DEPTH

          ((fixed (depth CARD8)
                  (-pad #(1 BYTE))
                  (visuals-len CARD16)
                  (-pad #(4 BYTE)))
           (array (visuals #(visuals-len VISUALTYPE))))

— X Struct: FONTPROP

          ((fixed (name ATOM) (value CARD32)))

— X Struct: FORMAT

          ((fixed (depth CARD8)
                  (bits-per-pixel CARD8)
                  (scanline-pad CARD8)
                  (-pad #(5 BYTE))))

— X Struct: HOST

          ((fixed (family CARD8)
                  (-pad #(1 BYTE))
                  (address-len CARD16))
           (array (address #(address-len BYTE))))

— X Struct: POINT

          ((fixed (x INT16) (y INT16)))

— X Struct: RECTANGLE

          ((fixed (x INT16)
                  (y INT16)
                  (width CARD16)
                  (height CARD16)))

— X Struct: RGB

          ((fixed (red CARD16)
                  (green CARD16)
                  (blue CARD16)
                  (-pad #(2 BYTE))))

— X Struct: SCREEN

          ((fixed (root WINDOW)
                  (default-colormap COLORMAP)
                  (white-pixel CARD32)
                  (black-pixel CARD32)
                  (current-input-masks CARD32)
                  (width-in-pixels CARD16)
                  (height-in-pixels CARD16)
                  (width-in-millimeters CARD16)
                  (height-in-millimeters CARD16)
                  (min-installed-maps CARD16)
                  (max-installed-maps CARD16)
                  (root-visual VISUALID)
                  (backing-stores BYTE)
                  (save-unders BOOL)
                  (root-depth CARD8)
                  (allowed-depths-len CARD8))
           (array (allowed-depths #(allowed-depths-len DEPTH))))

— X Struct: SEGMENT

          ((fixed (x1 INT16)
                  (y1 INT16)
                  (x2 INT16)
                  (y2 INT16)))

— X Struct: STR

          ((fixed (name-len CARD8))
           (array (name #(name-len char))))

— X Struct: Setup

          ((fixed (status CARD8)
                  (-pad #(1 BYTE))
                  (protocol-major-version CARD16)
                  (protocol-minor-version CARD16)
                  (length CARD16)
                  (release-number CARD32)
                  (resource-id-base CARD32)
                  (resource-id-mask CARD32)
                  (motion-buffer-size CARD32)
                  (vendor-len CARD16)
                  (maximum-request-length CARD16)
                  (roots-len CARD8)
                  (pixmap-formats-len CARD8)
                  (image-byte-order CARD8)
                  (bitmap-format-bit-order CARD8)
                  (bitmap-format-scanline-unit CARD8)
                  (bitmap-format-scanline-pad CARD8)
                  (min-keycode KEYCODE)
                  (max-keycode KEYCODE)
                  (-pad #(4 BYTE)))
           (array (vendor #(vendor-len char)))
           (array (pixmap-formats #(pixmap-formats-len FORMAT)))
           (array (roots #(roots-len SCREEN))))

— X Struct: SetupAuthenticate

          ((fixed (status CARD8)
                  (-pad #(5 BYTE))
                  (length CARD16))
           (array (reason #((/ (* length 4) 1) char))))

— X Struct: SetupFailed

          ((fixed (status CARD8)
                  (reason-len CARD8)
                  (protocol-major-version CARD16)
                  (protocol-minor-version CARD16)
                  (length CARD16))
           (array (reason #(reason-len char))))

— X Struct: SetupRequest

          ((fixed (byte-order CARD8)
                  (-pad #(1 BYTE))
                  (protocol-major-version CARD16)
                  (protocol-minor-version CARD16)
                  (authorization-protocol-name-len CARD16)
                  (authorization-protocol-data-len CARD16))
           (array (authorization-protocol-name
                    #(authorization-protocol-name-len char)))
           (array (authorization-protocol-data
                    #(authorization-protocol-data-len char))))

— X Struct: TIMECOORD

          ((fixed (time TIMESTAMP) (x INT16) (y INT16)))

— X Struct: VISUALTYPE

          ((fixed (visual-id VISUALID)
                  (class CARD8)
                  (bits-per-rgb-value CARD8)
                  (colormap-entries CARD16)
                  (red-mask CARD32)
                  (green-mask CARD32)
                  (blue-mask CARD32)
                  (-pad #(4 BYTE))))

— X Struct: (Access err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (Alloc err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (AllocColor ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (red CARD16)
                  (green CARD16)
                  (blue CARD16)
                  (-pad #(2 BYTE))
                  (pixel CARD32)
                  (%pad #(12 BYTE))))

— X Struct: (AllocColor req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (cmap COLORMAP)
                  (red CARD16)
                  (green CARD16)
                  (blue CARD16)))

— X Struct: (AllocColorCells ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (pixels-len CARD16)
                  (masks-len CARD16)
                  (-pad #(20 BYTE)))
           (array (pixels #(pixels-len CARD32)))
           (array (masks #(masks-len CARD32))))

— X Struct: (AllocColorCells req)

          ((fixed (%major-opcode CARD8)
                  (contiguous BOOL)
                  (%length CARD16)
                  (cmap COLORMAP)
                  (colors CARD16)
                  (planes CARD16)))

— X Struct: (AllocColorPlanes ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (pixels-len CARD16)
                  (-pad #(2 BYTE))
                  (red-mask CARD32)
                  (green-mask CARD32)
                  (blue-mask CARD32)
                  (-pad #(8 BYTE)))
           (array (pixels #(pixels-len CARD32))))

— X Struct: (AllocColorPlanes req)

          ((fixed (%major-opcode CARD8)
                  (contiguous BOOL)
                  (%length CARD16)
                  (cmap COLORMAP)
                  (colors CARD16)
                  (reds CARD16)
                  (greens CARD16)
                  (blues CARD16)))

— X Struct: (AllocNamedColor ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (pixel CARD32)
                  (exact-red CARD16)
                  (exact-green CARD16)
                  (exact-blue CARD16)
                  (visual-red CARD16)
                  (visual-green CARD16)
                  (visual-blue CARD16)
                  (%pad #(8 BYTE))))

— X Struct: (AllocNamedColor req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (cmap COLORMAP)
                  (name-len CARD16))
           (array (name #(name-len char))))

— X Struct: (AllowEvents req)

          ((fixed (%major-opcode CARD8)
                  (mode CARD8)
                  (%length CARD16)
                  (time TIMESTAMP)))

— X Struct: (Atom err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (BIG-REQUESTS Enable ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (maximum-request-length CARD32)
                  (%pad #(20 BYTE))))

— X Struct: (BIG-REQUESTS Enable req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)))

— X Struct: (Bell req)

          ((fixed (%major-opcode CARD8)
                  (percent INT8)
                  (%length CARD16)))

— X Struct: (ButtonPress ev)

          ((fixed (%code CARD8)
                  (detail BUTTON)
                  (%sequence-number CARD16)
                  (time TIMESTAMP)
                  (root WINDOW)
                  (event WINDOW)
                  (child WINDOW)
                  (root-x INT16)
                  (root-y INT16)
                  (event-x INT16)
                  (event-y INT16)
                  (state CARD16)
                  (same-screen BOOL)
                  (%pad #(1 BYTE))))

— X Struct: (ButtonRelease ev)

          ((fixed (%code CARD8)
                  (detail BUTTON)
                  (%sequence-number CARD16)
                  (time TIMESTAMP)
                  (root WINDOW)
                  (event WINDOW)
                  (child WINDOW)
                  (root-x INT16)
                  (root-y INT16)
                  (event-x INT16)
                  (event-y INT16)
                  (state CARD16)
                  (same-screen BOOL)
                  (%pad #(1 BYTE))))

— X Struct: (ChangeActivePointerGrab req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (cursor CURSOR)
                  (time TIMESTAMP)
                  (event-mask CARD16)))

— X Struct: (ChangeGC req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (gc GCONTEXT)
                  (value-mask CARD32))
           (array (value-list #(value-mask CARD32 mask))))

— X Struct: (ChangeHosts req)

          ((fixed (%major-opcode CARD8)
                  (mode CARD8)
                  (%length CARD16)
                  (family CARD8)
                  (-pad #(1 BYTE))
                  (address-len CARD16))
           (array (address #(address-len char))))

— X Struct: (ChangeKeyboardControl req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (value-mask CARD32))
           (array (value-list #(value-mask CARD32 mask))))

— X Struct: (ChangeKeyboardMapping req)

          ((fixed (%major-opcode CARD8)
                  (keycode-count CARD8)
                  (%length CARD16)
                  (first-keycode KEYCODE)
                  (keysyms-per-keycode CARD8))
           (array (keysyms
                    #((/ (* keycode-count keysyms-per-keycode) 4)
                      KEYSYM))))

— X Struct: (ChangePointerControl req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (acceleration-numerator INT16)
                  (acceleration-denominator INT16)
                  (threshold INT16)
                  (do-acceleration BOOL)
                  (do-threshold BOOL)))

— X Struct: (ChangeProperty req)

          ((fixed (%major-opcode CARD8)
                  (mode CARD8)
                  (%length CARD16)
                  (window WINDOW)
                  (property ATOM)
                  (type ATOM)
                  (format CARD8)
                  (-pad #(3 BYTE))
                  (data-len CARD32))
           (array (data #((/ (/ (* data-len format) 8) #f) void))))

— X Struct: (ChangeSaveSet req)

          ((fixed (%major-opcode CARD8)
                  (mode BYTE)
                  (%length CARD16)
                  (window WINDOW)))

— X Struct: (ChangeWindowAttributes req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (window WINDOW)
                  (value-mask CARD32))
           (array (value-list #(value-mask CARD32 mask))))

— X Struct: (CirculateNotify ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (event WINDOW)
                  (window WINDOW)
                  (-pad #(4 BYTE))
                  (place BYTE)
                  (%pad #(15 BYTE))))

— X Struct: (CirculateRequest ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (event WINDOW)
                  (window WINDOW)
                  (-pad #(4 BYTE))
                  (place BYTE)
                  (%pad #(15 BYTE))))

— X Struct: (CirculateWindow req)

          ((fixed (%major-opcode CARD8)
                  (direction CARD8)
                  (%length CARD16)
                  (window WINDOW)))

— X Struct: (ClearArea req)

          ((fixed (%major-opcode CARD8)
                  (exposures BOOL)
                  (%length CARD16)
                  (window WINDOW)
                  (x INT16)
                  (y INT16)
                  (width CARD16)
                  (height CARD16)))

— X Struct: (ClientMessage ev)

          ((fixed (%code CARD8)
                  (format CARD8)
                  (%sequence-number CARD16)
                  (window WINDOW)
                  (type ATOM))
           (array (data #((assq-ref
                            '((8 . #(20 CARD8))
                              (16 . #(10 CARD16))
                              (32 . #(5 CARD32)))
                            format)
                          ClientMessageData))))

— X Struct: (CloseFont req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (font FONT)))

— X Struct: (Colormap err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (ColormapNotify ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (window WINDOW)
                  (colormap COLORMAP)
                  (new BOOL)
                  (state BYTE)
                  (%pad #(18 BYTE))))

— X Struct: (Composite CreateRegionFromBorderClip req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (region (XFIXES REGION))
                  (window WINDOW)))

— X Struct: (Composite GetOverlayWindow ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (overlay-win WINDOW)
                  (-pad #(20 BYTE))))

— X Struct: (Composite GetOverlayWindow req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (window WINDOW)))

— X Struct: (Composite NameWindowPixmap req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (window WINDOW)
                  (pixmap PIXMAP)))

— X Struct: (Composite QueryVersion ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (major-version CARD32)
                  (minor-version CARD32)
                  (-pad #(16 BYTE))))

— X Struct: (Composite QueryVersion req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (client-major-version CARD32)
                  (client-minor-version CARD32)))

— X Struct: (Composite RedirectSubwindows req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (window WINDOW)
                  (update CARD8)
                  (-pad #(3 BYTE))))

— X Struct: (Composite RedirectWindow req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (window WINDOW)
                  (update CARD8)
                  (-pad #(3 BYTE))))

— X Struct: (Composite ReleaseOverlayWindow req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (window WINDOW)))

— X Struct: (Composite UnredirectSubwindows req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (window WINDOW)
                  (update CARD8)
                  (-pad #(3 BYTE))))

— X Struct: (Composite UnredirectWindow req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (window WINDOW)
                  (update CARD8)
                  (-pad #(3 BYTE))))

— X Struct: (ConfigureNotify ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (event WINDOW)
                  (window WINDOW)
                  (above-sibling WINDOW)
                  (x INT16)
                  (y INT16)
                  (width CARD16)
                  (height CARD16)
                  (border-width CARD16)
                  (override-redirect BOOL)
                  (%pad #(5 BYTE))))

— X Struct: (ConfigureRequest ev)

          ((fixed (%code CARD8)
                  (stack-mode BYTE)
                  (%sequence-number CARD16)
                  (parent WINDOW)
                  (window WINDOW)
                  (sibling WINDOW)
                  (x INT16)
                  (y INT16)
                  (width CARD16)
                  (height CARD16)
                  (border-width CARD16)
                  (value-mask CARD16)
                  (%pad #(4 BYTE))))

— X Struct: (ConfigureWindow req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (window WINDOW)
                  (value-mask CARD16))
           (array (value-list #(value-mask CARD32 mask))))

— X Struct: (ConvertSelection req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (requestor WINDOW)
                  (selection ATOM)
                  (target ATOM)
                  (property ATOM)
                  (time TIMESTAMP)))

— X Struct: (CopyArea req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (src-drawable DRAWABLE)
                  (dst-drawable DRAWABLE)
                  (gc GCONTEXT)
                  (src-x INT16)
                  (src-y INT16)
                  (dst-x INT16)
                  (dst-y INT16)
                  (width CARD16)
                  (height CARD16)))

— X Struct: (CopyColormapAndFree req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (mid COLORMAP)
                  (src-cmap COLORMAP)))

— X Struct: (CopyGC req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (src-gc GCONTEXT)
                  (dst-gc GCONTEXT)
                  (value-mask CARD32)))

— X Struct: (CopyPlane req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (src-drawable DRAWABLE)
                  (dst-drawable DRAWABLE)
                  (gc GCONTEXT)
                  (src-x INT16)
                  (src-y INT16)
                  (dst-x INT16)
                  (dst-y INT16)
                  (width CARD16)
                  (height CARD16)
                  (bit-plane CARD32)))

— X Struct: (CreateColormap req)

          ((fixed (%major-opcode CARD8)
                  (alloc BYTE)
                  (%length CARD16)
                  (mid COLORMAP)
                  (window WINDOW)
                  (visual VISUALID)))

— X Struct: (CreateCursor req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (cid CURSOR)
                  (source PIXMAP)
                  (mask PIXMAP)
                  (fore-red CARD16)
                  (fore-green CARD16)
                  (fore-blue CARD16)
                  (back-red CARD16)
                  (back-green CARD16)
                  (back-blue CARD16)
                  (x CARD16)
                  (y CARD16)))

— X Struct: (CreateGC req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (cid GCONTEXT)
                  (drawable DRAWABLE)
                  (value-mask CARD32))
           (array (value-list #(value-mask CARD32 mask))))

— X Struct: (CreateGlyphCursor req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (cid CURSOR)
                  (source-font FONT)
                  (mask-font FONT)
                  (source-char CARD16)
                  (mask-char CARD16)
                  (fore-red CARD16)
                  (fore-green CARD16)
                  (fore-blue CARD16)
                  (back-red CARD16)
                  (back-green CARD16)
                  (back-blue CARD16)))

— X Struct: (CreateNotify ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (parent WINDOW)
                  (window WINDOW)
                  (x INT16)
                  (y INT16)
                  (width CARD16)
                  (height CARD16)
                  (border-width CARD16)
                  (override-redirect BOOL)
                  (%pad #(9 BYTE))))

— X Struct: (CreatePixmap req)

          ((fixed (%major-opcode CARD8)
                  (depth CARD8)
                  (%length CARD16)
                  (pid PIXMAP)
                  (drawable DRAWABLE)
                  (width CARD16)
                  (height CARD16)))

— X Struct: (CreateWindow req)

          ((fixed (%major-opcode CARD8)
                  (depth CARD8)
                  (%length CARD16)
                  (wid WINDOW)
                  (parent WINDOW)
                  (x INT16)
                  (y INT16)
                  (width CARD16)
                  (height CARD16)
                  (border-width CARD16)
                  (class CARD16)
                  (visual VISUALID)
                  (value-mask CARD32))
           (array (value-list #(value-mask CARD32 mask))))

— X Struct: (Cursor err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (DAMAGE BadDamage err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (%pad #(28 BYTE))))

— X Struct: (DAMAGE Create req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (damage (DAMAGE DAMAGE))
                  (drawable DRAWABLE)
                  (level CARD8)
                  (-pad #(3 BYTE))))

— X Struct: (DAMAGE Destroy req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (damage (DAMAGE DAMAGE))))

— X Struct: (DAMAGE Notify ev)

          ((fixed (%code CARD8)
                  (level CARD8)
                  (%sequence-number CARD16)
                  (drawable DRAWABLE)
                  (damage (DAMAGE DAMAGE))
                  (timestamp TIMESTAMP)
                  (area RECTANGLE)
                  (geometry RECTANGLE)))

— X Struct: (DAMAGE QueryVersion ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (major-version CARD32)
                  (minor-version CARD32)
                  (-pad #(16 BYTE))))

— X Struct: (DAMAGE QueryVersion req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (client-major-version CARD32)
                  (client-minor-version CARD32)))

— X Struct: (DAMAGE Subtract req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (damage (DAMAGE DAMAGE))
                  (repair (XFIXES REGION))
                  (parts (XFIXES REGION))))

— X Struct: (DPMS Capable ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (capable BOOL)
                  (%pad #(23 BYTE))))

— X Struct: (DPMS Capable req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)))

— X Struct: (DPMS Disable req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)))

— X Struct: (DPMS Enable req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)))

— X Struct: (DPMS ForceLevel req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (power-level CARD16)))

— X Struct: (DPMS GetTimeouts ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (standby-timeout CARD16)
                  (suspend-timeout CARD16)
                  (off-timeout CARD16)
                  (%pad #(18 BYTE))))

— X Struct: (DPMS GetTimeouts req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)))

— X Struct: (DPMS GetVersion ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (server-major-version CARD16)
                  (server-minor-version CARD16)
                  (%pad #(20 BYTE))))

— X Struct: (DPMS GetVersion req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (client-major-version CARD16)
                  (client-minor-version CARD16)))

— X Struct: (DPMS Info ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (power-level CARD16)
                  (state BOOL)
                  (%pad #(21 BYTE))))

— X Struct: (DPMS Info req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)))

— X Struct: (DPMS SetTimeouts req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (standby-timeout CARD16)
                  (suspend-timeout CARD16)
                  (off-timeout CARD16)))

— X Struct: (DeleteProperty req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (window WINDOW)
                  (property ATOM)))

— X Struct: (DestroyNotify ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (event WINDOW)
                  (window WINDOW)
                  (%pad #(20 BYTE))))

— X Struct: (DestroySubwindows req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (window WINDOW)))

— X Struct: (DestroyWindow req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (window WINDOW)))

— X Struct: (Drawable err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (EnterNotify ev)

          ((fixed (%code CARD8)
                  (detail BYTE)
                  (%sequence-number CARD16)
                  (time TIMESTAMP)
                  (root WINDOW)
                  (event WINDOW)
                  (child WINDOW)
                  (root-x INT16)
                  (root-y INT16)
                  (event-x INT16)
                  (event-y INT16)
                  (state CARD16)
                  (mode BYTE)
                  (same-screen-focus BYTE)))

— X Struct: (Expose ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (window WINDOW)
                  (x CARD16)
                  (y CARD16)
                  (width CARD16)
                  (height CARD16)
                  (count CARD16)
                  (%pad #(14 BYTE))))

— X Struct: (FillPoly req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (gc GCONTEXT)
                  (shape CARD8)
                  (coordinate-mode CARD8))
           (array (points #(#f POINT))))

— X Struct: (FocusIn ev)

          ((fixed (%code CARD8)
                  (detail BYTE)
                  (%sequence-number CARD16)
                  (event WINDOW)
                  (mode BYTE)
                  (%pad #(23 BYTE))))

— X Struct: (FocusOut ev)

          ((fixed (%code CARD8)
                  (detail BYTE)
                  (%sequence-number CARD16)
                  (event WINDOW)
                  (mode BYTE)
                  (%pad #(23 BYTE))))

— X Struct: (Font err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (ForceScreenSaver req)

          ((fixed (%major-opcode CARD8)
                  (mode CARD8)
                  (%length CARD16)))

— X Struct: (FreeColormap req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (cmap COLORMAP)))

— X Struct: (FreeColors req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (cmap COLORMAP)
                  (plane-mask CARD32))
           (array (pixels #(#f CARD32))))

— X Struct: (FreeCursor req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (cursor CURSOR)))

— X Struct: (FreeGC req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (gc GCONTEXT)))

— X Struct: (FreePixmap req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (pixmap PIXMAP)))

— X Struct: (GContext err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (GLX AreTexturesResident ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (ret-val (GLX BOOL32))
                  (-pad #(20 BYTE)))
           (array (data #(#f BOOL))))

— X Struct: (GLX AreTexturesResident req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (n INT32))
           (array (textures #(n CARD32))))

— X Struct: (GLX BadContext err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (-pad #(21 BYTE))))

— X Struct: (GLX BadContextState err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (-pad #(21 BYTE))))

— X Struct: (GLX BadContextTag err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (-pad #(21 BYTE))))

— X Struct: (GLX BadCurrentDrawable err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (-pad #(21 BYTE))))

— X Struct: (GLX BadCurrentWindow err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (-pad #(21 BYTE))))

— X Struct: (GLX BadDrawable err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (-pad #(21 BYTE))))

— X Struct: (GLX BadFBConfig err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (-pad #(21 BYTE))))

— X Struct: (GLX BadLargeRequest err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (-pad #(21 BYTE))))

— X Struct: (GLX BadPbuffer err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (-pad #(21 BYTE))))

— X Struct: (GLX BadPixmap err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (-pad #(21 BYTE))))

— X Struct: (GLX BadRenderRequest err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (-pad #(21 BYTE))))

— X Struct: (GLX BadWindow err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (-pad #(21 BYTE))))

— X Struct: (GLX ChangeDrawableAttributes req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (drawable (GLX DRAWABLE))
                  (num-attribs CARD32))
           (array (attribs #((/ (* num-attribs 2) 4) CARD32))))

— X Struct: (GLX ClientInfo req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (major-version CARD32)
                  (minor-version CARD32)
                  (str-len CARD32))
           (array (string #(str-len CARD8))))

— X Struct: (GLX CopyContext req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (src (GLX CONTEXT))
                  (dest (GLX CONTEXT))
                  (mask CARD32)
                  (src-context-tag (GLX CONTEXT-TAG))))

— X Struct: (GLX CreateContext req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context (GLX CONTEXT))
                  (visual VISUALID)
                  (screen CARD32)
                  (share-list (GLX CONTEXT))
                  (is-direct BOOL)
                  (-pad #(3 BYTE))))

— X Struct: (GLX CreateGLXPixmap req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (screen CARD32)
                  (visual VISUALID)
                  (pixmap PIXMAP)
                  (glx-pixmap (GLX PIXMAP))))

— X Struct: (GLX CreateNewContext req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context (GLX CONTEXT))
                  (fbconfig CARD32)
                  (screen CARD32)
                  (render-type CARD32)
                  (share-list CARD32)
                  (is-direct BOOL)
                  (reserved1 CARD8)
                  (reserved2 CARD16)))

— X Struct: (GLX CreatePbuffer req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (screen CARD32)
                  (fbconfig (GLX FBCONFIG))
                  (pbuffer (GLX PBUFFER))
                  (num-attribs CARD32))
           (array (attribs #((/ (* num-attribs 2) 4) CARD32))))

— X Struct: (GLX CreatePixmap req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (screen CARD32)
                  (fbconfig CARD32)
                  (pixmap PIXMAP)
                  (glx-pixmap (GLX PIXMAP))
                  (num-attribs CARD32))
           (array (attribs #((/ (* num-attribs 2) 4) CARD32))))

— X Struct: (GLX CreateWindow req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (screen CARD32)
                  (fbconfig (GLX FBCONFIG))
                  (window WINDOW)
                  (glx-window (GLX WINDOW))
                  (num-attribs CARD32))
           (array (attribs #((/ (* num-attribs 2) 4) CARD32))))

— X Struct: (GLX DeleteLists req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (list CARD32)
                  (range INT32)))

— X Struct: (GLX DeleteQueriesARB req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (n INT32))
           (array (ids #(n CARD32))))

— X Struct: (GLX DeleteTextures req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (n INT32))
           (array (textures #(n CARD32))))

— X Struct: (GLX DeleteWindow req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (glxwindow (GLX WINDOW))))

— X Struct: (GLX DestroyContext req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context (GLX CONTEXT))))

— X Struct: (GLX DestroyGLXPixmap req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (glx-pixmap (GLX PIXMAP))))

— X Struct: (GLX DestroyPbuffer req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (pbuffer (GLX PBUFFER))))

— X Struct: (GLX DestroyPixmap req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (glx-pixmap (GLX PIXMAP))))

— X Struct: (GLX EndList req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))))

— X Struct: (GLX FeedbackBuffer req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (size INT32)
                  (type INT32)))

— X Struct: (GLX Finish ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (%pad #(24 BYTE))))

— X Struct: (GLX Finish req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))))

— X Struct: (GLX Flush req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))))

— X Struct: (GLX GenLists ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (ret-val CARD32)
                  (%pad #(20 BYTE))))

— X Struct: (GLX GenLists req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (range INT32)))

— X Struct: (GLX GenQueriesARB ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(24 BYTE)))
           (array (data #(#f CARD32))))

— X Struct: (GLX GenQueriesARB req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (n INT32)))

— X Struct: (GLX GenTextures ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(24 BYTE)))
           (array (data #(#f CARD32))))

— X Struct: (GLX GenTextures req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (n INT32)))

— X Struct: (GLX Generic err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (-pad #(21 BYTE))))

— X Struct: (GLX GetBooleanv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum BOOL)
                  (-pad #(15 BYTE)))
           (array (data #(n BOOL))))

— X Struct: (GLX GetBooleanv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (pname INT32)))

— X Struct: (GLX GetClipPlane ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(24 BYTE)))
           (array (data #(#f (GLX FLOAT64)))))

— X Struct: (GLX GetClipPlane req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (plane INT32)))

— X Struct: (GLX GetColorTable ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(8 BYTE))
                  (width INT32)
                  (-pad #(12 BYTE)))
           (array (data #(#f BYTE))))

— X Struct: (GLX GetColorTable req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (format CARD32)
                  (type CARD32)
                  (swap-bytes BOOL)))

— X Struct: (GLX GetColorTableParameterfv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum (GLX FLOAT32))
                  (-pad #(12 BYTE)))
           (array (data #(n (GLX FLOAT32)))))

— X Struct: (GLX GetColorTableParameterfv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetColorTableParameteriv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum INT32)
                  (-pad #(12 BYTE)))
           (array (data #(n INT32))))

— X Struct: (GLX GetColorTableParameteriv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetCompressedTexImageARB ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(8 BYTE))
                  (size INT32)
                  (-pad #(12 BYTE)))
           (array (data #(#f BYTE))))

— X Struct: (GLX GetCompressedTexImageARB req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (level INT32)))

— X Struct: (GLX GetConvolutionFilter ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(8 BYTE))
                  (width INT32)
                  (height INT32)
                  (-pad #(8 BYTE)))
           (array (data #(#f BYTE))))

— X Struct: (GLX GetConvolutionFilter req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (format CARD32)
                  (type CARD32)
                  (swap-bytes BOOL)))

— X Struct: (GLX GetConvolutionParameterfv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum (GLX FLOAT32))
                  (-pad #(12 BYTE)))
           (array (data #(n (GLX FLOAT32)))))

— X Struct: (GLX GetConvolutionParameterfv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetConvolutionParameteriv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum INT32)
                  (-pad #(12 BYTE)))
           (array (data #(n INT32))))

— X Struct: (GLX GetConvolutionParameteriv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetDoublev ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum (GLX FLOAT64))
                  (-pad #(8 BYTE)))
           (array (data #(n (GLX FLOAT64)))))

— X Struct: (GLX GetDoublev req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (pname CARD32)))

— X Struct: (GLX GetDrawableAttributes ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (num-attribs CARD32)
                  (-pad #(20 BYTE)))
           (array (attribs #((/ (* num-attribs 2) 4) CARD32))))

— X Struct: (GLX GetDrawableAttributes req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (drawable (GLX DRAWABLE))))

— X Struct: (GLX GetError ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (error INT32)
                  (%pad #(20 BYTE))))

— X Struct: (GLX GetError req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))))

— X Struct: (GLX GetFBConfigs ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (num-FB-configs CARD32)
                  (num-properties CARD32)
                  (-pad #(16 BYTE)))
           (array (property-list #(#f CARD32))))

— X Struct: (GLX GetFBConfigs req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (screen CARD32)))

— X Struct: (GLX GetFloatv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum (GLX FLOAT32))
                  (-pad #(12 BYTE)))
           (array (data #(n (GLX FLOAT32)))))

— X Struct: (GLX GetFloatv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (pname CARD32)))

— X Struct: (GLX GetHistogram ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(8 BYTE))
                  (width INT32)
                  (-pad #(12 BYTE)))
           (array (data #(#f BYTE))))

— X Struct: (GLX GetHistogram req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (format CARD32)
                  (type CARD32)
                  (swap-bytes BOOL)
                  (reset BOOL)))

— X Struct: (GLX GetHistogramParameterfv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum (GLX FLOAT32))
                  (-pad #(12 BYTE)))
           (array (data #(n (GLX FLOAT32)))))

— X Struct: (GLX GetHistogramParameterfv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetHistogramParameteriv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum INT32)
                  (-pad #(12 BYTE)))
           (array (data #(n INT32))))

— X Struct: (GLX GetHistogramParameteriv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetIntegerv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum INT32)
                  (-pad #(12 BYTE)))
           (array (data #(n INT32))))

— X Struct: (GLX GetIntegerv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (pname CARD32)))

— X Struct: (GLX GetLightfv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum (GLX FLOAT32))
                  (-pad #(12 BYTE)))
           (array (data #(n (GLX FLOAT32)))))

— X Struct: (GLX GetLightfv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (light CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetLightiv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum INT32)
                  (-pad #(12 BYTE)))
           (array (data #(n INT32))))

— X Struct: (GLX GetLightiv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (light CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetMapdv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum (GLX FLOAT64))
                  (-pad #(8 BYTE)))
           (array (data #(n (GLX FLOAT64)))))

— X Struct: (GLX GetMapdv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (query CARD32)))

— X Struct: (GLX GetMapfv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum (GLX FLOAT32))
                  (-pad #(12 BYTE)))
           (array (data #(n (GLX FLOAT32)))))

— X Struct: (GLX GetMapfv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (query CARD32)))

— X Struct: (GLX GetMapiv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum INT32)
                  (-pad #(12 BYTE)))
           (array (data #(n INT32))))

— X Struct: (GLX GetMapiv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (query CARD32)))

— X Struct: (GLX GetMaterialfv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum (GLX FLOAT32))
                  (-pad #(12 BYTE)))
           (array (data #(n (GLX FLOAT32)))))

— X Struct: (GLX GetMaterialfv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (face CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetMaterialiv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum INT32)
                  (-pad #(12 BYTE)))
           (array (data #(n INT32))))

— X Struct: (GLX GetMaterialiv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (face CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetMinmax ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(24 BYTE)))
           (array (data #(#f BYTE))))

— X Struct: (GLX GetMinmax req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (format CARD32)
                  (type CARD32)
                  (swap-bytes BOOL)
                  (reset BOOL)))

— X Struct: (GLX GetMinmaxParameterfv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum (GLX FLOAT32))
                  (-pad #(12 BYTE)))
           (array (data #(n (GLX FLOAT32)))))

— X Struct: (GLX GetMinmaxParameterfv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetMinmaxParameteriv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum INT32)
                  (-pad #(12 BYTE)))
           (array (data #(n INT32))))

— X Struct: (GLX GetMinmaxParameteriv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetPixelMapfv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum (GLX FLOAT32))
                  (-pad #(12 BYTE)))
           (array (data #(n (GLX FLOAT32)))))

— X Struct: (GLX GetPixelMapfv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (map CARD32)))

— X Struct: (GLX GetPixelMapuiv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum CARD32)
                  (-pad #(12 BYTE)))
           (array (data #(n CARD32))))

— X Struct: (GLX GetPixelMapuiv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (map CARD32)))

— X Struct: (GLX GetPixelMapusv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum CARD16)
                  (-pad #(16 BYTE)))
           (array (data #(n CARD16))))

— X Struct: (GLX GetPixelMapusv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (map CARD32)))

— X Struct: (GLX GetPolygonStipple ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(24 BYTE)))
           (array (data #(#f BYTE))))

— X Struct: (GLX GetPolygonStipple req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (lsb-first BOOL)))

— X Struct: (GLX GetQueryObjectivARB ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum INT32)
                  (-pad #(12 BYTE)))
           (array (data #(n INT32))))

— X Struct: (GLX GetQueryObjectivARB req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (id CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetQueryObjectuivARB ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum CARD32)
                  (-pad #(12 BYTE)))
           (array (data #(n CARD32))))

— X Struct: (GLX GetQueryObjectuivARB req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (id CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetQueryivARB ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum INT32)
                  (-pad #(12 BYTE)))
           (array (data #(n INT32))))

— X Struct: (GLX GetQueryivARB req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetSeparableFilter ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(8 BYTE))
                  (row-w INT32)
                  (col-h INT32)
                  (-pad #(8 BYTE)))
           (array (rows-and-cols #(#f BYTE))))

— X Struct: (GLX GetSeparableFilter req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (format CARD32)
                  (type CARD32)
                  (swap-bytes BOOL)))

— X Struct: (GLX GetString ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (-pad #(16 BYTE)))
           (array (string #(n CARD8))))

— X Struct: (GLX GetString req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (name CARD32)))

— X Struct: (GLX GetTexEnvfv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum (GLX FLOAT32))
                  (-pad #(12 BYTE)))
           (array (data #(n (GLX FLOAT32)))))

— X Struct: (GLX GetTexEnvfv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetTexEnviv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum INT32)
                  (-pad #(12 BYTE)))
           (array (data #(n INT32))))

— X Struct: (GLX GetTexEnviv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetTexGendv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum (GLX FLOAT64))
                  (-pad #(8 BYTE)))
           (array (data #(n (GLX FLOAT64)))))

— X Struct: (GLX GetTexGendv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (coord CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetTexGenfv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum (GLX FLOAT32))
                  (-pad #(12 BYTE)))
           (array (data #(n (GLX FLOAT32)))))

— X Struct: (GLX GetTexGenfv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (coord CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetTexGeniv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum INT32)
                  (-pad #(12 BYTE)))
           (array (data #(n INT32))))

— X Struct: (GLX GetTexGeniv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (coord CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetTexImage ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(8 BYTE))
                  (width INT32)
                  (height INT32)
                  (depth INT32)
                  (-pad #(4 BYTE)))
           (array (data #(#f BYTE))))

— X Struct: (GLX GetTexImage req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (level INT32)
                  (format CARD32)
                  (type CARD32)
                  (swap-bytes BOOL)))

— X Struct: (GLX GetTexLevelParameterfv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum (GLX FLOAT32))
                  (-pad #(12 BYTE)))
           (array (data #(n (GLX FLOAT32)))))

— X Struct: (GLX GetTexLevelParameterfv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (level INT32)
                  (pname CARD32)))

— X Struct: (GLX GetTexLevelParameteriv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum INT32)
                  (-pad #(12 BYTE)))
           (array (data #(n INT32))))

— X Struct: (GLX GetTexLevelParameteriv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (level INT32)
                  (pname CARD32)))

— X Struct: (GLX GetTexParameterfv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum (GLX FLOAT32))
                  (-pad #(12 BYTE)))
           (array (data #(n (GLX FLOAT32)))))

— X Struct: (GLX GetTexParameterfv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetTexParameteriv ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (datum INT32)
                  (-pad #(12 BYTE)))
           (array (data #(n INT32))))

— X Struct: (GLX GetTexParameteriv req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (target CARD32)
                  (pname CARD32)))

— X Struct: (GLX GetVisualConfigs ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (num-visuals CARD32)
                  (num-properties CARD32)
                  (-pad #(16 BYTE)))
           (array (property-list #(#f CARD32))))

— X Struct: (GLX GetVisualConfigs req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (screen CARD32)))

— X Struct: (GLX IsDirect ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (is-direct BOOL)
                  (-pad #(23 BYTE))))

— X Struct: (GLX IsDirect req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context (GLX CONTEXT))))

— X Struct: (GLX IsList ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (ret-val (GLX BOOL32))
                  (%pad #(20 BYTE))))

— X Struct: (GLX IsList req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (list CARD32)))

— X Struct: (GLX IsQueryARB ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (ret-val (GLX BOOL32))
                  (%pad #(20 BYTE))))

— X Struct: (GLX IsQueryARB req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (id CARD32)))

— X Struct: (GLX IsTexture ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (ret-val (GLX BOOL32))
                  (%pad #(20 BYTE))))

— X Struct: (GLX IsTexture req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (texture CARD32)))

— X Struct: (GLX MakeContextCurrent ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (context-tag (GLX CONTEXT-TAG))
                  (-pad #(20 BYTE))))

— X Struct: (GLX MakeContextCurrent req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (old-context-tag (GLX CONTEXT-TAG))
                  (drawable (GLX DRAWABLE))
                  (read-drawable (GLX DRAWABLE))
                  (context (GLX CONTEXT))))

— X Struct: (GLX MakeCurrent ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (context-tag (GLX CONTEXT-TAG))
                  (-pad #(20 BYTE))))

— X Struct: (GLX MakeCurrent req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (drawable (GLX DRAWABLE))
                  (context (GLX CONTEXT))
                  (old-context-tag (GLX CONTEXT-TAG))))

— X Struct: (GLX NewList req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (list CARD32)
                  (mode CARD32)))

— X Struct: (GLX PbufferClobber ev)

          ((fixed (%code CARD8)
                  (event-type CARD16)
                  (%sequence-number CARD16)
                  (draw-type CARD16)
                  (drawable (GLX DRAWABLE))
                  (b-mask CARD32)
                  (aux-buffer CARD16)
                  (x CARD16)
                  (y CARD16)
                  (width CARD16)
                  (height CARD16)
                  (count CARD16)
                  (-pad #(4 BYTE))
                  (%pad #(1 BYTE))))

— X Struct: (GLX PixelStoref req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (pname CARD32)
                  (datum (GLX FLOAT32))))

— X Struct: (GLX PixelStorei req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (pname CARD32)
                  (datum INT32)))

— X Struct: (GLX QueryContext ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (num-attribs CARD32)
                  (-pad #(20 BYTE)))
           (array (attribs #((/ (* num-attribs 2) 4) CARD32))))

— X Struct: (GLX QueryContext req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context (GLX CONTEXT))))

— X Struct: (GLX QueryExtensionsString ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (n CARD32)
                  (-pad #(16 BYTE))))

— X Struct: (GLX QueryExtensionsString req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (screen CARD32)))

— X Struct: (GLX QueryServerString ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(4 BYTE))
                  (str-len CARD32)
                  (-pad #(16 BYTE)))
           (array (string #(str-len CARD8))))

— X Struct: (GLX QueryServerString req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (screen CARD32)
                  (name CARD32)))

— X Struct: (GLX QueryVersion ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (major-version CARD32)
                  (minor-version CARD32)
                  (-pad #(16 BYTE))))

— X Struct: (GLX QueryVersion req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (major-version CARD32)
                  (minor-version CARD32)))

— X Struct: (GLX ReadPixels ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(24 BYTE)))
           (array (data #(#f BYTE))))

— X Struct: (GLX ReadPixels req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (x INT32)
                  (y INT32)
                  (width INT32)
                  (height INT32)
                  (format CARD32)
                  (type CARD32)
                  (swap-bytes BOOL)
                  (lsb-first BOOL)))

— X Struct: (GLX Render req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG)))
           (array (data #(#f BYTE))))

— X Struct: (GLX RenderLarge req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (request-num CARD16)
                  (request-total CARD16)
                  (data-len CARD32))
           (array (data #(data-len BYTE))))

— X Struct: (GLX RenderMode ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (ret-val CARD32)
                  (n CARD32)
                  (new-mode CARD32)
                  (-pad #(12 BYTE)))
           (array (data #(n CARD32))))

— X Struct: (GLX RenderMode req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (mode CARD32)))

— X Struct: (GLX SelectBuffer req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (size INT32)))

— X Struct: (GLX SwapBuffers req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (drawable (GLX DRAWABLE))))

— X Struct: (GLX UnsupportedPrivateRequest err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (-pad #(21 BYTE))))

— X Struct: (GLX UseXFont req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))
                  (font FONT)
                  (first CARD32)
                  (count CARD32)
                  (list-base CARD32)))

— X Struct: (GLX VendorPrivate req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (vendor-code CARD32)
                  (context-tag (GLX CONTEXT-TAG)))
           (array (data #(#f BYTE))))

— X Struct: (GLX VendorPrivateWithReply ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (retval CARD32)
                  (data1 #(24 BYTE)))
           (array (data2 #(#f BYTE))))

— X Struct: (GLX VendorPrivateWithReply req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (vendor-code CARD32)
                  (context-tag (GLX CONTEXT-TAG)))
           (array (data #(#f BYTE))))

— X Struct: (GLX WaitGL req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))))

— X Struct: (GLX WaitX req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context-tag (GLX CONTEXT-TAG))))

— X Struct: (GetAtomName ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (name-len CARD16)
                  (-pad #(22 BYTE)))
           (array (name #(name-len CARD8))))

— X Struct: (GetAtomName req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (atom ATOM)))

— X Struct: (GetFontPath ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (path-len CARD16)
                  (-pad #(22 BYTE)))
           (array (path #(path-len STR))))

— X Struct: (GetFontPath req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)))

— X Struct: (GetGeometry ans)

          ((fixed (%status CARD8)
                  (depth CARD8)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (root WINDOW)
                  (x INT16)
                  (y INT16)
                  (width CARD16)
                  (height CARD16)
                  (border-width CARD16)
                  (%pad #(10 BYTE))))

— X Struct: (GetGeometry req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (drawable DRAWABLE)))

— X Struct: (GetImage ans)

          ((fixed (%status CARD8)
                  (depth CARD8)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (visual VISUALID)
                  (-pad #(20 BYTE)))
           (array (data #((/ (* length 4) 1) BYTE))))

— X Struct: (GetImage req)

          ((fixed (%major-opcode CARD8)
                  (format CARD8)
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (x INT16)
                  (y INT16)
                  (width CARD16)
                  (height CARD16)
                  (plane-mask CARD32)))

— X Struct: (GetInputFocus ans)

          ((fixed (%status CARD8)
                  (revert-to CARD8)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (focus WINDOW)
                  (%pad #(20 BYTE))))

— X Struct: (GetInputFocus req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)))

— X Struct: (GetKeyboardControl ans)

          ((fixed (%status CARD8)
                  (global-auto-repeat BYTE)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (led-mask CARD32)
                  (key-click-percent CARD8)
                  (bell-percent CARD8)
                  (bell-pitch CARD16)
                  (bell-duration CARD16)
                  (-pad #(2 BYTE))
                  (auto-repeats #(32 CARD8))))

— X Struct: (GetKeyboardControl req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)))

— X Struct: (GetKeyboardMapping ans)

          ((fixed (%status CARD8)
                  (keysyms-per-keycode BYTE)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(24 BYTE)))
           (array (keysyms #((/ (* length 4) 4) KEYSYM))))

— X Struct: (GetKeyboardMapping req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (first-keycode KEYCODE)
                  (count CARD8)))

— X Struct: (GetModifierMapping ans)

          ((fixed (%status CARD8)
                  (keycodes-per-modifier CARD8)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(24 BYTE)))
           (array (keycodes
                    #((/ (* keycodes-per-modifier 8) 1) KEYCODE))))

— X Struct: (GetModifierMapping req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)))

— X Struct: (GetMotionEvents ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (events-len CARD32)
                  (-pad #(20 BYTE)))
           (array (events #(events-len TIMECOORD))))

— X Struct: (GetMotionEvents req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (window WINDOW)
                  (start TIMESTAMP)
                  (stop TIMESTAMP)))

— X Struct: (GetPointerControl ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (acceleration-numerator CARD16)
                  (acceleration-denominator CARD16)
                  (threshold CARD16)
                  (%pad #(18 BYTE))))

— X Struct: (GetPointerControl req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)))

— X Struct: (GetPointerMapping ans)

          ((fixed (%status CARD8)
                  (map-len CARD8)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(24 BYTE)))
           (array (map #(map-len CARD8))))

— X Struct: (GetPointerMapping req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)))

— X Struct: (GetProperty ans)

          ((fixed (%status CARD8)
                  (format CARD8)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (type ATOM)
                  (bytes-after CARD32)
                  (value-len CARD32)
                  (-pad #(12 BYTE)))
           (array (value #(value-len void))))

— X Struct: (GetProperty req)

          ((fixed (%major-opcode CARD8)
                  (delete BOOL)
                  (%length CARD16)
                  (window WINDOW)
                  (property ATOM)
                  (type ATOM)
                  (long-offset CARD32)
                  (long-length CARD32)))

— X Struct: (GetScreenSaver ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (timeout CARD16)
                  (interval CARD16)
                  (prefer-blanking BYTE)
                  (allow-exposures BYTE)
                  (%pad #(18 BYTE))))

— X Struct: (GetScreenSaver req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)))

— X Struct: (GetSelectionOwner ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (owner WINDOW)
                  (%pad #(20 BYTE))))

— X Struct: (GetSelectionOwner req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (selection ATOM)))

— X Struct: (GetWindowAttributes ans)

          ((fixed (%status CARD8)
                  (backing-store CARD8)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (visual VISUALID)
                  (class CARD16)
                  (bit-gravity CARD8)
                  (win-gravity CARD8)
                  (backing-planes CARD32)
                  (backing-pixel CARD32)
                  (save-under BOOL)
                  (map-is-installed BOOL)
                  (map-state CARD8)
                  (override-redirect BOOL)
                  (colormap COLORMAP)
                  (all-event-masks CARD32)
                  (your-event-mask CARD32)
                  (do-not-propagate-mask CARD16)))

— X Struct: (GetWindowAttributes req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (window WINDOW)))

— X Struct: (GrabButton req)

          ((fixed (%major-opcode CARD8)
                  (owner-events BOOL)
                  (%length CARD16)
                  (grab-window WINDOW)
                  (event-mask CARD16)
                  (pointer-mode CARD8)
                  (keyboard-mode CARD8)
                  (confine-to WINDOW)
                  (cursor CURSOR)
                  (button CARD8)
                  (-pad #(1 BYTE))
                  (modifiers CARD16)))

— X Struct: (GrabKey req)

          ((fixed (%major-opcode CARD8)
                  (owner-events BOOL)
                  (%length CARD16)
                  (grab-window WINDOW)
                  (modifiers CARD16)
                  (key KEYCODE)
                  (pointer-mode CARD8)
                  (keyboard-mode CARD8)))

— X Struct: (GrabKeyboard ans)

          ((fixed (%status CARD8)
                  (status BYTE)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (%pad #(24 BYTE))))

— X Struct: (GrabKeyboard req)

          ((fixed (%major-opcode CARD8)
                  (owner-events BOOL)
                  (%length CARD16)
                  (grab-window WINDOW)
                  (time TIMESTAMP)
                  (pointer-mode BYTE)
                  (keyboard-mode BYTE)))

— X Struct: (GrabPointer ans)

          ((fixed (%status CARD8)
                  (status BYTE)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (%pad #(24 BYTE))))

— X Struct: (GrabPointer req)

          ((fixed (%major-opcode CARD8)
                  (owner-events BOOL)
                  (%length CARD16)
                  (grab-window WINDOW)
                  (event-mask CARD16)
                  (pointer-mode BYTE)
                  (keyboard-mode BYTE)
                  (confine-to WINDOW)
                  (cursor CURSOR)
                  (time TIMESTAMP)))

— X Struct: (GrabServer req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)))

— X Struct: (GraphicsExposure ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (drawable DRAWABLE)
                  (x CARD16)
                  (y CARD16)
                  (width CARD16)
                  (height CARD16)
                  (minor-opcode CARD16)
                  (count CARD16)
                  (major-opcode CARD8)
                  (%pad #(11 BYTE))))

— X Struct: (GravityNotify ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (event WINDOW)
                  (window WINDOW)
                  (x INT16)
                  (y INT16)
                  (%pad #(16 BYTE))))

— X Struct: (IDChoice err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (ImageText16 req)

          ((fixed (%major-opcode CARD8)
                  (string-len BYTE)
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (gc GCONTEXT)
                  (x INT16)
                  (y INT16))
           (array (string #(string-len CHAR2B))))

— X Struct: (ImageText8 req)

          ((fixed (%major-opcode CARD8)
                  (string-len BYTE)
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (gc GCONTEXT)
                  (x INT16)
                  (y INT16))
           (array (string #(string-len char))))

— X Struct: (Implementation err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (InstallColormap req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (cmap COLORMAP)))

— X Struct: (InternAtom ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (atom ATOM)
                  (%pad #(20 BYTE))))

— X Struct: (InternAtom req)

          ((fixed (%major-opcode CARD8)
                  (only-if-exists BOOL)
                  (%length CARD16)
                  (name-len CARD16)
                  (-pad #(2 BYTE)))
           (array (name #(name-len char))))

— X Struct: (KeyPress ev)

          ((fixed (%code CARD8)
                  (detail KEYCODE)
                  (%sequence-number CARD16)
                  (time TIMESTAMP)
                  (root WINDOW)
                  (event WINDOW)
                  (child WINDOW)
                  (root-x INT16)
                  (root-y INT16)
                  (event-x INT16)
                  (event-y INT16)
                  (state CARD16)
                  (same-screen BOOL)
                  (%pad #(1 BYTE))))

— X Struct: (KeyRelease ev)

          ((fixed (%code CARD8)
                  (detail KEYCODE)
                  (%sequence-number CARD16)
                  (time TIMESTAMP)
                  (root WINDOW)
                  (event WINDOW)
                  (child WINDOW)
                  (root-x INT16)
                  (root-y INT16)
                  (event-x INT16)
                  (event-y INT16)
                  (state CARD16)
                  (same-screen BOOL)
                  (%pad #(1 BYTE))))

— X Struct: (KeymapNotify ev)

          ((fixed (%code CARD8) (keys #(31 CARD8))))

— X Struct: (KillClient req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (resource CARD32)))

— X Struct: (LeaveNotify ev)

          ((fixed (%code CARD8)
                  (detail BYTE)
                  (%sequence-number CARD16)
                  (time TIMESTAMP)
                  (root WINDOW)
                  (event WINDOW)
                  (child WINDOW)
                  (root-x INT16)
                  (root-y INT16)
                  (event-x INT16)
                  (event-y INT16)
                  (state CARD16)
                  (mode BYTE)
                  (same-screen-focus BYTE)))

— X Struct: (Length err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (ListExtensions ans)

          ((fixed (%status CARD8)
                  (names-len CARD8)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(24 BYTE)))
           (array (names #(names-len STR))))

— X Struct: (ListExtensions req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)))

— X Struct: (ListFonts ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (names-len CARD16)
                  (-pad #(22 BYTE)))
           (array (names #(names-len STR))))

— X Struct: (ListFonts req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (max-names CARD16)
                  (pattern-len CARD16))
           (array (pattern #(pattern-len char))))

— X Struct: (ListFontsWithInfo ans)

          ((fixed (%status CARD8)
                  (name-len CARD8)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (min-bounds CHARINFO)
                  (-pad #(4 BYTE))
                  (max-bounds CHARINFO)
                  (-pad #(4 BYTE))
                  (min-char-or-byte2 CARD16)
                  (max-char-or-byte2 CARD16)
                  (default-char CARD16)
                  (properties-len CARD16)
                  (draw-direction BYTE)
                  (min-byte1 CARD8)
                  (max-byte1 CARD8)
                  (all-chars-exist BOOL)
                  (font-ascent INT16)
                  (font-descent INT16)
                  (replies-hint CARD32))
           (array (properties #(properties-len FONTPROP)))
           (array (name #(name-len char))))

— X Struct: (ListFontsWithInfo req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (max-names CARD16)
                  (pattern-len CARD16))
           (array (pattern #(pattern-len char))))

— X Struct: (ListHosts ans)

          ((fixed (%status CARD8)
                  (mode BYTE)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (hosts-len CARD16)
                  (-pad #(22 BYTE)))
           (array (hosts #(hosts-len HOST))))

— X Struct: (ListHosts req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)))

— X Struct: (ListInstalledColormaps ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (cmaps-len CARD16)
                  (-pad #(22 BYTE)))
           (array (cmaps #(cmaps-len COLORMAP))))

— X Struct: (ListInstalledColormaps req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (window WINDOW)))

— X Struct: (ListProperties ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (atoms-len CARD16)
                  (-pad #(22 BYTE)))
           (array (atoms #(atoms-len ATOM))))

— X Struct: (ListProperties req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (window WINDOW)))

— X Struct: (LookupColor ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (exact-red CARD16)
                  (exact-green CARD16)
                  (exact-blue CARD16)
                  (visual-red CARD16)
                  (visual-green CARD16)
                  (visual-blue CARD16)
                  (%pad #(12 BYTE))))

— X Struct: (LookupColor req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (cmap COLORMAP)
                  (name-len CARD16))
           (array (name #(name-len char))))

— X Struct: (MIT-SCREEN-SAVER Notify ev)

          ((fixed (%code CARD8)
                  (code CARD8)
                  (%sequence-number CARD16)
                  (state BYTE)
                  (sequence-number CARD16)
                  (time TIMESTAMP)
                  (root WINDOW)
                  (window WINDOW)
                  (kind BYTE)
                  (forced BOOL)
                  (-pad #(14 BYTE))))

— X Struct: (MIT-SCREEN-SAVER QueryInfo ans)

          ((fixed (%status CARD8)
                  (state CARD8)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (saver-window WINDOW)
                  (ms-until-server CARD32)
                  (ms-since-user-input CARD32)
                  (event-mask CARD32)
                  (kind BYTE)
                  (-pad #(7 BYTE))))

— X Struct: (MIT-SCREEN-SAVER QueryInfo req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (drawable DRAWABLE)))

— X Struct: (MIT-SCREEN-SAVER QueryVersion ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (server-major-version CARD16)
                  (server-minor-version CARD16)
                  (-pad #(20 BYTE))))

— X Struct: (MIT-SCREEN-SAVER QueryVersion req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (client-major-version CARD8)
                  (client-minor-version CARD8)
                  (-pad #(2 BYTE))))

— X Struct: (MIT-SCREEN-SAVER SelectInput req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (event-mask CARD32)))

— X Struct: (MIT-SCREEN-SAVER SetAttributes req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (x INT16)
                  (y INT16)
                  (width CARD16)
                  (height CARD16)
                  (border-width CARD16)
                  (class BYTE)
                  (depth CARD8)
                  (visual VISUALID)
                  (value-mask CARD32))
           (array (value-list #(value-mask CARD32 mask))))

— X Struct: (MIT-SCREEN-SAVER Suspend req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (suspend BOOL)
                  (-pad #(3 BYTE))))

— X Struct: (MIT-SCREEN-SAVER UnsetAttributes req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (drawable DRAWABLE)))

— X Struct: (MIT-SHM Attach req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (shmseg (MIT-SHM SEG))
                  (shmid CARD32)
                  (read-only BOOL)))

— X Struct: (MIT-SHM BadSeg err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (MIT-SHM Completion ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (drawable DRAWABLE)
                  (shmseg (MIT-SHM SEG))
                  (minor-event CARD16)
                  (major-event BYTE)
                  (-pad #(1 BYTE))
                  (offset CARD32)
                  (%pad #(12 BYTE))))

— X Struct: (MIT-SHM CreatePixmap req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (pid PIXMAP)
                  (drawable DRAWABLE)
                  (width CARD16)
                  (height CARD16)
                  (depth CARD8)
                  (-pad #(3 BYTE))
                  (shmseg (MIT-SHM SEG))
                  (offset CARD32)))

— X Struct: (MIT-SHM Detach req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (shmseg (MIT-SHM SEG))))

— X Struct: (MIT-SHM GetImage ans)

          ((fixed (%status CARD8)
                  (depth CARD8)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (visual VISUALID)
                  (size CARD32)
                  (%pad #(16 BYTE))))

— X Struct: (MIT-SHM GetImage req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (x INT16)
                  (y INT16)
                  (width CARD16)
                  (height CARD16)
                  (plane-mask CARD32)
                  (format CARD8)
                  (-pad #(3 BYTE))
                  (shmseg (MIT-SHM SEG))
                  (offset CARD32)))

— X Struct: (MIT-SHM PutImage req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (gc GCONTEXT)
                  (total-width CARD16)
                  (total-height CARD16)
                  (src-x CARD16)
                  (src-y CARD16)
                  (src-width CARD16)
                  (src-height CARD16)
                  (dst-x INT16)
                  (dst-y INT16)
                  (depth CARD8)
                  (format CARD8)
                  (send-event CARD8)
                  (-pad #(1 BYTE))
                  (shmseg (MIT-SHM SEG))
                  (offset CARD32)))

— X Struct: (MIT-SHM QueryVersion ans)

          ((fixed (%status CARD8)
                  (shared-pixmaps BOOL)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (major-version CARD16)
                  (minor-version CARD16)
                  (uid CARD16)
                  (gid CARD16)
                  (pixmap-format CARD8)
                  (%pad #(15 BYTE))))

— X Struct: (MIT-SHM QueryVersion req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)))

— X Struct: (MapNotify ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (event WINDOW)
                  (window WINDOW)
                  (override-redirect BOOL)
                  (%pad #(19 BYTE))))

— X Struct: (MapRequest ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (parent WINDOW)
                  (window WINDOW)
                  (%pad #(20 BYTE))))

— X Struct: (MapSubwindows req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (window WINDOW)))

— X Struct: (MapWindow req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (window WINDOW)))

— X Struct: (MappingNotify ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (request BYTE)
                  (first-keycode KEYCODE)
                  (count CARD8)
                  (%pad #(25 BYTE))))

— X Struct: (Match err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (MotionNotify ev)

          ((fixed (%code CARD8)
                  (detail BYTE)
                  (%sequence-number CARD16)
                  (time TIMESTAMP)
                  (root WINDOW)
                  (event WINDOW)
                  (child WINDOW)
                  (root-x INT16)
                  (root-y INT16)
                  (event-x INT16)
                  (event-y INT16)
                  (state CARD16)
                  (same-screen BOOL)
                  (%pad #(1 BYTE))))

— X Struct: (Name err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (NoExposure ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (drawable DRAWABLE)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (NoOperation req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)))

— X Struct: (OpenFont req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (fid FONT)
                  (name-len CARD16))
           (array (name #(name-len char))))

— X Struct: (Pixmap err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (PolyArc req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (gc GCONTEXT))
           (array (arcs #(#f ARC))))

— X Struct: (PolyFillArc req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (gc GCONTEXT))
           (array (arcs #(#f ARC))))

— X Struct: (PolyFillRectangle req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (gc GCONTEXT))
           (array (rectangles #(#f RECTANGLE))))

— X Struct: (PolyLine req)

          ((fixed (%major-opcode CARD8)
                  (coordinate-mode BYTE)
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (gc GCONTEXT))
           (array (points #(#f POINT))))

— X Struct: (PolyPoint req)

          ((fixed (%major-opcode CARD8)
                  (coordinate-mode BYTE)
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (gc GCONTEXT))
           (array (points #(#f POINT))))

— X Struct: (PolyRectangle req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (gc GCONTEXT))
           (array (rectangles #(#f RECTANGLE))))

— X Struct: (PolySegment req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (gc GCONTEXT))
           (array (segments #(#f SEGMENT))))

— X Struct: (PolyText16 req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (gc GCONTEXT)
                  (x INT16)
                  (y INT16))
           (array (items #(#f BYTE))))

— X Struct: (PolyText8 req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (gc GCONTEXT)
                  (x INT16)
                  (y INT16))
           (array (items #(#f BYTE))))

— X Struct: (PropertyNotify ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (window WINDOW)
                  (atom ATOM)
                  (time TIMESTAMP)
                  (state BYTE)
                  (%pad #(15 BYTE))))

— X Struct: (PutImage req)

          ((fixed (%major-opcode CARD8)
                  (format CARD8)
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (gc GCONTEXT)
                  (width CARD16)
                  (height CARD16)
                  (dst-x INT16)
                  (dst-y INT16)
                  (left-pad CARD8)
                  (depth CARD8))
           (array (data #(#f BYTE))))

— X Struct: (QueryBestSize ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (width CARD16)
                  (height CARD16)
                  (%pad #(20 BYTE))))

— X Struct: (QueryBestSize req)

          ((fixed (%major-opcode CARD8)
                  (class CARD8)
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (width CARD16)
                  (height CARD16)))

— X Struct: (QueryColors ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (colors-len CARD16)
                  (-pad #(22 BYTE)))
           (array (colors #(colors-len RGB))))

— X Struct: (QueryColors req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (cmap COLORMAP))
           (array (pixels #(#f CARD32))))

— X Struct: (QueryExtension ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (present BOOL)
                  (major-opcode CARD8)
                  (first-event CARD8)
                  (first-error CARD8)
                  (%pad #(20 BYTE))))

— X Struct: (QueryExtension req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (name-len CARD16))
           (array (name #(name-len char))))

— X Struct: (QueryFont ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (min-bounds CHARINFO)
                  (-pad #(4 BYTE))
                  (max-bounds CHARINFO)
                  (-pad #(4 BYTE))
                  (min-char-or-byte2 CARD16)
                  (max-char-or-byte2 CARD16)
                  (default-char CARD16)
                  (properties-len CARD16)
                  (draw-direction BYTE)
                  (min-byte1 CARD8)
                  (max-byte1 CARD8)
                  (all-chars-exist BOOL)
                  (font-ascent INT16)
                  (font-descent INT16)
                  (char-infos-len CARD32))
           (array (properties #(properties-len FONTPROP)))
           (array (char-infos #(char-infos-len CHARINFO))))

— X Struct: (QueryFont req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (font FONTABLE)))

— X Struct: (QueryKeymap ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (keys #(32 CARD8))))

— X Struct: (QueryKeymap req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)))

— X Struct: (QueryPointer ans)

          ((fixed (%status CARD8)
                  (same-screen BOOL)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (root WINDOW)
                  (child WINDOW)
                  (root-x INT16)
                  (root-y INT16)
                  (win-x INT16)
                  (win-y INT16)
                  (mask CARD16)
                  (%pad #(6 BYTE))))

— X Struct: (QueryPointer req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (window WINDOW)))

— X Struct: (QueryTextExtents ans)

          ((fixed (%status CARD8)
                  (draw-direction BYTE)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (font-ascent INT16)
                  (font-descent INT16)
                  (overall-ascent INT16)
                  (overall-descent INT16)
                  (overall-width INT32)
                  (overall-left INT32)
                  (overall-right INT32)
                  (%pad #(4 BYTE))))

— X Struct: (QueryTextExtents req)

          ((fixed (%major-opcode CARD8)
                  (odd-length BOOL (logand string-len 1))
                  (%length CARD16)
                  (font FONTABLE))
           (array (string #(#f CHAR2B))))

— X Struct: (QueryTree ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (root WINDOW)
                  (parent WINDOW)
                  (children-len CARD16)
                  (-pad #(14 BYTE)))
           (array (children #(children-len WINDOW))))

— X Struct: (QueryTree req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (window WINDOW)))

— X Struct: (RANDR GetScreenInfo ans)

          ((fixed (%status CARD8)
                  (rotations CARD8)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (root WINDOW)
                  (timestamp TIMESTAMP)
                  (config-timestamp TIMESTAMP)
                  (nSizes CARD16)
                  (sizeID CARD16)
                  (rotation INT16)
                  (rate CARD16)
                  (nInfo CARD16)
                  (-pad #(2 BYTE)))
           (array (sizes #(nSizes (RANDR ScreenSize))))
           (array (rates #((/ (- nInfo nSizes) #f) RefreshRates))))

— X Struct: (RANDR GetScreenInfo req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (window WINDOW)))

— X Struct: (RANDR QueryVersion ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (major-version CARD32)
                  (minor-version CARD32)
                  (-pad #(16 BYTE))))

— X Struct: (RANDR QueryVersion req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (major-version CARD32)
                  (minor-version CARD32)))

— X Struct: (RANDR RefreshRates)

          ((fixed (nRates CARD16))
           (array (rates #(nRates CARD16))))

— X Struct: (RANDR ScreenChangeNotify ev)

          ((fixed (%code CARD8)
                  (rotation CARD8)
                  (%sequence-number CARD16)
                  (timestamp TIMESTAMP)
                  (config-timestamp TIMESTAMP)
                  (root WINDOW)
                  (request-window WINDOW)
                  (sizeID CARD16)
                  (subpixel-order CARD16)
                  (width INT16)
                  (height INT16)
                  (mwidth INT16)
                  (mheight INT16)))

— X Struct: (RANDR ScreenSize)

          ((fixed (width INT16)
                  (height INT16)
                  (mwidth INT16)
                  (mheight INT16)))

— X Struct: (RANDR SelectInput req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (window WINDOW)
                  (enable CARD16)
                  (-pad #(2 BYTE))))

— X Struct: (RANDR SetScreenConfig ans)

          ((fixed (%status CARD8)
                  (status CARD8)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (new-timestamp TIMESTAMP)
                  (config-timestamp TIMESTAMP)
                  (root WINDOW)
                  (subpixel-order CARD16)
                  (-pad #(10 BYTE))))

— X Struct: (RANDR SetScreenConfig req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (drawable DRAWABLE)
                  (timestamp TIMESTAMP)
                  (config-timestamp TIMESTAMP)
                  (sizeID CARD16)
                  (rotation INT16)
                  (rate CARD16)
                  (-pad #(2 BYTE))))

— X Struct: (RECORD BadContext err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (invalid-record CARD32)
                  (%pad #(24 BYTE))))

— X Struct: (RECORD ClientInfo)

          ((fixed (client-resource (RECORD ClientSpec))
                  (num-ranges CARD32))
           (array (ranges #(num-ranges (RECORD Range)))))

— X Struct: (RECORD CreateContext req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context (RECORD CONTEXT))
                  (element-header (RECORD ElementHeader))
                  (-pad #(3 BYTE))
                  (num-client-specs CARD32)
                  (num-ranges CARD32))
           (array (client-specs
                    #(num-client-specs (RECORD ClientSpec))))
           (array (ranges #(num-ranges (RECORD Range)))))

— X Struct: (RECORD DisableContext req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context (RECORD CONTEXT))))

— X Struct: (RECORD EnableContext ans)

          ((fixed (%status CARD8)
                  (category CARD8)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (element-header (RECORD ElementHeader))
                  (client-swapped BOOL)
                  (-pad #(2 BYTE))
                  (xid-base CARD32)
                  (server-time CARD32)
                  (rec-sequence-num CARD32)
                  (-pad #(8 BYTE)))
           (array (data #(#f BYTE))))

— X Struct: (RECORD EnableContext req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context (RECORD CONTEXT))))

— X Struct: (RECORD ExtRange)

          ((fixed (major (RECORD Range8))
                  (minor (RECORD Range16))))

— X Struct: (RECORD FreeContext req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context (RECORD CONTEXT))))

— X Struct: (RECORD GetContext ans)

          ((fixed (%status CARD8)
                  (enabled BOOL)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (element-header (RECORD ElementHeader))
                  (-pad #(3 BYTE))
                  (num-intercepted-clients CARD32)
                  (-pad #(16 BYTE)))
           (array (intercepted-clients
                    #(num-intercepted-clients ClientInfo))))

— X Struct: (RECORD GetContext req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context (RECORD CONTEXT))))

— X Struct: (RECORD QueryVersion ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (major-version CARD16)
                  (minor-version CARD16)
                  (%pad #(20 BYTE))))

— X Struct: (RECORD QueryVersion req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (major-version CARD16)
                  (minor-version CARD16)))

— X Struct: (RECORD Range)

          ((fixed (core-requests (RECORD Range8))
                  (core-replies (RECORD Range8))
                  (ext-requests (RECORD ExtRange))
                  (ext-replies (RECORD ExtRange))
                  (delivered-events (RECORD Range8))
                  (device-events (RECORD Range8))
                  (errors (RECORD Range8))
                  (client-started BOOL)
                  (client-died BOOL)))

— X Struct: (RECORD Range16)

          ((fixed (first CARD16) (last CARD16)))

— X Struct: (RECORD Range8)

          ((fixed (first CARD8) (last CARD8)))

— X Struct: (RECORD RegisterClients req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context (RECORD CONTEXT))
                  (element-header (RECORD ElementHeader))
                  (-pad #(3 BYTE))
                  (num-client-specs CARD32)
                  (num-ranges CARD32))
           (array (client-specs
                    #(num-client-specs (RECORD ClientSpec))))
           (array (ranges #(num-ranges (RECORD Range)))))

— X Struct: (RECORD UnregisterClients req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (context (RECORD CONTEXT))
                  (num-client-specs CARD32))
           (array (client-specs
                    #(num-client-specs (RECORD ClientSpec)))))

— X Struct: (RENDER ANIMCURSORELT)

          ((fixed (cursor CURSOR) (delay CARD32)))

— X Struct: (RENDER AddGlyphs req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (glyphset (RENDER GLYPHSET))
                  (glyphs-len CARD32))
           (array (glyphids #(glyphs-len CARD32)))
           (array (glyphs #(glyphs-len (RENDER GLYPHINFO))))
           (array (data #(#f BYTE))))

— X Struct: (RENDER AddTraps req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (picture (RENDER PICTURE))
                  (x-off INT16)
                  (y-off INT16))
           (array (traps #(#f (RENDER TRAP)))))

— X Struct: (RENDER COLOR)

          ((fixed (red CARD16)
                  (green CARD16)
                  (blue CARD16)
                  (alpha CARD16)))

— X Struct: (RENDER ChangePicture req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (picture (RENDER PICTURE))
                  (value-mask CARD32))
           (array (value-list #(value-mask CARD32 mask))))

— X Struct: (RENDER Composite req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (op CARD8)
                  (-pad #(3 BYTE))
                  (src (RENDER PICTURE))
                  (mask (RENDER PICTURE))
                  (dst (RENDER PICTURE))
                  (src-x INT16)
                  (src-y INT16)
                  (mask-x INT16)
                  (mask-y INT16)
                  (dst-x INT16)
                  (dst-y INT16)
                  (width CARD16)
                  (height CARD16)))

— X Struct: (RENDER CompositeGlyphs16 req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (op CARD8)
                  (-pad #(3 BYTE))
                  (src (RENDER PICTURE))
                  (dst (RENDER PICTURE))
                  (mask-format (RENDER PICTFORMAT))
                  (glyphset (RENDER GLYPHSET))
                  (src-x INT16)
                  (src-y INT16))
           (array (glyphcmds #(#f BYTE))))

— X Struct: (RENDER CompositeGlyphs32 req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (op CARD8)
                  (-pad #(3 BYTE))
                  (src (RENDER PICTURE))
                  (dst (RENDER PICTURE))
                  (mask-format (RENDER PICTFORMAT))
                  (glyphset (RENDER GLYPHSET))
                  (src-x INT16)
                  (src-y INT16))
           (array (glyphcmds #(#f BYTE))))

— X Struct: (RENDER CompositeGlyphs8 req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (op CARD8)
                  (-pad #(3 BYTE))
                  (src (RENDER PICTURE))
                  (dst (RENDER PICTURE))
                  (mask-format (RENDER PICTFORMAT))
                  (glyphset (RENDER GLYPHSET))
                  (src-x INT16)
                  (src-y INT16))
           (array (glyphcmds #(#f BYTE))))

— X Struct: (RENDER CreateAnimCursor req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (cid CURSOR))
           (array (cursors #(#f (RENDER ANIMCURSORELT)))))

— X Struct: (RENDER CreateConicalGradient req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (picture (RENDER PICTURE))
                  (center (RENDER POINTFIX))
                  (angle (RENDER FIXED))
                  (num-stops CARD32)))

— X Struct: (RENDER CreateCursor req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (cid CURSOR)
                  (source (RENDER PICTURE))
                  (x CARD16)
                  (y CARD16)))

— X Struct: (RENDER CreateGlyphSet req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (gsid (RENDER GLYPHSET))
                  (format (RENDER PICTFORMAT))))

— X Struct: (RENDER CreateLinearGradient req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (picture (RENDER PICTURE))
                  (p1 (RENDER POINTFIX))
                  (p2 (RENDER POINTFIX))
                  (num-stops CARD32)))

— X Struct: (RENDER CreatePicture req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (pid (RENDER PICTURE))
                  (drawable DRAWABLE)
                  (format (RENDER PICTFORMAT))
                  (value-mask CARD32))
           (array (value-list #(value-mask CARD32 mask))))

— X Struct: (RENDER CreateRadialGradient req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (picture (RENDER PICTURE))
                  (inner (RENDER POINTFIX))
                  (outer (RENDER POINTFIX))
                  (inner-radius (RENDER FIXED))
                  (outer-radius (RENDER FIXED))
                  (num-stops CARD32)))

— X Struct: (RENDER CreateSolidFill req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (picture (RENDER PICTURE))
                  (color (RENDER COLOR))))

— X Struct: (RENDER DIRECTFORMAT)

          ((fixed (red-shift CARD16)
                  (red-mask CARD16)
                  (green-shift CARD16)
                  (green-mask CARD16)
                  (blue-shift CARD16)
                  (blue-mask CARD16)
                  (alpha-shift CARD16)
                  (alpha-mask CARD16)))

— X Struct: (RENDER FillRectangles req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (op CARD8)
                  (-pad #(3 BYTE))
                  (dst (RENDER PICTURE))
                  (color (RENDER COLOR)))
           (array (rects #(#f RECTANGLE))))

— X Struct: (RENDER FreeGlyphSet req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (glyphset (RENDER GLYPHSET))))

— X Struct: (RENDER FreeGlyphs req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (glyphset (RENDER GLYPHSET)))
           (array (glyphs #(#f (RENDER GLYPH)))))

— X Struct: (RENDER FreePicture req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (picture (RENDER PICTURE))))

— X Struct: (RENDER GLYPHINFO)

          ((fixed (width CARD16)
                  (height CARD16)
                  (x INT16)
                  (y INT16)
                  (x-off INT16)
                  (y-off INT16)))

— X Struct: (RENDER Glyph err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (%pad #(28 BYTE))))

— X Struct: (RENDER GlyphSet err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (%pad #(28 BYTE))))

— X Struct: (RENDER INDEXVALUE)

          ((fixed (pixel CARD32)
                  (red CARD16)
                  (green CARD16)
                  (blue CARD16)
                  (alpha CARD16)))

— X Struct: (RENDER LINEFIX)

          ((fixed (p1 (RENDER POINTFIX))
                  (p2 (RENDER POINTFIX))))

— X Struct: (RENDER PICTDEPTH)

          ((fixed (depth CARD8)
                  (-pad #(1 BYTE))
                  (num-visuals CARD16)
                  (-pad #(4 BYTE)))
           (array (visuals #(num-visuals (RENDER PICTVISUAL)))))

— X Struct: (RENDER PICTFORMINFO)

          ((fixed (id (RENDER PICTFORMAT))
                  (type CARD8)
                  (depth CARD8)
                  (-pad #(2 BYTE))
                  (direct (RENDER DIRECTFORMAT))
                  (colormap COLORMAP)))

— X Struct: (RENDER PICTSCREEN)

          ((fixed (num-depths CARD32)
                  (fallback (RENDER PICTFORMAT)))
           (array (depths #(num-depths PICTDEPTH))))

— X Struct: (RENDER PICTVISUAL)

          ((fixed (visual VISUALID)
                  (format (RENDER PICTFORMAT))))

— X Struct: (RENDER POINTFIX)

          ((fixed (x (RENDER FIXED)) (y (RENDER FIXED))))

— X Struct: (RENDER PictFormat err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (%pad #(28 BYTE))))

— X Struct: (RENDER PictOp err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (%pad #(28 BYTE))))

— X Struct: (RENDER Picture err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (%pad #(28 BYTE))))

— X Struct: (RENDER QueryFilters ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (num-aliases CARD32)
                  (num-filters CARD32)
                  (-pad #(16 BYTE)))
           (array (aliases #(num-aliases CARD16)))
           (array (filters #(num-filters STR))))

— X Struct: (RENDER QueryFilters req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (drawable DRAWABLE)))

— X Struct: (RENDER QueryPictFormats ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (num-formats CARD32)
                  (num-screens CARD32)
                  (num-depths CARD32)
                  (num-visuals CARD32)
                  (num-subpixel CARD32)
                  (-pad #(4 BYTE)))
           (array (formats #(num-formats (RENDER PICTFORMINFO))))
           (array (screens #(num-screens PICTSCREEN)))
           (array (subpixels #(num-subpixel CARD32))))

— X Struct: (RENDER QueryPictFormats req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)))

— X Struct: (RENDER QueryPictIndexValues ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (num-values CARD32)
                  (-pad #(20 BYTE)))
           (array (values #(num-values (RENDER INDEXVALUE)))))

— X Struct: (RENDER QueryPictIndexValues req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (format (RENDER PICTFORMAT))))

— X Struct: (RENDER QueryVersion ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (major-version CARD32)
                  (minor-version CARD32)
                  (-pad #(16 BYTE))))

— X Struct: (RENDER QueryVersion req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (client-major-version CARD32)
                  (client-minor-version CARD32)))

— X Struct: (RENDER ReferenceGlyphSet req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (gsid (RENDER GLYPHSET))
                  (existing (RENDER GLYPHSET))))

— X Struct: (RENDER SPANFIX)

          ((fixed (l (RENDER FIXED))
                  (r (RENDER FIXED))
                  (y (RENDER FIXED))))

— X Struct: (RENDER SetPictureClipRectangles req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (picture (RENDER PICTURE))
                  (clip-x-origin INT16)
                  (clip-y-origin INT16))
           (array (rectangles #(#f RECTANGLE))))

— X Struct: (RENDER SetPictureFilter req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (picture (RENDER PICTURE))
                  (filter-len CARD16))
           (array (filter #(filter-len char)))
           (array (values #(#f (RENDER FIXED)))))

— X Struct: (RENDER SetPictureTransform req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (picture (RENDER PICTURE))
                  (transform (RENDER TRANSFORM))))

— X Struct: (RENDER TRANSFORM)

          ((fixed (matrix11 (RENDER FIXED))
                  (matrix12 (RENDER FIXED))
                  (matrix13 (RENDER FIXED))
                  (matrix21 (RENDER FIXED))
                  (matrix22 (RENDER FIXED))
                  (matrix23 (RENDER FIXED))
                  (matrix31 (RENDER FIXED))
                  (matrix32 (RENDER FIXED))
                  (matrix33 (RENDER FIXED))))

— X Struct: (RENDER TRAP)

          ((fixed (top (RENDER SPANFIX))
                  (bot (RENDER SPANFIX))))

— X Struct: (RENDER TRAPEZOID)

          ((fixed (top (RENDER FIXED))
                  (bottom (RENDER FIXED))
                  (left (RENDER LINEFIX))
                  (right (RENDER LINEFIX))))

— X Struct: (RENDER TRIANGLE)

          ((fixed (p1 (RENDER POINTFIX))
                  (p2 (RENDER POINTFIX))
                  (p3 (RENDER POINTFIX))))

— X Struct: (RENDER Trapezoids req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (op CARD8)
                  (-pad #(3 BYTE))
                  (src (RENDER PICTURE))
                  (dst (RENDER PICTURE))
                  (mask-format (RENDER PICTFORMAT))
                  (src-x INT16)
                  (src-y INT16))
           (array (traps #(#f (RENDER TRAPEZOID)))))

— X Struct: (RENDER TriFan req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (op CARD8)
                  (-pad #(3 BYTE))
                  (src (RENDER PICTURE))
                  (dst (RENDER PICTURE))
                  (mask-format (RENDER PICTFORMAT))
                  (src-x INT16)
                  (src-y INT16))
           (array (points #(#f (RENDER POINTFIX)))))

— X Struct: (RENDER TriStrip req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (op CARD8)
                  (-pad #(3 BYTE))
                  (src (RENDER PICTURE))
                  (dst (RENDER PICTURE))
                  (mask-format (RENDER PICTFORMAT))
                  (src-x INT16)
                  (src-y INT16))
           (array (points #(#f (RENDER POINTFIX)))))

— X Struct: (RENDER Triangles req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (op CARD8)
                  (-pad #(3 BYTE))
                  (src (RENDER PICTURE))
                  (dst (RENDER PICTURE))
                  (mask-format (RENDER PICTFORMAT))
                  (src-x INT16)
                  (src-y INT16))
           (array (triangles #(#f (RENDER TRIANGLE)))))

— X Struct: (RecolorCursor req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (cursor CURSOR)
                  (fore-red CARD16)
                  (fore-green CARD16)
                  (fore-blue CARD16)
                  (back-red CARD16)
                  (back-green CARD16)
                  (back-blue CARD16)))

— X Struct: (ReparentNotify ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (event WINDOW)
                  (window WINDOW)
                  (parent WINDOW)
                  (x INT16)
                  (y INT16)
                  (override-redirect BOOL)
                  (%pad #(11 BYTE))))

— X Struct: (ReparentWindow req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (window WINDOW)
                  (parent WINDOW)
                  (x INT16)
                  (y INT16)))

— X Struct: (Request err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (ResizeRequest ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (window WINDOW)
                  (width CARD16)
                  (height CARD16)
                  (%pad #(20 BYTE))))

— X Struct: (RotateProperties req)

          ((fixed (%major-opcode CARD8)
                  (window WINDOW)
                  (%length CARD16)
                  (atoms-len CARD16)
                  (delta INT16))
           (array (atoms #(atoms-len ATOM))))

— X Struct: (SHAPE Combine req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (operation (SHAPE OP))
                  (destination-kind (SHAPE KIND))
                  (source-kind (SHAPE KIND))
                  (-pad #(1 BYTE))
                  (destination-window WINDOW)
                  (x-offset INT16)
                  (y-offset INT16)
                  (source-window WINDOW)))

— X Struct: (SHAPE GetRectangles ans)

          ((fixed (%status CARD8)
                  (ordering BYTE)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (rectangles-len CARD32))
           (array (rectangles #(rectangles-len RECTANGLE))))

— X Struct: (SHAPE GetRectangles req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (window WINDOW)
                  (source-kind (SHAPE KIND))))

— X Struct: (SHAPE InputSelected ans)

          ((fixed (%status CARD8)
                  (enabled BOOL)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (%pad #(24 BYTE))))

— X Struct: (SHAPE InputSelected req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (destination-window WINDOW)))

— X Struct: (SHAPE Mask req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (operation (SHAPE OP))
                  (destination-kind (SHAPE KIND))
                  (-pad #(2 BYTE))
                  (destination-window WINDOW)
                  (x-offset INT16)
                  (y-offset INT16)
                  (source-bitmap PIXMAP)))

— X Struct: (SHAPE Notify ev)

          ((fixed (%code CARD8)
                  (shape-kind (SHAPE KIND))
                  (%sequence-number CARD16)
                  (affected-window WINDOW)
                  (extents-x INT16)
                  (extents-y INT16)
                  (extents-width CARD16)
                  (extents-height CARD16)
                  (server-time TIMESTAMP)
                  (shaped BOOL)
                  (%pad #(11 BYTE))))

— X Struct: (SHAPE Offset req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (destination-kind (SHAPE KIND))
                  (-pad #(3 BYTE))
                  (destination-window WINDOW)
                  (x-offset INT16)
                  (y-offset INT16)))

— X Struct: (SHAPE QueryExtents ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (bounding-shaped BOOL)
                  (clip-shaped BOOL)
                  (-pad #(2 BYTE))
                  (bounding-shape-extents-x INT16)
                  (bounding-shape-extents-y INT16)
                  (bounding-shape-extents-width CARD16)
                  (bounding-shape-extents-height CARD16)
                  (clip-shape-extents-x INT16)
                  (clip-shape-extents-y INT16)
                  (clip-shape-extents-width CARD16)
                  (clip-shape-extents-height CARD16)
                  (%pad #(4 BYTE))))

— X Struct: (SHAPE QueryExtents req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (destination-window WINDOW)))

— X Struct: (SHAPE QueryVersion ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (major-version CARD16)
                  (minor-version CARD16)
                  (%pad #(20 BYTE))))

— X Struct: (SHAPE QueryVersion req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)))

— X Struct: (SHAPE Rectangles req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (operation (SHAPE OP))
                  (destination-kind (SHAPE KIND))
                  (ordering BYTE)
                  (-pad #(1 BYTE))
                  (destination-window WINDOW)
                  (x-offset INT16)
                  (y-offset INT16))
           (array (rectangles #(#f RECTANGLE))))

— X Struct: (SHAPE SelectInput req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (destination-window WINDOW)
                  (enable BOOL)))

— X Struct: (SYNC Alarm err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-alarm CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (SYNC AlarmNotify ev)

          ((fixed (%code CARD8)
                  (kind CARD8)
                  (%sequence-number CARD16)
                  (alarm (SYNC ALARM))
                  (counter-value (SYNC INT64))
                  (alarm-value (SYNC INT64))
                  (timestamp TIMESTAMP)
                  (%pad #(4 BYTE))))

— X Struct: (SYNC Await req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16))
           (array (wait-list #(#f (SYNC WAITCONDITION)))))

— X Struct: (SYNC ChangeAlarm req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (id (SYNC ALARM))
                  (value-mask CARD32))
           (array (value-list #(value-mask CARD32 mask))))

— X Struct: (SYNC ChangeCounter req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (counter (SYNC COUNTER))
                  (amount (SYNC INT64))))

— X Struct: (SYNC Counter err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-counter CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (SYNC CounterNotify ev)

          ((fixed (%code CARD8)
                  (kind CARD8)
                  (%sequence-number CARD16)
                  (counter (SYNC COUNTER))
                  (wait-value (SYNC INT64))
                  (counter-value (SYNC INT64))
                  (timestamp TIMESTAMP)
                  (count CARD16)
                  (destroyed BOOL)
                  (%pad #(1 BYTE))))

— X Struct: (SYNC CreateAlarm req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (id (SYNC ALARM))
                  (value-mask CARD32))
           (array (value-list #(value-mask CARD32 mask))))

— X Struct: (SYNC CreateCounter req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (id (SYNC COUNTER))
                  (initial-value (SYNC INT64))))

— X Struct: (SYNC DestroyAlarm req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (alarm (SYNC ALARM))))

— X Struct: (SYNC DestroyCounter req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (counter (SYNC COUNTER))))

— X Struct: (SYNC GetPriority ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (priority INT32)
                  (%pad #(20 BYTE))))

— X Struct: (SYNC GetPriority req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (id CARD32)))

— X Struct: (SYNC INT64)

          ((fixed (hi INT32) (lo CARD32)))

— X Struct: (SYNC Initialize ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (major-version CARD8)
                  (minor-version CARD8)
                  (%pad #(22 BYTE))))

— X Struct: (SYNC Initialize req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)))

— X Struct: (SYNC ListSystemCounters ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (counters-len CARD32)
                  (-pad #(20 BYTE)))
           (array (counters #(counters-len SYSTEMCOUNTER))))

— X Struct: (SYNC ListSystemCounters req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)))

— X Struct: (SYNC QueryAlarm ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (trigger (SYNC TRIGGER))
                  (delta (SYNC INT64))
                  (events BOOL)
                  (state (SYNC ALARMSTATE))))

— X Struct: (SYNC QueryAlarm req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (alarm (SYNC ALARM))))

— X Struct: (SYNC QueryCounter ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (counter-value (SYNC INT64))
                  (%pad #(16 BYTE))))

— X Struct: (SYNC QueryCounter req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (counter (SYNC COUNTER))))

— X Struct: (SYNC SYSTEMCOUNTER)

          ((fixed (counter (SYNC COUNTER))
                  (resolution (SYNC INT64))
                  (name-len CARD16))
           (array (name #(name-len CARD8))))

— X Struct: (SYNC SetCounter req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (counter (SYNC COUNTER))
                  (value (SYNC INT64))))

— X Struct: (SYNC SetPriority req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (id CARD32)
                  (priority INT32)))

— X Struct: (SYNC TRIGGER)

          ((fixed (counter (SYNC COUNTER))
                  (wait-type (SYNC VALUETYPE))
                  (wait-value (SYNC INT64))
                  (test-type (SYNC TESTTYPE))))

— X Struct: (SYNC WAITCONDITION)

          ((fixed (trigger (SYNC TRIGGER))
                  (event-threshold (SYNC INT64))))

— X Struct: (SelectionClear ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (time TIMESTAMP)
                  (owner WINDOW)
                  (selection ATOM)
                  (%pad #(16 BYTE))))

— X Struct: (SelectionNotify ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (time TIMESTAMP)
                  (requestor WINDOW)
                  (selection ATOM)
                  (target ATOM)
                  (property ATOM)
                  (%pad #(8 BYTE))))

— X Struct: (SelectionRequest ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (time TIMESTAMP)
                  (owner WINDOW)
                  (requestor WINDOW)
                  (selection ATOM)
                  (target ATOM)
                  (property ATOM)
                  (%pad #(4 BYTE))))

— X Struct: (SendEvent req)

          ((fixed (%major-opcode CARD8)
                  (propagate BOOL)
                  (%length CARD16)
                  (destination WINDOW)
                  (event-mask CARD32)
                  (event #(32 char))))

— X Struct: (SetAccessControl req)

          ((fixed (%major-opcode CARD8)
                  (mode CARD8)
                  (%length CARD16)))

— X Struct: (SetClipRectangles req)

          ((fixed (%major-opcode CARD8)
                  (ordering BYTE)
                  (%length CARD16)
                  (gc GCONTEXT)
                  (clip-x-origin INT16)
                  (clip-y-origin INT16))
           (array (rectangles #(#f RECTANGLE))))

— X Struct: (SetCloseDownMode req)

          ((fixed (%major-opcode CARD8)
                  (mode CARD8)
                  (%length CARD16)))

— X Struct: (SetDashes req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (gc GCONTEXT)
                  (dash-offset CARD16)
                  (dashes-len CARD16))
           (array (dashes #(dashes-len CARD8))))

— X Struct: (SetFontPath req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (font-qty CARD16))
           (array (path #(#f char))))

— X Struct: (SetInputFocus req)

          ((fixed (%major-opcode CARD8)
                  (revert-to CARD8)
                  (%length CARD16)
                  (focus WINDOW)
                  (time TIMESTAMP)))

— X Struct: (SetModifierMapping ans)

          ((fixed (%status CARD8)
                  (status BYTE)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (%pad #(24 BYTE))))

— X Struct: (SetModifierMapping req)

          ((fixed (%major-opcode CARD8)
                  (keycodes-per-modifier CARD8)
                  (%length CARD16))
           (array (keycodes
                    #((/ (* keycodes-per-modifier 8) 1) KEYCODE))))

— X Struct: (SetPointerMapping ans)

          ((fixed (%status CARD8)
                  (status BYTE)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (%pad #(24 BYTE))))

— X Struct: (SetPointerMapping req)

          ((fixed (%major-opcode CARD8)
                  (map-len CARD8)
                  (%length CARD16))
           (array (map #(map-len CARD8))))

— X Struct: (SetScreenSaver req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (timeout INT16)
                  (interval INT16)
                  (prefer-blanking CARD8)
                  (allow-exposures CARD8)))

— X Struct: (SetSelectionOwner req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (owner WINDOW)
                  (selection ATOM)
                  (time TIMESTAMP)))

— X Struct: (StoreColors req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (cmap COLORMAP))
           (array (items #(#f COLORITEM))))

— X Struct: (StoreNamedColor req)

          ((fixed (%major-opcode CARD8)
                  (flags CARD8)
                  (%length CARD16)
                  (cmap COLORMAP)
                  (pixel CARD32)
                  (name-len CARD16))
           (array (name #(name-len char))))

— X Struct: (TranslateCoordinates ans)

          ((fixed (%status CARD8)
                  (same-screen BOOL)
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (child WINDOW)
                  (dst-x CARD16)
                  (dst-y CARD16)
                  (%pad #(16 BYTE))))

— X Struct: (TranslateCoordinates req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (src-window WINDOW)
                  (dst-window WINDOW)
                  (src-x INT16)
                  (src-y INT16)))

— X Struct: (UngrabButton req)

          ((fixed (%major-opcode CARD8)
                  (button CARD8)
                  (%length CARD16)
                  (grab-window WINDOW)
                  (modifiers CARD16)
                  (-pad #(2 BYTE))))

— X Struct: (UngrabKey req)

          ((fixed (%major-opcode CARD8)
                  (key KEYCODE)
                  (%length CARD16)
                  (grab-window WINDOW)
                  (modifiers CARD16)))

— X Struct: (UngrabKeyboard req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (time TIMESTAMP)))

— X Struct: (UngrabPointer req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (time TIMESTAMP)))

— X Struct: (UngrabServer req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)))

— X Struct: (UninstallColormap req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (cmap COLORMAP)))

— X Struct: (UnmapNotify ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (event WINDOW)
                  (window WINDOW)
                  (from-configure BOOL)
                  (%pad #(19 BYTE))))

— X Struct: (UnmapSubwindows req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (window WINDOW)))

— X Struct: (UnmapWindow req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (window WINDOW)))

— X Struct: (Value err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (VisibilityNotify ev)

          ((fixed (%code CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (window WINDOW)
                  (state BYTE)
                  (%pad #(23 BYTE))))

— X Struct: (WarpPointer req)

          ((fixed (%major-opcode CARD8)
                  (-pad #(1 BYTE))
                  (%length CARD16)
                  (src-window WINDOW)
                  (dst-window WINDOW)
                  (src-x INT16)
                  (src-y INT16)
                  (src-width CARD16)
                  (src-height CARD16)
                  (dst-x INT16)
                  (dst-y INT16)))

— X Struct: (Window err)

          ((fixed (%status CARD8)
                  (%hint CARD8)
                  (%sequence-number CARD16)
                  (bad-value CARD32)
                  (minor-opcode CARD16)
                  (major-opcode CARD8)
                  (%pad #(21 BYTE))))

— X Struct: (X-Resource Client)

          ((fixed (resource-base CARD32)
                  (resource-mask CARD32)))

— X Struct: (X-Resource QueryClientPixmapBytes ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (bytes CARD32)
                  (bytes-overflow CARD32)
                  (%pad #(16 BYTE))))

— X Struct: (X-Resource QueryClientPixmapBytes req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (xid CARD32)))

— X Struct: (X-Resource QueryClientResources ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (num-types CARD32)
                  (-pad #(20 BYTE)))
           (array (types #(num-types (X-Resource Type)))))

— X Struct: (X-Resource QueryClientResources req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (xid CARD32)))

— X Struct: (X-Resource QueryClients ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (num-clients CARD32)
                  (-pad #(20 BYTE)))
           (array (clients #(num-clients (X-Resource Client)))))

— X Struct: (X-Resource QueryClients req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)))

— X Struct: (X-Resource QueryVersion ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (server-major CARD16)
                  (server-minor CARD16)
                  (%pad #(20 BYTE))))

— X Struct: (X-Resource QueryVersion req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (client-major CARD8)
                  (client-minor CARD8)))

— X Struct: (X-Resource Type)

          ((fixed (resource-type CARD32) (count CARD32)))

— X Struct: (XC-MISC GetVersion ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (server-major-version CARD16)
                  (server-minor-version CARD16)
                  (%pad #(20 BYTE))))

— X Struct: (XC-MISC GetVersion req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (client-major-version CARD16)
                  (client-minor-version CARD16)))

— X Struct: (XC-MISC GetXIDList ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (ids-len CARD32)
                  (-pad #(20 BYTE)))
           (array (ids #(ids-len CARD32))))

— X Struct: (XC-MISC GetXIDList req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (count CARD32)))

— X Struct: (XC-MISC GetXIDRange ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (start-id CARD32)
                  (count CARD32)
                  (%pad #(16 BYTE))))

— X Struct: (XC-MISC GetXIDRange req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)))

— X Struct: (XEVIE End ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(24 BYTE))))

— X Struct: (XEVIE End req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (cmap CARD32)))

— X Struct: (XEVIE Event)

          ((fixed (-pad #(32 BYTE))))

— X Struct: (XEVIE QueryVersion ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (server-major-version CARD16)
                  (server-minor-version CARD16)
                  (-pad #(20 BYTE))))

— X Struct: (XEVIE QueryVersion req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (client-major-version CARD16)
                  (client-minor-version CARD16)))

— X Struct: (XEVIE SelectInput ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(24 BYTE))))

— X Struct: (XEVIE SelectInput req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (event-mask CARD32)))

— X Struct: (XEVIE Send ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(24 BYTE))))

— X Struct: (XEVIE Send req)

          ((fixed (%major-opcode CARD8)
                  (%minor-opcode CARD8)
                  (%length CARD16)
                  (event (XEVIE Event))
                  (data-type CARD32)
                  (-pad #(64 BYTE))))

— X Struct: (XEVIE Start ans)

          ((fixed (%status CARD8)
                  (-pad #(1 BYTE))
                  (%sequence-number CARD16)
                  (%reply-length CARD32)
                  (-pad #(24 BYTE))))