Commit e656306b authored by yoogx's avatar yoogx

* Remove obsolete files

parent 19b78192
Ocarina v1.1
============
The Ocarina team is proud to announce the release of Ocarina 1.1
(available at http://aadl.enst.fr)
Ocarina is a set of libraries to manipulate AADL models. Ocarina is
compliant with AADL 1.0, and some extensions from AADL 2.0.
Ocarina is available as both source and binary packages for Windows,
Linux, Solaris and Mac OS X.
To download Ocarina, go to http://aadl.enst.fr/ocarina
To download Ocarina + PolyORB-HI AADL runtime, go to
http://aadl.enst.fr/polyorb-hi/
Ocarina proposes
* AADL parser and pretty printer
* Code generation features for generating distributed applications on top of
the PolyORB schizophrenic middleware
* Code generation features for generating High-Integrity distributed
applications on top of the PolyORB-HI AADL middleware
Ocarina comes with a set of examples to demonstrate these different features.
For discussing Ocarina features, you can use the ocarina-users mailing list.
Ocarina is primarily developed by Bechir Zalila, Jerome Hugues and
Laurent Pautet at ENST (http://www.enst.fr).
-------------------------------------------------------------------------------
Ocarina v1.0-alpha
==================
Ocarina is a tool suite to manipulate, verify and process AADL
descriptions. It provides a set of specialized modules built around a
central core that manages the AADL model. Modules provide functions
such as parse/print AADL description in different syntax, perform
model analysis, generate code from a model, etc.
Ocarina is primarily developed by Thomas Vergnaud and Laurent Pautet
(Télécom Paris).
* Contents
This pre-release provides two main modules:
** Ocarina core:
The core of Ocarina provides basic functions to manipulate an abstract
syntax tree representing an AADL mode:
- an API to insert elements into the tree
- functionnalities to scan the whole tree; callback functions can be
associated to the tree nodes, in order to process the description
- basic checks on the structure: completeness, type consistency, etc.
** AADL parser and printer:
These modules can read or write a description in the AADL syntax. They
rely on the Ocarina core.
* Important Note
This pre-release must be considered as an unstable version. This means
it may crash or produce incomplete results. Yet, it works for common
AADL descriptions and can be used as a description validator.
* AADL
AADL (Architecture Analysis & Design Language) is an architecture
description language targetted to the description of embedded
real-time systems (e.g. avionics). More information can be found on
the AADL web site: http://www.aadl.info
New features
------------
* Ocarina 2.0 (2008-MM-DD)
* Ocarina 1.2 (2008-04-29)
- Fully parse and analyze AADL flows (Change 4210 and 4215)
- Dramatic performance improvement of semantic analysis time (change
4202)
- Support of models that contain more that one eligible root
system. The choice of the actual root system is done either in
scenario files or by a command line option (change 4151).
- Support of code generation for AADL "timed" threads: periodic
threads that are also able to respond sporadically to external
events (changes 4106 and 4108).
- Support of code generation from refined features in component
extension, all code generators (change 4107).
- Support for bounded strings and bounded wide strings code generation
for PolyORB-HI Ada (change 4102)
- In scenario files, the user may provide custom property sets (other
that the ones provided by Ocarina) to the
'Ocarina_Config::Needed_Property_Sets property' (change 4097)
- Support of AADL operational modes for thread compute entry points in
the po_hi_ada code generator (change 4095).
- Support of threads implementation using the Initialize_Entrypoint
property (po_hi_ada) (change 4089).
- Support of code generation for AADL threads that are connected with
delayed connexions (local case only) (changes 4074, 4077 and 4078)
* Ocarina 1.1 (2007-10-01)
- Support of OUT EVENT [DATA] ports for AADL subprograms in the
po_hi_ada code generator (change 3940).
- Support of AADL operational modes for thread call sequences in the
po_hi_ada code generator (change 3851).
- Support of most of the runtime routines required by the standard to
allow user code to handle thread interfaces (Get_Value, Get_Count,
Put_Value...) (changes 3834 and 3842).
- In addition to the thread call sequences, support of threads
implementation using the Compute_Entrypoint property (for threads
and ports) (changes 3834 and 3842).
- Besides the execution platform property that may be taken into
account by some code generators (po_hi_ada and po_hi_c), all code
generators support the interpretation of the environment variable
value "TARGET_PREFIX" which is used to specify the compiler that will
be used to compile the generated code. The value of TARGET_PREFIX (if
not empty) takes precedence over any AADL property specified in the
handled model (change 3785).
- 'ocarina_sh' takes now AADL scenario files that contain configuration
elements for AADL applications (AADL source files, code generator,
needed property sets). A new option allows 'ocarina_sh' to compile
the generated code without using any shell scripts. The last
features, should enhance portability amongst platforms (change
3726).
- Enriched the AADL instance tree to make code generation simpler
(change 3484).
- Redesigned the PolyORB-HI Ada code generator to use directly the
AADL instance tree which is more organized and contains more
information than the Gaia tree. The new generator is more robust
and error messages are more clear (change 3484)
* Ocarina 1.0 (2007-01-22)
- Gaia code generator can now generate objects that ensure access
protection for AADL data components. (change 3348)
- The AADL parser has been greatly enhanced and now support most of
AADL features.
- Ocarina now uses the same aadl_project and aadl_properties files as
used by OSATE v1.4.2.
- Ada code generator for PolyORB now supports more attributes
(priority, protocol, types), as detailed in the ARAO property file.
- A helper script ocarina.sh has been added to simplify the
manipulation of Ocarina.
- The AADL emacs mode is now packaged with Ocarina.
* Ocarina 1.0 Beta3 (2006-07-03)
- Application nodes use the proper IP location and port number specified in
the AADL model. There is no more need to the reference files to make the
nodes communicate between each other.
- New Ada code generator which is faster and lighter than the old one relying
on MetaScribe.
* Ocarina 1.0 Beta2 (2006-03-28)
- Added the Ada code generation for complex data components (record types)
- Added a second scenario to the bintree example to test all the elementary
data types (integer, boolean, float and string) and the complex data
structures (record types)
- Integrated the new release of Metascribe (1.1b14) which handles correctly
the "'" characters and which fixes some other miscellaneous bugs
- Removed the useless scripts that were used to workaround some lacks in the
old MetaScribe
- Fixed some bugs related to the properties and to the expansion in the
Ocarina core
* Ocarina 1.0 Beta (2006-03-07)
- The AADL parser can now deal with the AADL extensions we proposed
concerning the subprograms
- A DIA module is added. It allows to handle DIA files containing graphical
AADL descriptions created using the AADL plugin for DIA. This module can be
used to convert AADL files to DIA files or vice versa. Users can also use
this module to parse directly Graphical AADL descriptions.
- A new backend is added to Ocarina : Gaia. It's used to generate Ada
code from AADL descriptions. The code generated by the Gaia backend is meant
to be run using the schizophrenic middleware PolyORB (For more details, see
the examples provided in the examples/ directory)
* Ocarina 1.0 alpha5
- Front-end for the Ocarina parsers. It selects the adequate parser by
looking at the file extension. This allows to parse AADL descriptions
that are written using different syntaxes in different files.
- Ocarina is now able to look for a file that should contain a given
entity declaration. For now it works for packages and property
sets. The user has just to indicate a set of directory in which files
should be looked for, and specify that missing entity declarations
should be automatically imported by the analyzer. This is quite
similar to the option -I of gcc.
* Ocarina 1.0 alpha4
- Facilities to instantiate architectures, thus allowing the
navigation through the "real" architecture, not only its AADL
description. This is useful for all tools that deal with actual
architectures, such as analysis tool or code generators.
- Provides an application named check_addl, that verifies the
correctness of a set of AADL files
- A new reset function that allows the processing of new architecture
without having to restart the application.
- API functions to import the standard properties, instead of having
to explicitly parse them as any other file.
* Ocarina 1.0 alpha3
- Code reorganization for the AADL parser and printer. The printer can be used
as an example application that access all the elements of a model tree.
- API to build AADL entities and to retrieve entities or subclauses
from the tree.
- API Documentation
- a very simple example to show how to use the Ocarina library:
examples/basic_example.adb
- Ocarina now creates all the links between declarations
(e.g. subcomponent declarations are linked to the actual component
declaration). It ensures the correct structure of the model.
- Some semantic verifications (e.g. Ocarina ensures that components
have a unique initial mode, etc.)
- bug corrections
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment