Do more to obscure ragel's private variables. Just a leading underscore is not
enough. Maybe something more like __ragel__internal__.

Allow machines to be used before their definition. Sometimes it's nice to
defined the machine in a top-down manner. This will require ragel to do
recursion and definition checking.

Now that actions are prevented from being duplicated in actions lists, if it
turns out that actions may sometimes need to be duplicated in an action list
then this can be accomodated by adding an "allowdups" options on actions.

If two states have the same EOF actions, they are written out in the finish
routine as separate cases when they can be included in one case.

Maybe support the one machine join? ( 'hello', ) or (, 'hello' )

Testing facilities: Quick easy way to query which strings are accepted.
Enumerate all accepted strings. From Nicholas Maxwell Lester.

Want to be able to return from the execute machine on matching a certain input.
Workaround: store the current state using fsm->_cs = ftargs; then return.
Should be built in.  Be sure to document the fact that following actions on the
same character are abandoned.  From Nicholas Maxwell Lester. 

Print graphviz transitions as characters, rather than numbers, makes it easier
to interpret the graph. Perhaps somehow support the printing of symbols? Must
not make it difficult to understand non-printable characters.

Documentation: add longest match kleene star operator.

Options are available on the command line settable from within the fsm
specification. This would allow different fsms to be compiled differently from
within the same source.

Add more examples, add more tests and write more documentation.

Better compression of table driven fsms. Can put functions and states in the
same array then a transitions can be variable size. After looking at the target
state if the next num is in the function range then there is a function,
otherwise it is part of the next transition.

A debugger would be nice. Ragel could emit a special debug version that
prompted for debug commands that allowed the user to step through the machine
and get details about where they are in their RL.

Perhaps finish() should be changed to eof() (the phrase finish is also used for
finishing transtions). Also, perhaps init should change to something else since
it can't be used for Objective C code.

Frontend should support long alphabets.

Language/code-style independent frontend that would allow anyone to adapt ragel
to their particual language and/or state machine execution model.

    Ragel would read in input files and translate state machine definitions
    and instantions into state data (lists of state numbers, transitions,
    actions, etc) and pass that and all other statements through to the
    output, which would be read and processed by the backend. Perhaps some
    regualr expression definitions could be used for defining the boundaries
    between the host language and ragel.  So if you've got a new language
    that uses %% as comments, you can change the ragel specification opening
    sequence to something else.

    Ragel would essentially translate:

    %% M {
      element Foo;
      alphtype unsigned int;
      main := 'hello there' @{ printf("done\n");};
    }

    To something like the following. Anything that is not used to generate
    the state tables can be passed through, allowing users to define their
    own commands to be used by the code generation backend.

    %% M {
      element Foo;
      alphtype unsigned int;
      states: 1 2 3 4 5 6;
      transitions: 1 3237 372 9345 23;
      actions:
      a1 1{...}
    }

    The task of generating the machine execution code is left to the Ragel
    backend program, or users could write their own using whatever tools
    they please.

    The advantage of this is that people with different requirments for
    acquiring state machine input and walking over it can write their own
    tools and generate code optimized to their own scenerio.

