[ See http://lcamtuf.coredump.cx/asmsh/ ]

I am soliciting for volunteers to participate or submit suggestions to a
crossover assembler (s)hell project, asmsh.

This is not a joke - we intend to provide a hard-core but powerful
interactive shell environment with line-by-line assembly execution and
generous convenience features. Such a shell is hardly a practical
interface for invoking PINE or creating a long sed/awk/grep sequence, but
has some value for a bunch of other reasons:

  - Provides a very efficient assembler learning tool with instant
    feedback and undo features,

  - Provides a powerful shell / test environment that makes it possible to
    access just about any library on the system with very little effort;
    this is usually nearly impossible in other popular shells, forcing
    the user to use not always particularly well-tailored executable
    interfaces, often with a considerable performance and security impact,

  - Provides a way to write assembly "scripts" interactively (with the
    ability to save the session to an ELF file), detecting fault
    conditions as early as possible,

  - Serves as a marvelous BOFH tool and can be used to amaze
    your friends or annoy your enemies ;-)

If you, find the concept amusing or interesting, and would like to
contribute some code or suggestions, we would truly appreciate your
feedback. Thanks.

The page for the project is http://lcamtuf.coredump.cx/asmsh/

Below is a quick overview of the main features we'd like to implement:

  - The ability to load libraries on the fly in the interactive mode,
    and to examine their APIs (perhaps with a convenient manpage
    access feature or .h-based parameter name hints),

  - An alternative call and int syntax that finds a prototype in system
    .h files, if available, and asks for parameters to push; automatic
    string "here" allocation:

    wb1> push addr_to_str1
    wb1> push 1
    wb1> call somefunction

    ...vs...

    wb1> @somefunction
    int count = ?
    char* text = "foo" or :label or :label "foo"

  - A limited undo capability (memory and registers, sans reverting the
    effects of certain syscalls) in the interactive mode.

  - History stored both in source and compiled form, current command
    write pointer advances in the code segment (but can be repositioned).
    This enables the user to re-execute or reference previous code,
    make changes, add tags and symbols for easier accessibility,
    all this without the need for copy and paste or such.

  - The shell provides an ability to work with several workbenches
    representing separate code blocks - for example, one as a temporary
    work space and for tests, one with the commands used to convert
    certain data, etc. Each workbench can be then dumped to a script
    or saved as an executable ELF file to capture the functionality
    achieved with the script so far.

  - A fairly user-friendly shell environment with tab completion for
    library names and so on, built-in arithmetic expression evaluation,
    a powerful built-in debugger.

  - The ability to link libraries and load or save data chunks on
    the fly.

  - ...plus certain standard shell features to actually make it possible
    to invoke PINE.

The project is currently in planning / pre-alpha stage.