AutoGen Addons

   This template collection will produce a finite state machine based on a
   description of such a machine.  The presumption is that you generally
   do not need to know what the current state is in order to determine what
   kind of transition is to be taken.  That is to say, there is a global
   transition table that is indexed by the current state and the next
   transition type to determine the next state and trigger any optional
   transition handling code.

   The finite state machine may be either the master, driving the other
   parts of the program, or act as a subroutine keeping track of state
   between calls.  Consequently, the "type" attribute may be set to:

   looping
       If the machine processes transitions until it reaches a terminal
       state (error or done).
   stepping
       If the FSM code will process a single transition and then return.
   reentrant
       This method is much the same as stepping, except that the caller
       must save the current state and provide it on the next call.
       In this fashion, an FSM may be used in a multi threaded application.

   The machine can be constructed in either of three formats, depending
   on the value of the "method" attribute:

   callout
       This method will use a callout table instead of a switch statement
       to implement the machine.
   case
       This is the alternate implementation method.
   none
       Do not supply the "method" attribute.  Choosing this will cause only
       the dispatch table to be created.  The implementation code is omitted.
       The "type" attribute is then ignored.

Files generated by the autofsm add-on:

    example-fsm.c
    example-fsm.h

Additional Files for autofsm:

autofsm/Makefile autofsm/example.def autofsm/fsm-macro.tpl autofsm/fsm-trans.tpl autofsm/run.sh

bits/bits.tpl

   This template produces a header file with an enumeration of all the defined
   bits.  If the bit collection fits in a 32 or 64 bit word, then the bit values
   will also be #defined.  A set of macros will also be defined for manipulating
   the bit collections.  The interface to these macros is consistent, even if
   the implementation has to resort to arrays of words to hold all the bits.
   (That is, if there are more than 64 bits.)

   Unless suppressed, a .c file is also produced with two routines for convert-
   ing from a list of bit names to a bit collection and back again.

Files generated by the bits add-on:

    b-test.c
    b-test.h

Additional Files for bits:

bits/Makefile bits/b-test.def bits/bit-test.tpl

char-mapper/char-mapper.tpl

   This program will take a list of character classes and convert them
   into bit map tests.  If all you ever need are "isspace" or "isalpha"
   or the other tests included in <ctype.h>, then by all means use that.
   On the other hand, if you find yourself writing code like:
      if (isalnum(*p) || (*p == '_'))
   Then this might be handy.

Files generated by the char-mapper add-on:

    cm-opt.c
    cm-opt.h
    test-cmap.h
    test-cmap.map

Additional Files for char-mapper:

char-mapper/Makefile char-mapper/char-mapper.c char-mapper/mk-opt-table.sh char-mapper/mk-str2enum.sh char-mapper/test.sh

config_edit/editor.tpl

   This template will produce a program that will process its configuration
   file and command line options, save the option state to its config file,
   and then signal its associated daemon file with a SIGHUP.  Included with
   this template are some auxialiary options and attributes in a file named
   "editor.def".

Files generated by the config_edit add-on:

    daemon-opts.c
    daemon-opts.h
    edit-daemon-conf.c
    edit-daemon-conf.h

Additional Files for config_edit:

config_edit/Makefile config_edit/daemon-opts.def config_edit/daemon.c config_edit/editor.def

dispatch/dispatch.tpl

   This template will produce a header file and one or two source files.
   You supply a list of commands as values for "cmd" and it will produce
   an enumeration of these commands and code that will match strings against
   these command names.  The input command name need only be as long as
   needed for a unique partial match.  For example, if there is only one
   command that starts with "x", then the single letter "x" is sufficient
   for a unique match.

Files generated by the dispatch add-on:

    greek-hdlr.c
    greek.c
    greek.h

Additional Files for dispatch:

dispatch/Makefile dispatch/greek.def dispatch/test-all.sh