Yet Another Object Request Broker
Status
WARNING: If you are looking for a stable, mature, functional implementation of CORBA for your project,
and looking to use it now, YaOrb is not for you, as it's not ready yet.
A search on the internet will give you better results.
That being said, the current version, YaOrb 0.2, does contain a lot of features already, at various completion stages.
Note that this section assumes you are familliar with CORBA, since it dives into the implementation details.
Code Coverage Report
See the LCOV coverage report here.
Design time
The most important design time tool is the IDL compiler itself:
- The pre-processor is very decent, functional,
except for macro expansion (when a macro has parameters) which is not implemented.
- The lexical analysis is complete and functional.
- The semantic analysis is complete and functional: any valid IDL file should be accepted.
- The symbol table is complete and functional.
- Type checking is complete and functional ... and it's strong,
reporting errors that other ORBs probably don't mention.
- The semantic tree is partially implemented: some constructs, like "any", "value type" ..., will be ignored,
but otherwise basic (module, interface, operations, etc) constructs are functional.
- Code generation is implemented in a separate back-end, and currently consist of
a C++ binding (incomplete but decent) and a Java binding (experimental)
- The C++ code generation generates all artifacts (header files, stub code, skeleton code)
but is limited in scope to the constructs supported by the semantic tree
(some constructs are functional, others in progress).
The compiler is a single pass compiler, and leverages the concept of nested states automatons in flex,
as well as typed yyval tokens in bison.
Runtime time
The networking protocols are implemented as follows:
- GIOP 1.2: Implemented.
- GIOP 1.1: Not implemented.
- GIOP 1.0: Not implemented.
- IIOP: Implemented.
- IOP: Partially implemented.
- IOR: Partially implemented, probably need some work.
- CDR: Implemented.
For the core implementation:
- Starting the ORB for a client or a server: partially implemented (just rude, no configuration, etc)
- Main event loop on a server (waiting for / dispatching connections): patially implemented
- POA: partially implemented
Basically, in the current state, putting all the peices together allows a developper to take some simple IDL,
use the compiler to generate code,
compile the generated code, link it against the developer implementation and the runtime library,
start a server, start a client, make a call from the client to the server (not too bad so far),
and ... start to find what is missing and implement it.
Implementing a basic end to end "ping" call in IDL is the current task,
where the next major component that needs work is the Portable Object Adapter (POA) itself.
There is much more to a CORBA implementation than the components listed here, this is just a start.
