#9 Rewrite core object communications system

When IC was first being ripped into two parts, the GUI
was going to sit on top of the IC command line process
and relay commands to it. For many various reasons,
this ended up not working, but it was late enough in
the design cycle that the communications system
(passing strings around for commands, and parsing the
message log for returns) stayed in. This is a horrible
system to be running under, and shouldn't take that
much to change out.

[Jim Peterson]

Logged In: YES
user_id=1176716

Either the goal of separating the compiler from the user
interface is on the horizon or not. what form of
communication will be used between the CLI and the GUI? I
envision the CLI writes all outputs to standard output. and
the GUI traps that to make its presetntation rather than
the simple console out. I would think the goal is to be
able to build the CLI independent of the GUI and have them
still work. that would mean some form of structured
communication that (if intended to support use selected
editor or the like) would mean string parsing to separate
errors and results in any case.

[Anonymous]

Logged In: YES
user_id=1033039

Yeah, what you said has actually already happened, I guess I
didn't state my case well enough. The compiler and the user
interface have been seperated. The compiler now sits in its
own static library that both the CLI and the GUI link
against, and use the ICInterface class to access. The GUI
and the CLI don't even know about each other.

The main problem is that instead of directly calling
ICInterface functions, everything goes through a command
router (the GUI/CLI send strings into it, it figures out
what command the string is linked to, and runs that
function), which really doesn't need to happen. I needed to
do that when the GUI was sitting on top of the CLI, because
the GUI was pretty much emulating what a user would have to
type in to access functionality in the compiler. It should
be ok to link both the GUI and CLI directly to the
ICInterface functions now.

The problem with the GUI being bonded to the compiler was
that there was no other way to access the compiler, period.
Now that any interface can be built just by linking against
the compiler library, we've got two interfaces that are easy
to maintain and debug.