This describes an older ST-Developer release (2003). You can find the details for the latest release here

What's new in ST-Developer v10

ST-Developer Version 10 is the eleventh major release of the ST-Developer suite of STEP and EXPRESS programming tools from STEP Tools, Inc. It includes a number of exciting enhancements, extensions and new tools.

These enhancements should make it faster and easier than ever before to read, manipulate, validate, and share STEP data. Included in this release is the ST-Runtime package which will make it easier to distribute applications that you create with ST-Developer

The version 10 release updates the EXPRESS to HTML converter to generate more useful and informative output. Options have been added that allow you to force the output to have short file names, and also to place a link on each page which can provide an exit from the HTML pages.

The EXPRESS compiler has been enhanced to generate a longform schema from a shortform

As in previous releases, the Windows version of ST-Developer is bundled with the latest version of our ST-Viewer product. The new viewer features several enhancements that enables it to view files from the shipbuilding APs.

The ROSE library features several enhancements. We have added several options to the Part 21 filer to enable you to preserve entity ID, and to search a design in memory by entity ID. Part 21 is now the default file format. The system now, by default, gives up reading a STEP and returns an error if the corresponding schema cannot be located. A new backpointer facility has been added to the ROSE library.

ST-Developer v10 Supported Platforms

Architecture Operating System Supported C++ Compilers
HP PA-RISC HP-UX v11.0 HP Cfront C++ with and w/o +eh,
Intel x86 Linux glibc 2.3.2
(RedHat 9)
GCC 3.2.2
Intel x86 Windows: 98, NT4.0, 2000, XP Visual C++ v6.0 with /ST, /MT, and /MD options.
Silicon Graphics IRIX v6.x SGI C++ default and -n32
Sun SPARC Solaris v7-8 Sun C++ v4.2, Sun Forte C++ 5.0 and 6.0 (with and w/o -PIC -mt), GCC 2.95

ST-Runtime Package

In order to simplify software development, the ST-Runtime package it now included with ST-Developer. This is a freely redistributable package containing the schemas and other run-time support files that ST-Developer based applications require in a form that can be quickly installed by the end user of your ST-Developer application.

While ST-Developer has always provided a mechanism for applications to specify where the schemas are installed, it required custom code to be included in an application to tell the run-time system where the schemas could be located, or else the end-user had to recreate a portion of the ST-Developer environment on their machine. By installing ST-Runtime on the target machine, your application will behave the same way under both the development environment (provided by ST-Developer) and the deployment environment on the target machine.

On the Windows platform, The ST-Runtime package is provided as both a stand-alone Windows Installer (msi) package, and as an installer merge module. Thus you can integrate ST-Runtime into your installer, or for simple applications, you can include the ST-Runtime installer along with your application, and let the user install the two independently.

On all platforms, the ST-Runtime package is provided as zip file containing the schema files that are included with ST-Developer.

For more information, see Packaging Applications for Distribution in the Rose Library Reference Manual.

Due to the introduction of ST-Runtime, the system_db directory has been eliminated. The data that was there has either been moved to the ST-Runtime package (for those items that may be needed by applications developed using ST-Developer) or into the lib subdirectory for those items that are only used by the tools included with ST-Developer.

EXPRESS shortform to longform conversion

ST-Developer now provides the functionality of converting an EXPRESS shortform schema (a schema which references or uses resources from other schemas) into an EXPRESS longform schema (a schema which does not reference or use resources from any other schema). This is implemented by the -shtolo option of the EXPRESS compiler. This feature should be most helpful to AP Developers.


A number of features have been added to the EXPRESS to HTML converter. The frames-based page for each definition now includes more detailed cross reference information. See the ST-Developer Tools Manual for more information.

The complete set of subtypes of an entity is now included, instead of the list of immediate subtypes. Immediate subtypes are identified with an asterisk ("*") in the list.

The "Referenced By" table on each definition now includes every definition (entity, type, rule, or function) which references the item or, in the case of entities, any of its supertypes. Because of this, the table can get quite large. To make it easier to navigate the table, it consists of dynamic HTML which can sort the table by any column. To sort the table, simply click on a column heading, and the table is updated. This feature has been tested with recent versions of Internet Explorer, Mozilla and Netscape Navigator. If for some reason you do not desire dynamic HTML, you can disable it by using the -nojs option when you generate your HTML.

The -exit and -exittext options have been added to enable you to provide a link to a URL you specify on every page to return to the HTML page where the user began the navigation.

The -truncate option causes the generated HTML file to be truncated to 10 characters plus the extension. The names of the files are based on the EXPRESS definition names, some of which can be more than 50 characters in length, which can get unwieldy when distributing the data electronically.

The names of the entities in the generated HTML files now begin with t_ This causes the index.html file to appear near the top of an alphabetically sorted of files generated by the EXPRESS to HTML converter.

ST-Viewer Enhancements

ST-Developer includes ST-Viewer version 5.0. This new version of ST-Viewer, which is also available as a stand-alone product, incorporates a number of enhancements

ST-Viewer now has added support for non-manifold surface shapes. Such shapes are used frequently by the suite of application protocols defined by the ship building industry (e.g. AP 215, 216, and 218), thus enabling such AP to be visualized by the viewer.

In addition, ST-Viewer now generates a better faceted 3-dimensional representation of the geometry. This improvement results in an improved visual appearance of the STEP part on the screen.

The import file preferences dialog form now contains an optional check box that allows the product structure tree naming conventions to use instance names rather than part names. This is helpful for distinguishing a part which occurs multiple times within an assembly tree.

Part 21 Filer Enhancements

The ROSE library includes a filer that can read and write STEP Part 21 files. While there have been no changes to the Part 21 specification since the last release, several options have been added to the STEP filer to simplify applications that work with Part 21 files.

Part 21 is now the default format for RoseDesigns. This means that you no longer need to include


to set the save format to Part 21. In the past, the default format was the ROSE binary ("standard") file format. If you need to save data in a ROSE binary file, you need to set the format to standard before you call the save method.

Since Part 21 does not support inter-file references between objects, the filer now generates a warning when such an object is encountered while writing it. Such inter-file references are written as NULL values, and so there is a potential for information loss. If you need to save such designs, you will need to set to format of the design to standard or rose before saving.

Missing schemas prevent file read

The Part 21 file reader will now raise an error and abort the read of the file when the schema in the file header cannot be located.

Under the old behavior, when a schema could not be found, the filer would generate an error for the missing schema, plus another warning for every instance in the file, creating a huge number of messages. The RoseDesign that resulted from reading the Part 21 file was then empty of all instances.

The new behavior generates a single error for the schema itself, and the RoseDesign that is returned from ROSE.findDesign() is NULL. This new behavior makes it more convenient easier to check for errors in your application.

If the old behavior is desired, it can be enabled by setting the static variable RoseP21Parser::allow_bad_schemas to RoseTrue.

Enhanced Entity ID Management

The management of Part 21 Entity Instance Identifiers (EIDs) has been greatly enhanced. It is now possible to preserve the EIDs in a Part 21 file without writing a custom renumbering function. You can decide if the instances in a Part 21 file are sorted by EID, and you can control where new EIDs are inserted. This functionality is controlled by the following static members of RoseP21Writer.

    static RoseBoolean preserve_eids;        /* Do we save eids */
    static RoseBoolean sort_eids;            /* Do we sort by eid */

The RoseP21Writer::preserve_eids variable, if true, enables the preservation of entity instance identifiers. If you turn on this option it can slow down the creation of Part 21 files, so it is turned off by default.

The RoseP21Writer::sort_eids writes the EIDs in a Part 21 file in sorted order. This will normally happen when preserve_eids is turned off, since the writer uses the same traversal procedure to first number and then to write the instances, however when preserve_eids is turned on, this option can be used to force the entities to be output in a sorted order. Note: this option requires an index be built for the EIDs before they can be written out, and so is somewhat expensive. While an unsorted Part 21 file may look strange, it is perfectly valid according to the Part 21 specification.

A new method has been added to RoseDesign to quickly find an object by EID.

    RoseStructure * findByEntityId(unsigned long id);

The first time this method is called on a design, is creates an index which makes all subsequent calls very efficient. This index can be deleted (to save memory, for example) by calling the deleteEidIndex() method.


The references between entities in STEP Application Protocols often point is a direction that is inconvenient for application programmers to utilize. Thus, the rose library now includes a feature to compute the backpointers for an instance to simplify traversal.

Before you can utilize backpointers, you must call the rose_compute_backptrs() function, passing the RoseDesign for which you want the backpointers computed as the parameter. This traverses the data and builds up the index of backpointers for all the instances in the design.

You can then retrieve the backpointers for any instance in the data by calling the rose_get_backptrs function and passing the object you need the back pointers to. This returns a RoseBackptrs object which can then be used to find all the references to the target object.

For example, you can use the following code to find all the instances that refer to the object obj.

    RoseDesign *des = obj->design();
    RoseBackptrs *bp = rose_get_backptrs(obj);
    for (unsigned i=0; i<bp->size(); i++) {
      RoseObject * ref = bp->get(i);
      /* Ref points to obj -- do something with it here */

You can also use a RoseBackPtrCursor to limit the scope of a search to a particular attribute. For example this can be used to efficiently compute inverse attributes.

    RoseObject * product;
    RoseAttribute * att = des->findDomain("product_definition_formation")
    RoseBackPtrCursor cur;
    RoseObject *pdf)
    while (pdf = {
      /* Do something with the product_definition_formation in pd */

You can call the rose_release_backptrs() function to clean up memory usage after you are finished.

Unset attributes

The following methods have been added to RoseObject to make working with unset attribute values simpler.

    RoseBoolean isUnset(RoseAttribute * att, unsigned index=0);
    RoseBoolean isUnset(const char * att_name, unsigned index=0);
    void unset(RoseAttribute * att, unsigned index=0);
    void unset(const char * att_name, unsigned index=0);

It is no longer necessary to have a big switch statement to check for all the possible primitive types to either put or compare to the appropriate NULL value. This functionality is now in the core library.

Internationalization Functionality

The stepi18n library has been removed. All of its functionality including the functions rose_cvt_p21_to_wchar() and rose_cvt_wchar_to_p21() has been moved to the rose library.

Shortname syntax change

The syntax for short name files (*.nam) has been changed with this release. This is a text file where each line consists of long entity name and a short entity name. In past releases the syntax consisted of the shortname followed by the longname. In this release, the syntax is:


This new syntax conforms to the format distributed with many EXPRESS application protocols, so the short name files no longer need to be translated.

Additional EXPRESS Schemas

Several application protocols have been added to the ST-Developer this release. As always, you can use the EXPRESS compiler to compile any schema for which you have EXPRESS, but for your convenience, these schemas have been included as both EXPRESS information models in the express directory in the ST-Developer installation, and also as compiled schemas in ST-Runtime.