ColdFrame: Releases

You can access the CVS Repository to browse or download.

Source can be downloaded here.

Archives are available in .zip or .tgz (.tar.gz) form. The file name encodes the date of the release: cf-20010130.zip was the zipped release of 30 January 2001. The corresponding cf-html-20010130.zip contains the complete documentation.

You'll sometimes see a suffix on the date, for example 20050503cvs. The meanings are

Suffix	Meaning	Tagged
-	full release	yes
p1, p2...	patch release	yes
a, b...	candidate release	yes
cvs	from CVS	no
t, u...	temporary	no

20090617cvs

• Generation
• Generated HTML for instance events didn't select the right payload.
• Generated HTML includes simple hyperlinked class diagram and exceptions.
• Diagrams in generated HTML are optional.
• Removed no-longer-relevant warnings about singletons in associations.
• The Make option CHECKING (default strict) demotes some relatively benign errors to warnings. These include
  • Multiple declarations of the same type. No check is made that the declarations are the same, and no promises are made as to which will be chosen if they are different.
  • Missing types: a child domain can use types declared in its parent.
• Code
• Code is compatible with Ada 2005 (but doesn't use any new features, so remains compatible with Ada 95 as well).
• For classes whose maximum number of instances is known, raise Too_Many_Instances instead of Storage_Error if this number is exceeded.
• Work round a GNAT 3.16a1 memory leak problem with Find and class Delete for unbounded classes.
• When an instance of an active class is deleted, its task is only deleted after it has terminated.
• Added informative text to generated assertions.
• Testing
• ColdFrame.Stubs.Get_Input_Value's For_Call parameter is extended:
  • Positive values denote the indicated call.
  • You can specify the last call by supplying 0 as well as ColdFrame.Stubs.Last.
  • Negative values denote previous calls; thus -1 indicates the last call but one.

20080503

• General
• Added a more explicit copyright statement.
• Modelling
• Associations involving «singleton»s are fully supported.
• Generation
• ColdFrame.Exceptions.Initialization_Error is no longer called; an exception raised during domain initialization is propagated.
• The error of having more than one class with the same name is detected.
• The error of having more than one type with the same name is detected.
• The error of having more than one transition from a state triggered by the same event is detected properly.
• With a new option (GENERATE_EVENT_LOGGING=yes), all events in the domain concerned are logged as they are handled (for instance events, the state on entry is included).
• Generated HTML documents now include state diagrams (via Graphviz).
• Code
• Cant_Happen exception reports are no longer accompanied with a traceback. The message says it all.
• The standard Event Queue gives instance events priority over class events.
• Event Queue informational and error logging is now done via ColdFrame.Project.Log_Info (new) and ColdFrame.Project.Log_Error directly rather than via a generic signature package.
• A Trace event queue no longer includes the time in log messages (you have probably included the time in your project logger).
• Testing
• Unit Test support can be generated for a class with an attribute of a protected type.
• There's a new Fire operation to allow handling events on Timers.
• Added a new Monitoring event queue; it checks runs of events without a return to idle, and reports if the run has taken an excessive time (probably a symptom of inappropriate behaviour in an action routine; you shouldn't block by, for example, delaying or making a network connection, because you're holding up the whole application).
• Added a Debug storage pool which keeps track of allocations and deallocations by call site (actually, by call chain, so an allocating library subprogram will have a different record for each caller).

20060427

• Modelling
• You can mark an attribute {aliased} (or «aliased»; it's probably best to use the tagged ({aliased}) form for this, since it hardly contributes to the problem-domain analysis and the stereotype form is very visible; but note that in UML2 tagged values can only be used in association with a particular stereotype, so the diagram clutter will be unavoidable).
• A completion transition from a state with a «final» action to a final state isn't treated as an error.
• Generation
• The generated separate bodies for functions of classes returning type Handle now compile.
  The approved way of achieving this effect is to use the name of the class concerned.
• There was a problem with protected types which used access types created using {access=name}.
• Code
• The functions Is_Set and Expires_At in ColdFrame.Events_G.Test_G were not dispatching operations in the same way as Wait_Until_Idle, this made calling them very clumsy.

20060326

• Documentation
• Improved the presentation of the HTML documents.
• Revised, and documented,the support for low-level unit tests and inspecting event queues. Note in particular that the accessors for a state machine's current state are now Get_State_Machine_State, Set_State_Machine_State, and that when inspecting an event queue the events are held in posting order, not time order.
• Modelling
• You can specify «atomic» and «volatile» (as well as {atomic} and {volatile}).
• Generation
• Warnings are generated for unrecognised stereotypes (but not for tagged values).
• Code
• Fixed a problem with Domain_Initialized, which was getting set too early.
• A Test_Trace event queue starts 'unstarted', as you'd expect.
• Stub support
• Stubbed operations of types weren't thread-safe.
• Setting up 'output' values and exceptions for stubbed operations is now thread-safe.
• It's more convenient to retrieve the "last" value of an in parameter.
• A domain package body is generated even if there are no operations of types (in case the full domain does have a body, to avoid compilation difficulties with extension GPRs).
• The accessors for a state machine's current state are now Get_State_Machine_State, Set_State_Machine_State.
• When inspecting an event queue the events are held in posting order, not time order.

20051107

• Added a limited form of inspection for Timers.
• Unit testing might freeze during tear down (again!).
• Fixed a storage leak caused by improper instance deletion during an action routine.
• Improved the presentation of generated HTML.

20051019

• Generation took a lot longer than you would expect on Windows 2000, Windows XP.
• Problems with cat2raw.py and transitions to unnamed final states.
• Leading or trailing dots in names are treated as errors.
• Unit testing might freeze during tear down.

20051001

• Various corrections and improvements to test stub generation/use.
• Corrected a race condition which could block on starting a low-priority event queue.
• A type used for the return type of a protected function might have been declared too late.
• Some domain initialization (creation of singletons, default values for class attributes) is done before any domain {init} operation is called.
• Corrected problems with «final» event actions (actions which delete the instance).
• The Makefiles allow you to specify which version of a command (eg, find) to use; especially useful with mixed CMD/Cygwin builds.
• Added support for low-level unit test involving Event Queues; you can inspect a (non-started) queue. See ColdFrame.Events_G.Standard_G.Inspection_G for details; there's an instantiation at ColdFrame.Project.Events.Standard.Inspection.
• Protected function return types are taken account of when calculating the order in which to output type declarations.

20050515

• For this release, it's necessary to re-extract all Domains from the model and to regenerate.
• Modelling
• ColdFrame now recognises utility classes ("classes" with no instances, only operations).
• Visibility is partially implemented for operations of classes and «protected» types; public and protected operations are public, private and implementation operations are private.
  This doesn't include «entry» operations of «active» classes, which are always public (but only visible in the context of their own class, since the task is declared in the private part of the class package).
• You can constrain a scalar type; for a Height, you could say { constrains = Metres | lower 0.0 | upper 100_000.0 }.
• You can declare types private, by saying «type, private», (more tidily, perhaps) by tagging {private}, or even by using the Rose class specification dialog box!
  {serializable} types must be public, as must the types of any components. ColdFrame checks the former but not the latter.
• You can mark a nested package that's to be included as «include» instead of «generate» if you find it clearer.
• You can use Ada attributes (eg, 'Small) in values (initial values, bounds).
• You can specify an initialization operation to be called before any «init» operations during domain initialization, using { init = ada-package-name.operation } on the domain.
• You can declare unsigned (modular) types.
• You can make ColdFrame generate access types for your own types.
• You can specify {atomic}, {volatile} on types or attributes (translating to the corresponding pragmas). If the type is an {array} type, the components are marked as atomic or volatile (the array itself will almost certainly be too large to be marked as a whole).
• Event queues, state machines
• Action routines can be inherited from the parent.
• ColdFrame checks that operations corresponding to actions actually exist.
• There are added checks on state machine legality.
• The error of creating a Timer on the stack now results in a log message rather than an exception.
• The Event Queue task responsible for delayed Events has been renamed from Timer_Manager to Held_Event_Manager (since it doesn't just deal with Timers).
• The Debug versions of Event Queues are now deprecated; use the new Trace versions instead (ColdFrame.Project.Events.Standard.Trace and ColdFrame.Project.Events.Standard.Test_Trace).
  As an added incentive to change, Trace now includes the time since program start with each log message and reports the fully-qualified state name..
• Callbacks
• If an exception gets raised in a called-back routine, an error is logged (rather than re-raising the exception to the supplier).
  You need to be careful with this, because it can lead to elaboration circularity if your ColdFrame.Project.Logging_Support uses callbacks.
• A callback operation can deregister itself (though the register/deregister operations aren't task-safe).
• Miscellaneous
• XML Schemas are now supplied for ColdFrame's "raw" and "normalized" XML.
• It's been made a bit more straightforward to add your own code generation extensions. You can also customize the banner ColdFrame outputs at the head of each file.
• You can change the generated top-level package name of a domain, using { name = New Name } on the domain. See the new discussion on testing.
• The supplied ColdFrame.Project.Calendar provides an Epoch function (to be used for aggregates); so should a Project's replacement.
• Because it's a Bad Idea for user code to call them, the operations previously named Domain.Class.Class_Initialize and Tear_Down are now named CF_Class_Initialize and CF_Tear_Down respectively.
• ColdFrame can now generate test stubs.
• {array} types can be (de)serialized automatically.
• If a «public» class has no attributes, no instance record will be generated.
• The ColdFrame-supplied storage pools, as well as filling newly-allocated memory with an obviously bad pattern (16#deadbeef#), now refill just-freed memory with 16#deaddead#.
• Unimplemented operations raise Unimplemented instead of Program_Error.
• Tear Down has been reworked to remove some race conditions that could lead to Tasking_Error.
• The error of deleting an active instance from its own task is detected.
• Making an association with a «public» class was never meant to be supported and now results in an error.
• Floating point types are always generated as constrained subtypes, using 'Base'First or 'Base'Last as appropriate for omitted bounds.
• It's possible to suppress the deserialization code in generated Image operations in a target-dependent way; see ColdFrame.Project.Serialization.

20040319

• Unrecognised tagged values (eg, {status}) are no longer reported. Instead, they are included in the normalized intermediate file, so that, for example, you can add your own code generation extensions.
• Tagged values with names containing illegal characters are treated as errors. (Legal characters are alphanumerics, hyphen and underscore).
• You can specify an empty type using the tag {null}.
• Cant_Happen exceptions in state machines are accompanied by exception information (to make them easier to debug).
• You can specify array «type»s ({array=element-type, index=index-type}). You can also say {unconstrained}: since unconstrained arrays are indefinite (ARM 3.3(23), 3.7(26)), you can't use them as attributes, but they can be used as parameters or as function return values.
  If you want to serialize array types, you must supply your own field-image operation.
• For increased performance, if a class has a single identifier of type
  • Boolean
  • an {imported} or {renames} «type» marked {hash=enumeration}
  • an {integer} or {enumerated} «type» of small enough range (currently 49 by default, the parameter max-hash-buckets)
  the container for the extent of the class (all the current instances) is implemented as an array rather than a Booch Components Map.
• Callback support asserts that:
  • on registering, the procedure hasn't already been registered
  • on deregistering, the procedure has been registered
• Making an association with a «public» class was never meant to be supported; doing so results in a "strong warning" during code generation, and will result in an error in a future release.
• Fixed-length strings are supported (say {string = fixed 27}, for example).
• A state machine action is allowed to delete its instance if
  • The operation is the (generated) Delete.
  • The operation is stereotyped «final».
  Other uses will result in an exception.
• The error of creating (and using) a Timer on the stack is detected. Unfortunately, this means getting a Program_Error because of an unhandled exception in a Finalize subprogram.

20031126

• The class Delete operation for a 0..1 class didn't null out the container, so it appeared that there was still an instance.

20031123

• There was a memory leak if an exception should occur in a callback routine.
• The generated separate bodies of operations of types didn't include any documentation comments.
• UML tagged values are supported as well as ColdFrame's original [[annotations]].

20031102

• Improved the default error logging (stop concurrent access mangling the output; flush the output after each message).
• Serializable output used the wrong field names.
• Performance improvements in class Filter_Function, Selection_Function.

20030930

• A class variable of the class's type wouldn't compile ("representation item appears too late").
• Classes with state machines wouldn't compile ("primitive operation declared too late").
• Improved detection and reporting of problems with state machines.
• Code for «accessor»s is no longer inlined (compilation times were greatly extended).

20030914

• Serialization supports nested (but not discriminated!) records.
• The old [[image]] functionality for outputting serialized data was clumsy for unstructured types (such as an imported Time). A new type-image annotation is provided.
  The old [[image]] functionality is retained but deprecated; use [[field-image]] instead.

20030906

• The old Hash function has been replaced by Instance_Hash (because the arguments are different).
• Code generation doesn't stop on the first error.
• State machines support actions on transitions.
• It was possible, especially with Cascade_Teardowns, for a shared event queue to be torn down more than once, leading to Constraint_Errors.
• With the new container implementation, calling Find for an «active» (multiple-instance) class would hang.
• Started a set of regression tests, in the test/ subdirectory of the distribution.
• ColdFrame identification commentary (revision of the model, date of extraction, revision of ColdFrame components) is added to each generated file.

20030815

• Added ColdFrame.Project.Log_Error, and used it to report exceptions in domain initialization.
• If all the attributes of a «singleton» (or «public») class were «class» attributes, the generated code wouldn't compile.
• Generates code for «protected» types.
• Includes Rose "model" files for the example and test distribution subdirectories.
• Exceptions can be imported or renamed.
• Operations can be renamed (this provides a form of overloading, which isn't otherwise possible given that ColdFrame generates separate proper bodies).
• Attributes marked class in the Rose class specification dialog are seen as such.
• Operations marked abstract in the class specification dialog are seen as such.
• Included cf-banner.el, an Emacs add-in to aid replacing ColdFrame's generated banner file heading with something appropriate to your version control system (in this case, PVCS).
• Improved code generation efficiency (by eliminating many instantiations of Booch Components).
  Note, to allow further improvements without impacting your code, it would be a good idea to use the generated Domain.Class.Iterate generic for iterations rather than open iterations using Domain.Class.Abstract_Containers.
• Memory allocation (for instance, when creating an instance of a class) now fills the allocated memory with an improbable pattern. This should help to catch use of uninitialized attributes.
• You can specify an active class's stack size and priority (as an offset from the system's default priority, the larger the number the higher the priority).

20030519

• You can use expressions in range specifications for types, initial values for attributes, and default values for parameters. Pi is specially recognised (it translates to a domain constant equal to Ada.Numerics.Pi).
• Code for «accessor»s, and for supporting inheritance and «abstract» operations, is generated in the package body rather than in separates.
• Code for «accessor»s is made "inline".
• The Makefiles are much quieter.
• The Makefiles report any code in the .impl directory that doesn't correspond to generated code.

20030513

• Corrected problems deleting an instance with extant held events.
• The script to split serialized XML files into CSV format is included in the distribution.
• A class with a Timer but no state machine will now compile.
• These stereotypes now imply «type»:
  • «callback»
  • «counterpart»
  • «discriminated»
• You can tear down an Event Queue that hasn't been started.
• The generated Create operation checks that supplied referential parameters are of the correct class.
• The Domain.Serializable package is generated even if there are no serializable types in the domain (in which case it will, of course, be empty).

20030330

• Some documentation rework.
• Handle parameter modes correctly (the old way, with the [[mode]] annotation, is still supported).
• A Serialization Base class now needs to support the function Base_Attribute_Image (to output any of its own attributes, such as a timestamp).
• The supplied makefiles include a target (install) to help override ColdFrame's support code (the ColdFrame.Project hierarchy). See the installation notes.

20030316

• Domain.Cascade_Initialize and .Cascade_Tear_Down procedures are generated; as generated, they call the domain's Initialize procedure.
• Removed ColdFrame.Serialization_Signature, no longer needed.
• Corrected errors in calculating multiplicity and dealing with [[hash]] annotations.
• Normalization reports problems with trailing dots in (Ada) names.
• Added ColdFrame.Project.Events.Standard.Test_Debug, which is a Test event queue (ie, it doesn't start until told, and allows you to wait until it's idle) which prints what's going on.
• Adding extra kinds of Time (for held events) is simplified.

20030309

• Operations of «type»s no longer have an implicit This parameter (you can of course always provide an explicit one).
• Case normalization has been improved; the GLIDE rules are now followed, so that you can specify that short comes out as short while short message comes out as Short_Message.
• The way in which Booch Maps are used has been changed; now, the number of hash buckets is the maximum number of instances, up to a value which can be changed in the Makefile but is defaulted to 49.
• If a class has a single-attribute identifier that is an enumeration or an integer range, the maximum number of instances is calculated automatically (but doesn't override any user-specified maximum).
• The maximum number of instances of association classes is calculated.
• If you have serialized output in output.xml, you can say
     make -f $TOP/$COLDFRAME/Makefile-unix output.csv
  (or, of course, Makefile-winnt if you're on Windows) to run a script to split the output into "comma separated variable" files, one per serialized type included in the input file. Comma separated variable format is importable into spreadsheets.
• If events to run "after an interval" are posted to an event queue which hasn't yet started, the interval refers to the time when the queue is eventually started.

20030207w

• The HTML documentation is distributed in a zip file alongside the source code.
• The [[extends]] annotation allows you to specify that a type is derived from an external type.
  (It might have been possible to use inheritance relationships, but that would have opened a raft of problems with supporting polymorphic operations of types, and in any case you should probably be looking at classes rather than types for your own work.)
• The [[convention]] annotation allows you to specify the programming language calling convention that an operation will be called with.
  For Ada, this translates to pragma Convention.
• If an association has an associative class, a Find operation is generated in Domain.Association which, given the handles of two potentially associated instances, returns the corresponding associative instance's handle (or null, of course).
• Callbacks are now unbounded (you can continue to specify a "maximum number of observers", but it will not be used).
• The [[serializable]] annotation allows you to specify support for transmitting values of a (record) type via some external medium -- perhaps to record binary data for future analysis.
• Your main program can coordinate the Event Queues (Dispatchers) used by the Domains.
  If you pass a Dispatcher to Domain.Initialize, it will use it instead of calling Domain.Events.Initialize.

20030107a

• Extraction from Rose loads required packages recursively.
• Added a new Logging signature package, ColdFrame.Logging_Signature.
• Using the same generalization name with more than one parent is detected.
• The last entry action of a final State can (and probably should) delete the instance - unless of course it's a defunct «singleton». It no longer needs to be named Delete.
• If you want to make a class visible for unit test support, mark it «visible-for-test».
  This should be reserved for unusual cases (typically, unit test variants of device support domains).
• Added ColdFrame.Interrupts for interrupt support.
• Added Interrupt_Handling, Library demos.
• The environment variable CASE_EXCEPTIONS specifies one or more case exception files. If there's more than one, the separator is ; on Windows, : on Unix.
• [[counterpart]] «type»s are implemented as renamings (subtypings) of ColdFrame.Instances.Handle.
• «teardown» operations are called during domain teardown.
• «class» accessor operation bodies are automatically generated for «class» variables.
• You can specify that an imported or renamed type is to be hashed as a discrete type (using [[ hash : discrete ]]).
• Added a reasonably complete example (the Stairwell demonstration).

20020921

• Extraction from Rose now loads a Domain package if it isn't already loaded.
• The Rose Path Map variable and the environment variable ColdFrameOut are both now capitalized (COLDFRAMEOUT). This is because of an interaction between Windows and Cygwin.
• Extraction checks the environment variable COLDFRAMEOUT if there's no Path Map setting. There are notes.
• There was an error in Event Tear_Down which caused Storage_Error if there were in fact any Events.
• The Selection_Function of a class with multiplicity 0..1 gave a Constraint_Error if there was no instance.

20020917

• Reworked how Time is handled in ColdFrame.Project.Events.
• There's a new ColdFrame.Events_G.Test_G add-in which allows you to query whether a Timer is set, and when it will expire.
  These are not appropriate in operational code; state machine logic should be encoded in the state machine, as far as possible, and you ought to know whether a Timer is set or not.
  The Start operation has a default implementation which raises ColdFrame.Exceptions.Use_Error (because operational code shouldn't be calling it). Test queues support this operation; the queue doesn't start dispatching events until the operation is called.
  The Wait_Until_Idle operation has a default implementation which raises ColdFrame.Exceptions.Use_Error (because operational code shouldn't be calling it). Test queues support this operation; the operation blocks the test thread of control until all event activity has terminated. A parameter Ignoring_Timers (defaulted to False) controls whether Timers are included in the count.
• Documentation is copied through into the generated code.
• The way in which the "lines of code" count is generated and reported has changed.
• The provided ColdFrame.Projects.Calendar implements Time as a renaming (subtype) of Ada.Calendar.Time; there was an interaction with a GNAT feature (GCC PR/7613) when the whole package was a renaming of Ada.Calendar.
  Generated code no longer uses ColdFrame.Projects.Calendar; instead, there's a use type for it. This will change operations' profiles.
• Attempts to use Ada reserved words for identifiers are caught.
• Tear_Down now cleans up «singleton»s and class variables (actually, they're reset on the next Initialize via a new Class_Initialize operation; Class_Initialize is now reserved).
• If a state entry action procedure has a parameter, it's of the type of the corresponding event's payload rather than the event itself. This allows different events to cause transitions to the same state, so long as they all have the same payload type.
• State entry actions can now see both the previous and the current state of the instance.
• Delete is supported as an entry action (not available for «singleton»s, and it had better be the last action!).
• The Makefiles allow the Rose model to be extracted to a different directory from that under which the code is kept (using the make variable ColdFrameOut).

20020716

• Event Queues now have a Wait_Until_Idle operation, for unit tests to use after posting test Events; the operation blocks the test thread of control until all event activity has terminated.
• Event Queues now have a Tear_Down operation; this is automatically called from the domain Tear_Down. Note, this is also intended for unit test!
• There is a new Post_To_Self operation on Event Queues, to be used by a state machine instance which is posting an event to itself to make sure that the event is processed before any externally-signalled events to the same instance.
• Missing names/types are detected for attributes and parameters before code is generated (during normalization).
• Date, Time types are translated to ColdFrame.Projects.Calendar.Time, which is provided as a renaming of Ada.Calendar.

20020706

• «instantiation» can be used to mark operations which you want to appear on a sequence diagram but which will be implemented by instantiating a generic (for example, Class.Selection_Function).
• The [[set]] annotation (defining a type consisting of a collection of instances of a class) is no longer available; I couldn't find a sensible mechanism to implement it now that I don't use WITH TYPE any more.
• Initial support for state machines.
• Support «class» attributes.
• Added Counterparts.
• Create the default "abbreviation" for single-word classes by prepending A or An to the class name.
• Check for illegal characters in identifiers.
• Added Exceptions (like «type»s, but marked «exception», generated in the Domain package).
• Initializers can be signed.
• Autonumbering is reset by Tear_Down.
• Added pragma Elaborate_Body for generated instantiable units.
• Navigation of associations from collections is now in a separate child package Domain.Association.From_Collections.
• Include "don't edit" warnings in generated code.
• It's no longer necessary to mess with your CLASSPATH to include saxon.jar; java's called with -cp. You do need to unpack Saxon where the Makefile's expecting it (see the installation notes).
• Added special processing where an dispatching or inherited operation has a parameter of the same type as its class; the parameter is converted to the same type as the implicit This parameter.
  This may be what's called covariance in Eiffel.
• Tear-down of an active non-singleton instance didn't terminate the associated task.
• Some of the generated operations (eg, some accessors for referential attributes) are only intended to be called by generated code. These are now marked in the spec.
• «access» functions were generated as though they were procedures.
• ColdFrame now respects the modeller's casing; if you say FOO it should come out as FOO (in the absence of a case exception for foo).
  This change has two consequences:
  • you need to be consistent about case; the code generator is case-sensitive
  • you need to use the case that ColdFrame expects (for example, AutoNumber won't work).
• There's a new exception ColdFrame.Exceptions.Existing_Child, raised when you create a child of a parent which already has one.
• Operations of «type»s are generated.
  This allows you to have domain-wide «access» operations, too: declare them as operations of some «type» (if there are no other [[annotations]], attributes or operations the «type» itself won't be generated).
• As well as setting Events that you want to be delivered at some future time on Timers, which allows you to retract the event (by unsetting the timer), you can just Post them (in a "fire and forget" way).
• Event-related exceptions have been moved to ColdFrame.Exceptions (with the rest).
• The generated bodies of functions that return composite (record) types now compile.
• Create operations Assert that any identifying referential attributes aren't null.
  Link operations Assert that their arguments aren't null.
• "Subtype migration" (dynamic classification) is supported; for each class involved in an inheritance relationship there's a child package (Domain.Class.Inheritance) containing the new operations.
• Include installation notes.
• Projects will want to provide their own versions of supporting Ada packages, for example to provide the default storage pool; but ColdFrame needs to know how to with them.
  A new package hierarchy rooted at ColdFrame.Project is used to hold such packages.
  A new Ada source library directory cf-yyyymmdd/project is provided to hold example versions of required packages.
• The exceptions declared in ColdFrame.Exceptions are no longer renamings of Booch exceptions.

20020116

• «abstract» is supported on Classes (nothing is done with it yet).
• The supplied Makefiles assume there's a case exceptions file (~/.emacs_case_exceptions); normalization no longer fails if there isn't one.
• Normalization no longer checks that the parent in an inheritance relationship has an identifier (if it hasn't, that will be found later anyway). This means it's no longer a fluke if inheritance trees work properly!
• The Rose Extractor only extracts (selected) packages in the current class diagram; it pops up a dialog box on completion to say what it's done.
• Reports of unhandled stereotypes, annotations tidied up.
• The domain package comments include the generated lines-of-code count (actually, the usual Ada "number of semicolons").
• Normally ColdFrame only extracts classes and associations from the top-level (domain) package. If you prefer to organize your model with, say, the «type»s in a "Types" child package, mark it with «generate».

20011209

• There's a new scheme for mutual visibility of Class package specs, not involving the GNAT WITH TYPE extension.
• In multiple inheritance, an inherited operation is called in the correct parent.
• «abstract» and «finalize» operations don't map to task entries.
• A new operation stereotype «navigation» is like «generated» (but is intended to mark operations that are in fact provided in an association package).
• «finalize» operations aren't inherited.
• The domain Tear_Down clears all registered Callbacks.
• A proper error message is given when a [[callback]] annotation is given on a non-record type (a type without attributes).
• Implement the [[renames]] annotation.
• Sort out multiplicities (on roles) and cardinalities (on classes).
• Implement Autonumber using GNAT's Long_Long_Integer (64 bits). Let's see you overflow that!

20011011

• To support testing with AUnit, a Tear_Down child procedure is generated for each Class, which deletes all instances. This won't (31.viii.01) work for «active» classes.
  A domain Tear_Down child procedure is also generated, which calls all the class Tear_Downs.
• normalize-rose.tcl supports the --casing file flag, which specifies a file containing identifier case exceptions.
  A GLIDE case exception file can be used, but GLIDE's distinction between partial and complete exceptions isn't preserved (you could tell GLIDE to upcase gnat only when it formed the whole of an identifier, so you'd get GNAT but Gnat_Id).
  You can specify more than one exception file by repeating --casing.
• A child class's Create operation sets up the parents' child information record.
• Deletion of an instance of a child class clears the parent's (or parents') child information record(s).
• Deletion of an instance of a parent class deletes the current child instance.
• A parameterless instance procedure marked «finalize» is called by Delete just before the instance is freed.
• Operations marked «generated» are treated as "already generated", that is, no new code is generated for them.
  This is to allow the standard Create, Find and Delete operations to be used on sequence diagrams without Rose complaining.
• The supplied Makefiles, when placing generated code in Domain.gen, delete any .ad? files which are already present in Domain.impl. This should reduce confusion (and may make the use of GNAT Projects easier).
• (Record) types marked [[discriminated]] are generated as discriminated records; the discriminant is an enumeration type with literals formed from the attribute names with _T appended.
• A child generic procedure Domain.Class.Iterate is created for non-«singleton» classes to simplify iteration over Collections.
• Storage management for the Booch Containers, where relevant, adopts the new style (you need a version of the BCs later than 20010927).
• Generated Hash functions now compute a useful (I hope) value.
• The supporting code for hash functions has been reorganised under ColdFrame.Hash.
• Generated package specs and bodies have added blank lines to make them easier to read. This is controlled by the Make variable BLANK_LINES (yes means "add blank lines", anything else means "don't").
• Verbosity is controlled by the Make variable VERBOSE; yes means "be chatty", anything else means "don't".

20010819

• The Domain Initialize procedure used to call an Initialize procedure for each Class, for which a default empty implementation was supplied. Now, it only calls operations with the «init» stereotype («init» implies «class»). They should be parameterless procedures (a warning is given, but code generation completes); a standard stub implementation is provided, which raises Program_Error.
• ColdFrame used to use «interface» to indicate that the stereotyped class should be visible outside the Domain package. «interface» is used for another purpose in UML; now ColdFrame uses «public» instead. «interface» is retained but deprecated (ie, it will disappear at some later time; stop using it as soon as you can).
• The generated top-level Ada file contains identification information:
  • revision control information for the domain (this is extracted from a [[revision]] annotation for the domain, if any: to put this in the Rose model in the correct place, select the domain Package in the browser)
  • date and time of extraction
  • the ColdFrame releases (in the form cf-yyyymmdd) of the extractor, normalizer and generator components of ColdFrame used.
• In Rose, you can extract more than one Domain at once by
  • having a class diagram showing the Domain packages to be extracted, and making it the active diagram
  • selecting more than one Domain package in the Rose browser (or the extraction diagram).
• There is no longer an extraction dialog:
  • the extracted file name is formed from the package name, with spaces replaced by underscores
  • the extraction directory is that specified by the Rose Path Map variable ColdFrameOut or, if not specified, the current directory.
• The extracted code is laid out using GNAT's defaults (standard indentation 3 spaces, continuations 2 spaces). These can be overridden.

20010707

• Generate the Link operation for 1-(1:1) associations correctly.
• Work round a GNAT problem (tasks and with type don't mix).
• Work round a GNAT problem (with type in the spec needs to be matched with a plain with in the body).
• If the Saxon command line parameter generate-accessors is set to defined, attribute accessor subprograms will be generated if they were specified in the Rose model. Corresponding task entries for active classes are suppressed.
  For an attribute Attr, an operation is a "set" accessor if it is a non-«class» procedure named Set_Attr with a single parameter of the same type as Attr, and an operation is a "get" accessor if it is a non-«class» function named Get_Attr with no parameters returning a value of the same type as Attr.
• Generate short names (omit Domain name and own Class name), where possible. This is because of GNAT 3.14a1 problems with complex separates.

20010623

• Operations can be stereotyped as "access to subprogram" (and, by implication, as «class» operations) using «access». This was actually present but undocumented in 20010520.
• Allow types to be [[imported]].
• Partitioned inheritance trees were not being distinguished properly.
• Support "autonumber" attributes.
• Domain types are generated in (reverse) dependency order, so you can safely specify records containing records.
• 1-(1:1), 1-(1:1c), 1-(1c:1c) associations now supported.
• Operations are generated with "separate" bodies, instead of using child subprogram units.
• Active classes (in Rose, go to the Class/Detail tab and select Active) are generated with a task for each instance. The task body is "separate". Each non-«class» procedure operation has a matching entry; the generated (separate) procedure body calls the task entry.
• Singleton (but not Interface) classes now provide a Handle type (accessed through the Find function), for use in associations.
• All Classes have a «class» operation Initialize (no parameters); the Domain has an Initialize operation which calls each of the Class' Initialize (in alphabetical order).
• If the Saxon command line parameter generate-accessors isn't set to yes, attribute accessor subprograms won't be generated.
• The Makefiles set the file protection on generated code to read-only (to give you some sort of warning when you accidentally edit generated code).
• Include proper default initialization for Date/Time.
• Dispatching operations supported, including «abstract» operations.
• Associations with «singleton»s now supported.

20010520

• Includes support for Associations.
• Generates HTML documentation.
• Supports record «type»s (no check yet that record types are declared after record types that they reference).
• Provides a callback facility (the Observer pattern).
• Allows the use of a class' Cardinality instead of [[max]] or «singleton».

20010325

• Whether a class is a singleton or not is now determined by the «singleton» stereotype (or annotation).
• All classes except those with the «interface» stereotype or annotation are implemented as private children. «interface» classes are automatically «singleton»s.
• If a class is implemented using Bounded containers (because the number of instances is known), a fixed-size storage pool is used for the Handle access type (so that memory is only allocated from the heap at package elaboration). This has forced the Abstract_Containers package to be implemented as a child of the Domain.Class package.
• References are implemented using the Handle of the referenced class. This means we have to use the GNAT "with type" extension.
  I've included a pragma Extensions_Allowed (On); in each package that needs it, but there seems to be a GNAT problem here (3.13p, 3.14a) so you may need to include this in your configuration file (gnat.adc) or use the -gnatX flag.
• The child class enumeration literals now have _T appended (otherwise the literals masked the class package, so you had to say Domain.Class.thing rather than just Class.thing in subprogram bodies).
• Delete operations didn't in fact free allocated memory.
• You need at least Release 20010325 of the Booch Components.

20010228

• Choose between Bounded and Unbounded Containers depending on the class's [[ max: max-size ]] documentation annotation.
• Choose the number of hash buckets for Bounded Maps depending on the [[ max: max-size ]] documentation annotation.
• Added documentation on the paraphernalia surrounding an Identified Class Package.

20010204

• Added support for singleton classes (classes with no Identifier attributes).
• Added documentation of the relationship between the normalized ColdFrame metamodel and generated Ada.

20010130

Initial release.