Important Note If Upgrading From Previous Rose for UNIX Release
Rational Rose 98 for UNIX, Version 98.2 (4.5.8303)
Rational Rose 98 for UNIX, Version 98.1 (4.5.8153)
For your convenience, this Release Note contains information applicable to both Rose 98 for UNIX versions 98.1 and 98.2. Refer to the following recommended guideline to determine which specific sections of this Release Note will be important to you:
Thank you for selecting Rational Rose®98 for Unix, hereafter referred to as Rose.
Please read this release note before you install or use Rose.
Note: In some cases, you may note discrepancies between the printed documentation and the online documentation. In these cases, the online documentation is the most up-to-date and should be followed.
For release note information on any Rose 98 components, read the following sections located in this manual or online help:
If you encounter any problem while installing or running Rose, please check here first to see if it is a known problem. If a problem is not yet documented, please call Rational Technical Support so we can investigate it, provide you with a workaround, and track the problem for future action.
Contact information for Rational is in Appendix B of the Rational Rose 98 for Unix Installation Guide and in the online help supplied with Rose.
Online support can be found on the World Wide Web at the following location:
This location includes any updates not available at the printing of this manual in relation to such documents as:
This website also includes such information as:
The following tables list the recommended configuration to successfully install and use Rose. See the Rational Rose 98 for Unix Installation Guide for more details about supported configurations.
The first table contains the hardware requirements for installation and use of this product. Note that the recommended amount of memory is only the suggested minimum amount. Additional memory may improve performance. Your memory requirements will also be larger if you are constructing larger models.
The next table contains the software requirements for installation and use of this product. Note that this is also only a suggested amount of swap space. Your requirements may be larger if you expect to construct very large models. If all of your models are small, you may need less than the amount shown here.
The following table lists the general limitations of this release.
The following section lists defects that have been fixed in each version.
Thank you for selecting Rational Rose 98.
This release note describes known problems and any changes in Rose. Please read this release note before you install or use the product.
Additional information on these related topics can be found in the following sections:
Contact information for Rational is in Appendix B of the Rational Rose 98 for Unix Installation Guide, and in the online help supplied with Rose.
Changes and Enhancements in Rose
Rose 98 for Unix provides the following major enhancements over Rose 4.0:
In addition to the current support of assigning classes to components representing source files, classes can now also be allocated to these new binary components. A class can now be assigned to multiple components. Each component is of a certain language, like C++, JavaTM, etc. This language will control what language tabs are displayed for classes and other assigned model elements. For example, if a component is Java, only the Java tab will be displayed for a class. The language will also control what primitive types are available for that class.
The Add-Ins will be managed through the new Rose Add-In Manager, hosted on the new Add-Ins menu. This menu is also where we expect most Add-Ins to be visible.
Independent Add-Ins will also allow us to move to a simpler update and distribution model. As Add-Ins will be licensed to work only with the appropriate tier of a Rose product, we plan to post new Add-Ins on our public web site.
For important additional information, refer to the "Visual Diff/Merge" section in Chapter 7.
Since the new version of Rose supports a new model format, you will be able to save your models as 4.0 models.
Also a number of anomaly resolutions have made their way into this release.
Upgrading from Rose 4.0 or earlier versions
The following are affected when you upgrade from Rose 4.0 or from a Rose release previous to 4.0:
If the model properties for the model file are stored in a controlled unit, Rose will not be able to determine the default language. In this case, simply choose the language of your choice in the dialog box and click OK.
Warning: In most cases it will not be necessary to change the language that Rose detects. Do not use this dialog to change the language of your model, as no language conversion will take place. If your model was written using Rose C++, you should not change the language to Java, for example.
To convert Rose 98 models imported from Rose 4.0 (when assigning a class name to more than one module)
In Rose 98, you have the ability and will need to assign both the module specification and the module body to the class. Because a class can now be assigned to both, Rose no longer automatically detects the identically named module body and uses it. This is an issue if you are moving from 4.0 and you used the automatic detection system. You need to update their models by assigning module bodies to their classes.
You may automatically perform this model conversion by selecting Tools:Open Script ... and run rational_dir/releases/rose.I.J.K/scripts/convertTo98.ebs.
Before running the conversion script, load all units in the model that have IDL model properties. Next, invoke the IDL conversion script which can be found as the Tools:IDL:Convert Rose 4.0 IDL to Rose98 IDL menu item. The script will look for those model properties corresponding to IDL and perform the required conversion.
When reading a model from a previous release, Rose 4.0 and Rose 98 will identify all attributes and has relationships as has relationships (because that is, in actuality, what they were in the previous release). Items which appeared in the Attribute/Has Relation listbox will now appear in the Relationships listbox.
This does not affect code generation, but if you prefer, you can change any of your existing has relationships into new-style attributes as follows:
Code generation properties for a has relationship will be discarded when you change it into an attribute. No warning is given.
You can also go the other way, changing attributes into has relationships. Note that the change is made only in underlying model, not in any diagram.
To modify your .rose.ini file to disable smart word wrap of item names:
Known Rose Problems and Limitations
The following section lists defects that have been fixed in each version.
| Defect | Description |
|---|---|
| 131653
|
Components not shown in Class
Specification component list.
Unable to assign classes to components from a class
specification. The component drop-down list only displayed the entry <unspecified>.
|
| 132034
|
Unable to manipulate models between
NT/PC and Unix systems.
Was unable to share models between platforms (for example, once model file saved on NT/PC unable to open the file on Unix file system). Note: Users of Rose 98 on Windows NT & 95 will
need to download and install Rose 98 Windows Service Pack 1 for their Windows
product before they will be able to transfer models back and forth seamlessly
between platforms. Rose 98 Windows Service Pack 1 is available for download
from
http://www.rational.com/support/downloadcenter/upgrades/rose98i_download.jsp
|
| 132058, 132140
|
Virtual Pathmap errors when attempting
to load controlled units.
Rose was unable to resolve "\\" as a path separator. The "\\" path separator may have occurred when a model was loaded on both Windows and Unix. Workaround was to grep through the *.mdl and *.cat files, changing "\\" to "//". Virtual Pathmap variables were not correctly expanded due to a functionality change of the "ufile:" menu command. Rose now correctly resolves both path separators
"\\" and "//", and expands Virtual Pathmap variables.
|
| 132348
|
Using accelerators (for example,
"Control-G") could cause Rose to crash.
|
| 132494
|
Upon exiting Rose, core file could
be produced.
|
| 132705
|
The Class Specification 'Detail'
tab not updated when class assigned to a component.
Upon creating a class in the Logical View, creating
a Subprogram Spec and Body in the Component View, assigning the class to
the named Subprogram Spec -- the Component field was left blank (not updated)
in the Class Specification Detail tab.
|
| 132826
|
Deleting/Editing Association/Class (as shown in the following steps) could cause Rose to crash: |
| 133249
|
While working in Rose, the mouse
pointer transforms into a "move" pointer (four pointed arrows) and is trapped
in the diagram area.
In some cases pressing the "F1" key would help workaround
the problem (reinstating the mouse pointer).
|
Thank you for selecting Rose® JavaTM Edition.
This release note describes known problems and any changes in Rose Java Edition or its documentation. Please read this release note before you install or use the product.
Additional information on these topics can be found in the following sections:
If you encounter any problem while installing or running Rose, please check here to see if it is a known problem. If a problem is not yet documented here, please call Rational Technical Support so we can investigate it, provide you with a workaround, and track the problem for future action.
Contact information for Rational is in Appendix B of the Rational Rose 98 for Unix Installation Guide, and in the online help supplied with Rose.
The Rose Java Edition supports the round-trip engineering of applications based on either JDK 1.0.2 or JDK 1.1.x libraries. This support includes reverse engineering and forward generation of inner classes as Rose nested classes.
The Rose Java Edition takes advantage of Rose support for namespaces on a package-by-package basis. For more information about namespaces, refer to the Rose section.
The Rose Java Edition will automatically generate function stubs for all unimplemented methods of interfaces that a class implements. For systems that rely on interface realization, this results in enhanced developer productivity, and fewer compilation errors.
Rose Java Edition dynamically resolves Java* import statements by using the CLASSPATH setting to determine the locations of classes or interfaces that a class uses. This resulted in more accurate round trip engineering and namespace conflict resolution.
Rose Java Edition takes advantage of Rose's support for interfaces stereotypes by including the capability to indicate interfaces as stereotypes. Reverse engineering automatically applies the <<Interface>> stereotype to Java interfaces.
A legacy Java application can be reverse engineered and forward engineered (without any methods being dropped). This makes it possible to introduce round-trip engineering at any point of a project.
JavaDoc comments are generated and reverse engineered.
Rose Java Edition uses the component diagram for its code generation. In order to use the component diagram, Rose UML-Java language mappings have been standardized. New features available on the component diagram, such as interfaces, and package level dependencies are supported.
Rose Java extends RTE support for class names with enhanced characters.
Reverse engineering counts on executing in a valid Java Edition environment. In order to reverse engineer source or byte-code, the CLASSPATH environment variable must be set up correctly.
You should not reverse engineer any Java code which does not exist in relation to the CLASSPATH. This is because the Java Add-In depends on the CLASSPATH setting to correctly resolve all class dependencies (i.e. import statements).
This is especially critical in a namespace-enabled environment. Moving code to a different directory than where it is compiled and reverse engineering it could result in broken dependencies between classes.
Note: Because Rose Java Edition does not yet support Java archives (*.zip, *.jar, *.cab), you may have to unzip any archives that your classpath references in order for Rose Java Edition to function correctly.
Support for Java archives will be added in a subsequent service pack.
Be sure that Rose Java Edition is installed.
Set the CLASSPATH environment variable to point to IDE libraries and .java source files.
For additional information, refer to "Java" in the "Add-Ins" section of Chapter 7.
The current documentation does not explain how to set up your project with the appropriate CLASSPATH before forward or reverse engineering. Use the following procedure to do so:
There are a number of anomalies in the JDK 1.1.4 release which, although passed or ignored by the Sun parser, are not supported in the Java grammar.
The javac compiler accepts references to inner classes by object other than the owner object. For example,
While legal, this is not encapsulated design. It is more appropriate in this case to implement myA as a separate class. References to this sort of design are not currently supported in Reverse Engineering.
Rose Java Edition does not yet support Java archives (*.zip, *.jar, *.cab). Support for Java archives will be added in a subsequent service pack.
It is important to back up all code before round trip engineering it, as Rose will sometimes overwrite the code (the ~.jav file may not contain the original code).
The following table lists defects fixed in Rose 98 Java Edition V98.2.
Thank you for selecting Rose C++.
This release note describes known problems and any changes in Rose C++. Please read this release note before you install or use the product.
Additional information on these topics can be found in the following sections:
Contact information for Rational is in
Appendix
B of the Rational Rose 98 for Unix Installation Guide, and in
the online help supplied with Rose.
Rose C++ provides enhancements and bug fixes applicable
for all C++ compilers.
These settings are explained in the Roundtrip Engineering With Rose C++ manual.
In addition, a number of new code generation properties and Analyzer options have been added or enhanced to support:
Upgrading from Rose C++ 4.0 or earlier versions
Rose has a new file format to support enhancements of the new release. Rose will read old model files, and when you save them, they will be saved in the new file format.
Rose will now support model files with mixed languages. When you read in an old model file, Rose will bring up a dialog verifying that the language found will be set as the default language. You can choose to change this selection if you wish to.
Rose C++ introduces some new code generation properties
to the models. To update your model with the new properties, load your
model into Rose and invoke Tools:Model Properties:Update
and then select the rosecpp.pty file found in the C++ directory (rational_dir/releases/rose.I.J.K/addins/c++).
Known Rose C++ Problems and Limitations
The following known defects have been fixed.
| Defect | Description |
|---|---|
| 117512 | Analyzer does not pick up comments
after a template header.
The same occurs with enumerations and typedefs. The Analyzer only picks comments before the enumeration or typedef. |
| 125556 | The code generation does not allow a class utility to inherit from another class utility. |
| 125052 | Crash can occur if NameIfUnlabeled
set to (blank).
Changing NameIfUnlabeled (default properties of has relationships) from the _$supplier to (blank); code generation crashes when trying to generate code for a class with a has relationship that is unlabeled. |
| 125125 | Codegen crash if codegen attribute set to "" (empty string). |
| 126386 | Analyzer no longer focuses on file, after changing file type. Analyzer no longer focuses on the file |
| 130975 | Kanji class name is corrupted after C++ reverse engineering. |
| 131962 | Anonymous instantiations are generated
incorrectly in friend declarations.
Generating a template class X, then creating an instantiated class by anonymous instantiation (for example: instantiated class with name (X<int>). Rose generates code correctly, and does not generate any definition for the instantiated class. Class Y is created, which has an association with instantiated X<int> specifying that class X<int> is to be a friend of Y. The code generator does not generate the name of the anonymous instantiation correctly, where it is referenced. |
| 132030 | Analyzer can crash during export
if 'Export Scope' set to '#include closure'.
Setting the 'Export Scope' option to 'Selected Files and #include' before executing the Export ultimately produces the crash. |
| 132274 | Rose codegen (C++) truncates contents of protected regions over 255 characters. |
| 132620 | Mapper Defect: C++ codegen corrupts contents of protected regions after large protected region. |
| 132660 | Script Defect: the class definition will be generated in both the header and the .cpp file. |
| 132738 | Infinite loop generating C++ on model (based on 'get' and 'set' attributes). |
| 132770 | In Rose 4.0 classes were assigned
only to specification (.h) components.
The C++ generator looked for matching body (.cpp) component and generated the appropriate code in the body. In Rose 98, the C++ generator only generates bodies for classes that are explicitly assigned. A script is available from Rational to adjust Rose 98 models imported from Rose/C++ 4.0 models, so classes-body assignments are added for corresponding class-spec assignments. Refer to "Model Conversion" under "Upgrading from Rose 4.0 or earlier versions" in Chapter 2 of these Release Notes for information in relation to converting Rose 98 models imported from Rose 4.0. |
| 133211 | The C++ Analyzer cannot handle
Japanese comments correctly.
Japanese comments cannot be analyzed correctly if they include DB characters ended by '\' when they are used for class names, attribute names, etc. |
| 133215 | The C++ Analyzer does not retrieve
a string with the last character ended by a DB.
When retrieving a string ended by a DB character whose second byte is '\', the selected line can be incorrect. |
| 133218 | C++ Analyzer does not save the
comment in the subsystems dialog box.
The C++ analyzer's project file contents have changed slightly such that the analyzers of Rose releases prior to 98.2 will not correctly read subsystem names from a project file written with the Rose 98.2 analyzer. The Rose 98.2 analyzer will still read the project files of Rose releases prior to 98.2. The change is the addition of the subsystem comment field to the project file. |
| 133248 | Unable to select category (package) and invoke code generation command (Ctrl-G) and have the code for all classes contained within the category hierarchy generated. |
| 133711 | Crash occurs when changing the case of the first character in the attribute. ${attribute:f}. |
| 133806 | Rose hangs when attempting C++
code generation on two components with a dependency between them.
The hang occurs when trying to assign the components to C++: |
| 133872 | Code generation causes Rose to crash when it tries to produce code for a class in an unloaded package. |
| 133902 | Expanded symbol $supplier is not resolved for link attributes for an association. |
| 140314 | Analyzer causes a segmentation
fault if windu_clientd* daemon does not start (if unable to allocate 16
colors on display).
In some cases, the analyzer dies silently (without a segmentation fault). |
| 140526 | Analyzing functions with default
parameters cause Illegal Sienna Op message:
Error: "*** Illegal Sienna Op: Set_xxx -- Tn_Init_Expression" |
| 140664 | C++ generation of read-only units
displays the wrong error message.
A warning will now be generated and will appear in the LOG window. |
| 140714 | Pressing "Cancel" after getting
"Name Must Exist" dialog causes Rose to hang.
Upon entering a pathway (that does not exist) in the Directories dialog box a message dialog indicating "Name Must Exist" appears. At this point, hitting return or pressing "Cancel" will cause Rose to hang. |
| 141022 | Unable to locate Analyzer, Rose
Ada 83 or Rose Ada 95 help (*.hlp) files.
The following error message appears upon selecting Help from the Analyzer: Workaround:
The following error message appears upon selecting Ada 95 help topic: Workaround: |
| 141164 | Includes workaround to automatically
increase process shell "descriptors" limit when running release, if set
to less than 256 descriptors (for Visual Differencer and Analyzer)
The following error message appears, upon attempting to start the Visual Differencer if the descriptors set to less than 256: Workaround:Clean Up Rose Environment (if visdiff has crashed)
Refer to 'man limit' or the 'man csh' for more information regarding the limit command. |
| 142157 | The help button in many of the
Analyzer's dialog boxes unnecessarily bringsup a context sensitive help
pointer.
When this occurs, clicking in the dialog box, presents a a help file for the entire dialog box. |
| 142230 | The Help:About... box for the Analyzer does not show version# of the Analyzer. |
| 142253 | Help button of Container Types
dialog does not work.
|
The Apex Add-In of Rose 98 provides direct access to the Compile and Control commands in Apex. It also works with language add-ins for Rose 98, including Rose C++, Java, and IDL Add-Ins, to create Apex subsystems and views during the code generation from the model to the source files of the specified language.
The following information is also located in your Apex Add-In online documentation.
Apex Compile and Control Commands
The Compile and Control commands of Apex are directly accessible from Rose 98 through the Apex submenu of the Tools menu. The Compile commands compile and link the source files, generated into Apex views via Apex Add-In, that correspond to the selected items in the diagram. The Control commands perform Apex source code control operations on the source files generated in the same way.
To use these commands, click Apex on the Tools menu, and select Compile or Control to get to the list of commands, respectively.
For the descriptions on these Apex commands, please consult the online help in the Apex windows.
Code Generation With Apex Add-In
In general, the code generation operation for a regular language Add-In is based on a directory structure where top-level packages, nested packages, and classes (or modules) are mapped, respectively, into directories, subdirectories, and source files in a hierarchical way. The operation can create such directories or subdirectories if they do not already exist, and then generate source files into these (sub)directories. This works with the regular source code control system and build management.
Apex has a different style of source code control and build management. An Apex project has a set of subsystems which contain the source files and subdirectories of source files for development. Each developer has his own views, one for each subsystem, which collectively reflect the source base the developer uses for the project. For this reason, Apex-style code generation is different from the regular style. From a Rose model, the top level packages will be mapped into subsystems and the associated views for the developers; the packages nested inside another package will be mapped into the subdirectories inside an Apex view, or a subdirectory already enclosed by a view; the classes (or modules) will be mapped into the source files inside the views or the subdirectories.
The Apex Add-In provides a mechanism for the user to select which of the two code generation styles to use. When the property CreateApexSubsystemAndView of the Apex tool set is set to "Yes", the code generation command for a language add-in will automatically create Apex subsystems and views for the top-level packages selected in the model, followed by the generation of subdirectories and source files into the views. If the property is not set to "Yes", the code generation command does the regular style of code generation.
The language add-ins that work with Apex Add-In include C++, Java, IDL, Ada 95, and Ada 83.
Refer to the online documentation for a list of the properties used by the Apex Add-In for Apex-style code generation. Some are properties for the project, and the others for the subsystems in the model. The code generation command will use the combination of these properties when it needs to generate code into Apex subsystems and views.
All the properties except CreateApexSubsystemAndView will take effect only when the CreateApexSubsystemAndView property is set to "Yes" and when the selected item is a top-level package. When any of these properties are specified differently from their default value, the Directory property for the top-level package should remain as the default value.
Converting a pre-Rose 98 model into a Rose 98 model
A model created by Rose 98 has all the Apex properties inside a stand alone "Apex" property set which the code generation command in Rose 98 uses to create and maintain Apex subsystems and views. However, a model created by the 4.0.16b or earlier versions of Rose Developer or Rose/Ada keeps such Apex properties built inside the "cg" property set. For such a model, the code generation command in Rose 98 will not be able to retrieve those Apex properties in order to function properly. To resolve this incompatibility, the model should be converted into a Rose 98 model before any code generation can be done with Apex Add-In.
The following steps will do the conversion:
Known Apex Add-In Problems and Limitations
|
Defect
|
Description
|
|---|---|
The above error may occur when attempting to reverse engineer Rose/Ada code from Apex, running: Rose:Ada_Reverse Engineer For Rose 98, the Ada reverse-engineering code is done on the Apex side. (It is necessary to use Apex version 3.0.0b or greater.) |
Ada 83 and Ada 95 Add-In Support
The following lists the changes in the Ada 83 and Ada 95 Add-Ins (also known as Rose/Ada) since version 4.0.16.
Ada 83 and Ada 95 Add-In Overview
Rational Rose 98 for UNIX provides two add-ins that support generation of Ada 83 and Ada 95 code. The following capabilities are included:
Note: The Ada 83 and Ada 95 Add-Ins of Rational Rose 98 for Unix do not provide reverse-engineering of Ada code. This capability is now delivered as part of Rational Apex/Ada, starting with version 3.0.0b of this product. The capabilities of the reverse-engineering tool are essentially identical to those provided with Rose/Ada 4.0.16.
Enhancements in Ada 83 and Ada 95 Add-In
The project property CommentWidth has been added. It specifies the maximum number of characters per line in generated comments. Lines in the model that are longer that this are split at word boundaries into multiple lines. The default CommentWidth is 60. This enhancement has the side-effect of fixing defect 133429.
Known Ada 83 and Ada 95 Add-In Problems and Limitations
After creating a new model, you must first execute the Tools:Options command to bring up the Options dialog box. Then, select the Notation tab and choose the default language to be either Ada 83 or Ada 95. If the default language is not set, Ada code generation will not work properly.
Rose 98 for UNIX Overview
In general, we have attempted to introduce as few variations as possible between the Rose 98 product for Unix and the Rose 98 product for Windows. However, due to differences in the underlying operating systems and technologies, it is not always been possible or desirable to hide the details of the underlying execution environment. This chapter is intended to highlight these differences. It should provide a good starting point for those already familiar with Rose 98 on Windows or for individuals who intend to use Rose 98 in a multi-platform environment.
One of the first differences you will notice is the installation process. The Windows version of Rose 98 uses an installation "Wizard" which takes care of extracting the product into the desired location, setting up the required registry entries, creating shortcuts and Start Menu entries, and setting up of uninstall scripts.
The Unix version of Rose 98 has two steps to the install process. The first step is dependent on the installation media type. If you have a Rose 98 CD-ROM, the first step is to run cdinstall, which handles copying the installation scripts to the desired installation location. Otherwise, the first step is to download the rinstall script from the Rational ftp site (ftp.rational.com) and run it. The rinstall script downloads the installation image from the ftp site and copies the product to the desired installation location (referred to here as $ROSE). The second step is to run install in $ROSE/install. This script begins the installation and walks you through the final steps of licensing and post-installation. The only setup not performed by installation is registry setup. Information on setup and configuration of the Unix registry is described in Registry Setup and Customization. For additional details on installation, please see the Rational Rose 98 for UNIX Installation Guide.
For Rose 98, the Virtual Path Map variables have been moved from the .rose.ini file into the registry. Rose 98 provides a script named pathmapconvert.ebs that will convert path map settings from an old .rose.ini file into registry settings. For additional details, see the Path Map Conversion section of the Rose 98 for Windows on-line documentation. Rose 98 for Unix also provides support for converting Virtual Path Map entries from .ini files into registry settings. However, instead of a script, it is an executable named pathmapconvert found in the bin directory of your Rose 98 for Unix installation. This tool reads up a supplied .ini file, and if it contains a Virtual Path Map section, adds each entry in the section to your registry if it does not already exist. The syntax for the pathmapconvert tool is:
pathmapconvert ~/.rose.ini
Registry Setup and Customization
On the Windows platform, registry information is set up during installation and you can use the regedit tool to customize it. On Rose 98 for Unix, registry information is setup and configured the first time you run Rose 98 on a particular machine. For registry support, Rose 98 for Unix uses a registry daemon which manages a per-user registry in $HOME/.windu.<machine_name>. There is a regedit tool, provided with the Rose 98 for Unix product, which works with this daemon. The first time you run Rose 98 for Unix on a new machine, regedit is run with the .reg files in $ROSE/registry and $ROSE/addins/* as input. This takes care of setting up your initial Rose 98 registry environment.
There are two special registry files that allow for easy customization of your registry settings in Rose 98 for Unix. The first registry customization file, located in $ROSE/registry, is site.reg. You can edit this file to add custom registry entries on a site-wide basis. That is, all users who run the installation of Rose 98 where site.reg was modified will see the changes in their initial registry environment. The second file is for user-specific registry customization. This file is located in $HOME and is called $user.reg (where $user is the Unix username). Entries in this file are applied only to the registry for that particular user. The site.reg in $ROSE/registry contains comments with a sample registry entry. site.reg also contains information about the versioning mechanism that provides a means of forcing a reload of the file for all users when changes are made to the file.
The following information applies only to Rose 98 for Unix. Under Rose 98 for Unix, there is a new field in the Virtual Pathmap dialog that allows setting of an "Automounter Prefix Removal Pattern". If your site uses an automounter, this field should contain a pattern describing the prefixes the automounter adds to pathnames. When the analyzer stores a filename in a Project or data file, it strips any matching automount prefix from the path so that the stored name is portable from machine to machine on your network. For more information on this setting, consult the sections on automount in the on-line documentation.
Rose 98 provides several mechanisms that allow you to extend and customize its capabilities to meet your specific software development needs. These mechanisms include customizable menus, Rose Scripts, in-process OLE using Rose Automation objects, and OLE server extensions.
The Rose Scripting language is an extended version of the Summit BasicScript language, and is supported in both the Windows and Unix versions of Rose 98. The Rose extensions to basic scripting allow you to create, query, and manipulate Rose specific objects such as Diagrams and Classes. In addition to use of the Rose basic script extensions, Rose script supports the DECLARE statement which provides a mechanism for calling arbitrary external routines from within Rose script. For more information on Rose script and the REI, see the Rose on-line documentation.
Rose 98 for Unix can also, with a 3rd party product, be extended using in-process OLE and OLE server extensions. To obtain additional information on extending Rose 98 for Unix using in-process OLE or OLE server extensions, contact Rose Technical Support.
Add-Ins
Visual Diff/Merge
The Rose 98 Visual Diff/Merge tool, commonly referred to as visdiff, functions in essentially the same manner on Windows and Unix with one difference. Under Windows, when the visdiff tool is started from the Tools menu, it is launched as an automation server and is passed a handle to the running Rose 98 application. The result is that visdiff is started with an OLE automation connection to the running rose and its currently open model. Any changes made to this base model, such as changes resulting from a merge operation, are immediately visible in the running Rose. Even if you change the base model in visdiff but elect not to save the changes on exit from visdiff, they will still exist in the open model in Rose. You can, of course, exit Rose and specify that the changes are not to be saved if you decide you don't want the changes to be written to the saved model on disk.
Under Rose 98 for Unix, launching the visdiff tool from the Tools menu does not cause visdiff to use the existing Rose session as an automation server. If there is a model currently open in Rose, visdiff is started with the path to this model on its command line. Any unsaved changes to this model will not appear in the model in visdiff. If no model is open when visdiff is started it will prompt the user for both the base and reference model on startup. Since the running Rose application is not being used by visdiff, any changes made to the base model will not be reflected in the open Rose model. To see the changes, first save the changes from visdiff and then reload the model in Rose.
Since it does not reuse the running Rose application, the Rose 98 Visual Diff/Merge Tool on Unix always uses two Rose automation servers to read and write it's Rose models. As a result, it can consume a considerable amount of machine resources, particularly for large models. If your machine or shell environment is not configured with adequate resources, the visdiff tool can fail in sometimes strange ways.
In order to communicate with the automation servers, visdiff uses RPC. The connections established by the RPC protocol require approximately 100 file descriptors for each automation server. Since the default shell limit for file descriptors on some platforms is as low as 64, it may be necessary for you to modify your shell resource file (e.g. $HOME/.cshrc) to change the limit for descriptors in your environment. We recommend a value of at least 256. If you encounter error messages indicating that visdiff was unable to open a file or shared library on startup, the probable cause is an insufficient descriptor limit in your shell. Under Bourne Shell and C Shell, you can get and set the descriptor limit using the built-in limit command.
Another resource that can be strained by visdiff is memory. If you launch visdiff from the Tools menu in Rose, you will have three separate rose instances running. One for the Rose you launched visdiff from and two automation servers for use by visdiff. If your machine is configured with insufficient memory and/or swap space you may encounter large performance problems due to "thrashing" and possibly even out of memory errors in visdiff. The following error is indicative of an out-of-memory (insufficient available swap space) condition:
Wind/U Error (129) : Function wuInitMsgQ could not
allocate memory
In addition to the obvious solution of configuring additional swap space on your machine, you can reduce the amount of memory being consumed by invoking visdiff directly instead of from within Rose. If you exit Rose and run visdiff from the command line, you reduce the number of running Rose processes by one, reducing the memory requirements. If you are still running into problems, you can try disabling some or all of the Rose add-ins before running visdiff. To do this, run Rose and bring up the Add-In Manager. Simply deselect all of the "checked" add-ins and then exit Rose. Then run visdiff from the command line. When you run Rose again, you can bring up the Add-In Manager and re-enable the desired Add-Ins. Keep in mind that only enabling add-ins you are actually using will remove unused menu items, and improve Rose startup time and memory requirements.
Currently visdiff will not run on Digital Unix version 4.0D.
The only difference between the Java add-in under Windows and the Java add-in on Unix is with the CLASSPATH variable. On Windows, this variable is a semi-colon `;' separated list of paths set in your Windows environment (where this is actually set depends upon which "flavor" of Windows you are running: 95 or NT). On Unix, the CLASSPATH is a shell variable set to a colon `:' separated list of paths. Note that this variable must be set before running Rose. Otherwise, you will be unable to perform Reverse Engineering of Java files. There is currently no way to set this variable once Rose has been started. So, you will probably want to set this variable to an appropriate value in your shell resource file.
At present the Rose 98 Framework Wizard is available only in the Windows version of Rose 98.