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

What's new in ST-Developer Version 14

ST-Developer v14 adds a new .NET programmable geometry viewer, new STEP Application Protocols, as well as continued support for the CIMsteel Integration Standard (CIS/2) and Industry Foundation Classes (IFC), new Visual Studio 2010 and 2008 libraries, new programming DLLs, and many other refinements.

Supported Platforms

Operating System Architecture Supported C++ Compilers
Windows 7/Vista/XP 32bit Intel x86 Visual Studio 2010 (VC++ 10.0), Visual Studio 2008 (VC++ 9.0), Visual Studio 2005 (VC++ 8.0), and Visual C++ 6.0 with the /MT and /MD options.
Windows 64bit Intel x64
AMD64
EM64T
Visual Studio 2010 (VC++ 10.0), Visual Studio 2008 (VC++ 9.0), Visual Studio 2005 (VC++ 8.0) with the /MT and /MD options.
MacOS X on PowerPC
v10.4+ (Tiger)
PowerPC GCC 3.3 and GCC 4.0 (Xcode 2.0)
MacOS X on Intel 32bit
v10.4+ (Tiger)
Intel x86 GCC 4.0 (Xcode 2.3+, Xcode 3.x)
MacOS X on Intel 64bit
v10.5+ (Leopard)
Intel 64bit GCC 4.0 (Xcode 2.3+, Xcode 3.x)
Linux
LSB 3.x or newer distros, RHEL 4/5, SuSE 9+, and many others as described in the install notes.
Intel x86 GCC 3.4/4.x
Linux 64bit
LSB 3.x or newer distros, built for x86_64. See install notes for examples.
Intel 64bit
AMD64
EM64T
GCC 3.4/4.x
IBM POWER-series
AIX v5.3
POWER5 IBM XL C/C++
Hewlett Packard
HP-UX v11
PA-RISC HP ANSI C++
Hewlett Packard
HP-UX v11
Itanium HP ANSI C++
Silicon Graphics
IRIX v6.x
MIPS SGI C++ default and -n32
Sun Solaris v10 SPARC Sun Studio v11 (default and with -PIC -mt)
Sun Solaris v10 Intel x86 Sun Studio v11 64bit default and with -PIC -mt

Supported Application Protocols

ST-Developer v14 ships with a wide selection of C++ and Java class libraries, sample programs, HTML-documented schemas, and usage guides. In this release we have added or updated support for AP203 second edition, AP210 second edition, AP214 third edition, AP223, AP235, and technical corrigenda for AP215, AP216, AP227, and IFC 2x3.

You can start programming immediately, with out-of-the-box support for twenty two STEP Application Protocols, the CIMsteel Integration Standard (CIS/2) as well as two versions of the Industry Foundation Classes (IFC). If we missed your favorite, you can use EXPRESS compiler and other ST-Developer tools to install them yourself! The electronic manuals have quick links to each of the following:

New ST-Viewer

The ST-Viewer tool has been completely updated to use the same STEP geometry visualization technology found in our STEP-NC Machine product. The new version is based on a new .NET library that that you can use to add STEP visualization to your .NET Forms applications.

The new ST-Viewer lets you explore the product and shape assembly trees in a STEP file, turn assembly components on or off, and change the display color or transparency of things. Tooltip popups display the underlying STEP entities for the shape representations, relationship, and product entities so that you can trace their use within the STEP P21 file. The tool displays STEP geometry with both context-dependent shape representation and mapped item assemblies, color information, and AP203e2 presentation tolerances.

Consult the ST-Viewer Reference Manual for a complete description of these capabilities.

ST-Viewer

ST-Viewer browsing a STEP assembly.

New ST-Developer Tool Windows

The ST-Developer compilers, checkers, and other tools have always been available as both command line tools and Windows dialog versions. In this release we have updated all of the Windows versions to be even easier to use and include more options.

Previously, you could only start the Windows dialog versions one at a time through the ST-Developer Launcher and all output messages were shown in the launcher window. Now you can run all of the tools at once from the Launcher, or directly from the Start Menu, plus each tool window shows it own messages. The ST-Developer Launcher has been simplified and now has a quick link to the ST-Developer online manuals.

In addition, you can now drag and drop files into the tool windows, each one keeps a list or recently used files, and you can cut and paste, save or print the messages printed by the tools.

ST-Developer Tool Windows

The ST-Developer Launcher and Windows dialog interfaces for several tools

ST-Developer DLLs

ST-Developer for Windows now supports DLL versions of the ROSE C++ library and all preinstalled schemas. The DLL support is available for programs built with Visual Studio 2010, 2008, and 2005. Both release and debug configurations are provided.

The DLL versions of the ST-Developer libraries are most useful if you build several sub-project DLLs that each must access C++ objects read or written to P21 files. The memory for the objects are managed by the shared ST-Developer DLLs and you can work with them across your DLLs. ST-Developer still includes static libraries, which are usually the simplest choice if your program has no sub-projects.

Switching to the DLLs is a simple change to your project files. Distributing your applications linked to the DLLs becomes a little more complex, however, because you must make sure that your programs can find the ST-Developer DLLs as well as the Visual Studio runtime.

A simple application built with static libraries and a more complex application using shared DLL versions of the ST-Developer libraries

Part 28 XML Improvements

ST-Developer makes it simple to examine STEP XML files in any web browser with the Part 28 to HTML conversion tool. On Windows, this tool integrates into the Explorer so you can open a file in a web browser by simply right clicking on it and selecting "Browse P28 XML" as shown below. In this release, we have added a "Browse P28 XML (quick)" option that handles larger XML files.

Browsing a large P28 file using simplified HTML.

We have also made many of internal improvements to the P28 XML reading and writing library to better handle STEP data. These improvements are summarized in the table below.
Issue IDDescription
---Fixed problem with double quote appearing in XML attributes that was not properly escaped.
---Fixed crash when writing entity instances with no attributes.
---Changed handling of zero byte files so that an IO error is generated rather than a ROSE error (which would exit).
---Major improvement to write speed by reducing buffering for XML attributes.
---Corrected memory leak during write from creating RoseDictionary instances.
---Corrected P28 reader to read lists of strings.
---Updated P28 reader and writer to handle binary data as hexBinary, using the P21 encoding.
---Corrected P28 writer to correctly emit selects of aggregates of entities.
---Applied patch for expat security bug #1990430
---Updated zlib version to 1.2.5
---Updated minizip version to 1.01h

ROSE Library Improvements

As described above, the ROSE C++ library is now available in DLL form for use with programs built in both release and debug configurations, with Visual Studio 2010, 2008, and 2005. In addition, many of the functions in the RoseInterface object were deprecated in the last release and have now been retired. These functions are simply aliases and can be replaced with the RoseDesign functions of the same name.

    RoseInterface::addName()
    RoseInterface::addSchema()
    RoseInterface::designName()
    RoseInterface::display()
    RoseInterface::findDomain()
    RoseInterface::findObject()
    RoseInterface::findObjects()
    RoseInterface::format()
    RoseInterface::nameTable()    
    RoseInterface::pnewInstance()
    RoseInterface::removeDesign()
    RoseInterface::removeName()
    RoseInterface::rootObject()
    RoseInterface::saveDesign()
    RoseInterface::saveDesignAs()
    RoseInterface::setDesignName()
    RoseInterface::setFormat()
    RoseInterface::setRootObject()
    RoseInterface::useSchema()

In addition, the following type aliases have been deprecated and will be removed in a future release.

    STR         ==> use RoseSTR
    ArrayOfSTR  ==> use ArrayOfString
    BagOfSTR    ==> use BagOfString
    ListOfSTR   ==> use ListOfString
    SetOfSTR    ==> use SetOfString
    DictionaryOfSTR  ==> use DictionaryOfString

With previous versions, you could use declare() and implement() macros for manually declaring new aggregate classes. These macros have been retired, so you so you must change any uses to the ROSE_DECLARE_AGG() and ROSE_IMPLEMENT_AGG() macros as shown below.

declare(npList,DefInfo);              // Change this
implement(npList,DefInfo);

ROSE_DECLARE_AGG(npList,DefInfo);     // To this
ROSE_IMPLEMENT_AGG(npList,DefInfo);

See Migrating Programs from Earlier Versions for a complete list of changes if you are upgrading code written for an earlier version of ST-Developer.

In addition to these changes described above, we have addressed a number of library issues in this release. The issues are listed in the table below.
Issue IDDescription
370GCC 4.1 roselib warnings. The roseHdefs.h file had a warning about a multi-line comment caused by a commented macro containing backslashes, The RoseError.h file had several warnings about non-virtual destructors reported when using -Wnon-virtual-dtor. These have been fixed.
447rose_get_nested_object type filter does not work. Using the filter would produce "cannot typecast" warnings. These have been fixed.
448Retire RoseImport
465Late-bound ANDORs are missing redeclared as derived info. When the domains for complex instances are generated at runtime instead of being generated at compile time by a workingset, the result did not have information about attributes redeclared as derived. This resulted in incorrect P21 encoding because the required star * is missing from the attribute field. Seen with si_unit andors. This has been fixed.
466Allow P21 read of incorrectly wrapped primitives. The P21 parser rejected simple primitives when they were incorrectly wrapped with a name in the manner of selects. There is a system (SAP2000) that is writing CIS files in this manner. We have improved the parser so that it now warns and ignores any typed parameter wrapping that shows up around non-select values, which takes care of this particular class of syntax errors and lets us still get useful data from the wrapped value.
517Part 21 files with unusual line breaks. Fixed the P21 writer so that it now inserts a newline when writing an enum or a select keyword tag that would extend beyond the normal wrapping point.
521RoseBackPtrCursor traversal problem. RoseBackPtrCursor would only work properly within a ROSE.traversal block. It now works properly everywhere.

Java Library Improvements

We have made a number of improvements to the Java programming libraries. The library issues that were addressed in this release are listed in the table below.
Issue IDDescription
294A string with an embedded quote char ('') in a P21 file could not be read. This has been fixed.
296EntityDomain.domain(List) should take Set as its parameter, not a list. The API mathod has been updated to take a generic Collection.
445The two argument version of EntityInstance.usedin did not work. The three arg version did, but only if explicitly passing in the target domain. This has been fixed.
446Add one arg version of EntityIDTable methods. The methods forModel and getId take a boolean parameter which if true will create the appropiate value. This are now optional, and default to false, to make client code simpler.
461P21 parse error with \\. Escaped backslashes in strings were not handled correctly, and instead caused a P21SyntaxException to be thrown.
462Implement Binary types. Binary types were not implemented, but have now been added to support List Of Binary in IFC2X3.
463Report line number on ClassCastException in P21 filer. The exception now includes the STEP P21 file line number to simplify error tracking.
490Implement PopulationBase.getExtent(String). Added a convenience method to get an EntityExtent by name from a population.
494P21 parse error with enums/booleans. The Java Part 21 parser could not read a boolean value contained within a select. This has been fixed.
499Usedin of aggregates of instances does not work. This has been fixed.
518Part 21 file strings containing backslashes not written with proper escape characters. Fixed the P21 writer so that it now writes the proper double backslash escape sequence.

Conformance Checker Improvements

The ap214check AP214 Conformance Checker has been extended to now support the third edition of AP214. In addition, all of the conformance checkers are easier to use with new tool windows that can cut, paste, save, or print the checking results. Consult the ST-Developer Tools Manual for more information on the updated checkers.

EXPRESS Compiler Improvements

We have made a number of improvements and fixes to the expfront EXPRESS Compiler. In addition, the new tool window should simplify managing the many different compiler options. Consult the ST-Developer Tools Manual for a complete description of the new interface. The compiler issues that were addressed in this release are listed in the table below.
Issue IDDescription
303 Case preservation bugs. When two different constructs shared a name, only the capitalization of the first one would be preserved used for all further code generation. This was first noticed with the Owner attribute in multiple IFC entities. The compiler and class generator now tracks each defining use, so the capitalization should be as expected in C++ classes.
359 Problem with attribute having same name as type. Upon review, this was found to be a duplicate of Issue 454 below.
443 Conflict between enumeration value and type name. Enumeration values and type names should be in separate namespaces, but the compiler was handling them in the same namespace. This has been fixed, and as a side effect, the compiler is now much more vocal when something does not resolve to a type.
454 Not proper specialization warnings in modular longforms. The second TC to EXPRESS E1 added several new redeclaration cases to clause 9.2.3.4 that say a redeclare can go from SELECT to a member as well as from an entity to a SELECT of subtypes. The compiler has been updated to allow these cases without complaint.
455 Crash when compiling schema. Compiler front-end now reports cyclic inheritance.