ROSE Library Change History

Changes in release 18.2 (in progress)

• The operator new defined for all RoseObjects now only takes RoseDesignSection. Retired the one takes RoseDesign, but changed the pnew macro so this should be transparent.

• Copy ctor and assignment copy operator for all RoseObjects are private. RoseObject is designed for use as pointer to instance. Use RoseObject::copy or rose_copy() for duplication.

• File format detection for both Part 21 and XML now skips a UTF-8 Byte Order Mark (U+FEFF) at the start of the file.

• Added rose_path_is_url() and rose_path_is_absolute() functions.

• Added functions for working with ISO 8601 timestamps in a variety of contexts. The rose_iso_timestamp() function is deprecated, replace with rose_datetime_now()
  • rose_get_utc_offset_secs()
  • rose_datetime_add_secs()
  • rose_datetime_cmp()
  • rose_datetime_diff_secs()
  • rose_datetime_format()
  • rose_datetime_format_utc()
  • rose_datetime_now / now_ms()
  • rose_datetime_parse()
  • rose_datetime_to_month_day()
  • rose_datetime_to_ordinal_day()
  • rose_datetime_utc_now / now_ms()

• The rose_iso_timestamp_from_time() function has been retired. Use the rose_datetime_format() function instead.

• Early bound access to an uninitialized RoseUnion on Windows might return garbage. Fixed to now return zero.

Changes in release 18.1 (2019-10-28)

• Version 18 Service Pack One release.

• Update expat to version 2.2.9.

Changes in release 18.0 (2018-10-01)

• Version 18 release.

• Better Part 21 recovery when reading malformed list fields.

• Better checking for minus zero, NaN, and infinity when writing floating point values in a Part 21 file.

• Now checks for embedded comment start end tokens when writing P21 comments. Will prevent inadvertant corruption by adding a space to break up the token.

• Removed deprecated RoseDomain name_hook, use write_name_fn instead.

• Added tests for common IEEE floating point conditions to st_defs.h
  • STPT_FLOAT_TEST_DECLARE()
  • STPT_FLOAT_IS_ANYZERO()
  • STPT_FLOAT_IS_MINUSZERO()
  • STPT_FLOAT_IS_UNPRINTABLE()
  • STPT_FLOAT_IS_INFINITY()
  • STPT_FLOAT_IS_NAN()

• Added RoseKeyDoubleLookup and RoseKeyIntLookup classes.

• Added rose_sprintf_double() function for consistent formatting in tests and other uses.

• Corrected startup issue that could result in bad element size for enums and aggregates of enums. Also changed enum aggregate macro to use the express type name in the RTTI.

Changes in ROSE Library 17.4 (2018-05-22)

• Fixed behavior of rose_file_exists() on Windows with files larger than 2.5GB when building with Visual Studio 2015 and 2017. The CRT for the newer compilers change behavior of _stat()/_wstat() with files larger than signed 32bit maxint. This prevents findDesign() of large files with those compilers because the library does not think the file exists.

Changes in ROSE Library 17.3 (2018-05-01)

• Now sets ROSE.design() to null if that design is deleted or emptied from the trash.

• When writing the ANCHOR section include the name or id attribute, if the object has one, along with the type comment.

Changes in ROSE Library 17.2 (2018-01-05)

• When the implementation level string in the Part 21 header is missing or empty, use the 1995 TC select algorithm, rather than the original 1994 IS one. This will result in better reads for nested select types.

Changes in ROSE Library 17.1 (2017-12-29)

• Added an explicit destructor to aggregate class macros, which by the will prevent c++11 compilers like vc14/vc15 from generating an extra move constructor by the "rule of zero". This matches changes to the EXPRESS compiler to add an explicit dtor to the generated entities and selects, and omits the many-argument custom ctor. All of these help accommodate the increased number of classes in AP242e2.

Changes in ROSE Library 17.0 (2017-04-07)

• Version bump for major release.

• Updated zlib to version 1.2.11

• Updated expat to version 2.2.0

• The ROSE_DECLARE_MEMBERS() macro defines a single new operator with a design section and a default domain argiment where before it made two different ones.

Changes in ROSE Library 16.15 (2016-11-28)

Changes in ROSE Library 16.14 (2016-11-02)

• Deprecated NULL_ENUM, use ROSE_NULL_ENUM instead.

• Part 21 writer and RoseObject::putInteger now handle out-of-band enum data gracefully.

• Added rose_enum_to_string() and rose_string_to_enum() functions to encapsulate all of the casting behavior.

• Added RoseOutputString, a string-builder stream which expands as needed and returns a null terminated string on request. Also added put_sprintf() to the base RoseOutputStream class to printf() format a string in one step rather than a rose_sprintf followed by a put()

• Moved RoseInputZipMember and RoseOutputZipMember classes to a public header file, but they are low level and require much supporting C code to open and search the zip file.

• Documented all RoseInput and RoseOutput stream classes, although they are still primarily internal utility classes.

Changes in ROSE Library 16.13 (2016-06-01)

• Released as ST-Developer v16 SP4

• An application can have multiple designs with the same name in memory, as long as their file paths are different. A program can read "dir1/foo.stp" and "dir2/foo.stp" now. findDesign() looks at the full path of designs in memory when deciding to read from disk or return a design in memory. You can still do findDesign("foo"), and it will return the first match. The end result is that RoseDesign objects are automatically assigned to the ROSE.workspaceDesigns() list of designs in memory as soon as they are created. Previously, they only appeared when they were given a name, which could lead to odd situations and memory leaks.

• RoseInterface::findDesign() and findDesignInMemory() now search the designs in memory by full path if given, findDesign("bar/foo" will only return a design read from "bar/foo", while findDesign("foo") can return a design read from "./foo", "bar/foo", or "baz/foo". If all three are in memory, it returns the first one read.

• Both RoseDesign name() and path() functions accept a full file path with directory and extension. The name() function can take partial information. It will only change the directory if one is given. It will change the file extension given and will add a default one if neither the string nor the design have one. Use path() to set the complete file path explicitly, without any additional behavior.

• Designs are saved to the current directory by default, rather than the first directory in the RoseInterface search path (which was the current directory if you did not explicitly change it) To make a design save to a particular directory, set it with fileDirectory() on the design or set the full filename with RoseDesign::path()

• Added fileArchiveMember() to RoseDesign to hold the path within an archive, such as a zip file, that a design was read from or will be written to. If null, use the default name.

• Changed the return type of RoseDesign string functions to be const, including path(), format(), fileDirectory(), fileExtension(), all of the rose_getenv_* functions. Also added const to the following:
  • RoseObject::className();
  • RoseObject::entity_comment();
  • RoseP21EntityNameFn
  • RoseAttribute::name();
  • RoseDomain::name();
  • RoseDomain::short_name();
  • RoseP28NamespaceFn
  • RoseP21EntityNameFn
  • RoseType::name();
  • RoseType::schema_name();
  • rose_iso_timestamp_from_time
  • rose_iso_timestamp
  • rose_get_schema_property
  • sdai_isotime

• Dictionary put() with a null key no longer crashes.

• Added rose_path_dir/base/ext() functions for path parsing and retired the rose_dirname, rose_basename, and rose_extname functions, which used a static character buffer and were not thread safe.

• Added rose_path_join() to replace rose_expand_path(), which used a static character buffer and was not thread safe. The new function no longer expands environment variables in the directory name, which

• Added rose_path_search() to find the file path completion for a given name, directory, and possibly extension. If the directory or list of directories are missing, just look in the current directory. Store the first match in result and return the value. Returns null if no match found. If ext is not given, searches for all known extensions. RoseServer::searchPaths() has been retired.

• Added rose_path_cmp() for string comparison of paths. Folds case and backslashes on windows and anywhere else that is needed. Also knows that ./foo.bar and foo.bar are the same. Replaces the less capable rose_file_strcmp()

• Made the return values for many string access functions const char rather than just char. This includes RoseDesign name, directory and extension, the RoseP21SchemaNameFn

• Added a copy constructor for RoseCursor.

• Added rose_io_use_write_and_rename() preference setting to switch between writing a temp file with a rename (true) and writing direct to the final destination (false) The rename operation prevents a failed write from destroying an existing file, but some situations may require writing directly to the final filename.

• Moved ROSE.useShortNames() to RoseP21Writer::use_short_names so that it is with all of the other STEP file preferences.

• Fixed crash when calling rose_get_backptrs() on non-entity types.

• Simplified functions on RoseServer class and retired all functions that used the RoseHandle structure.

• ROSE.workspaceDesignNames() has been retired. To find the names, loop over the list of designs and test with RoseDesign::name(). Now the names may be null or duplicates.

• Retired unsupported RoseObject::satisfies() function and related variant of findObjects() that took a string.

Changes in ROSE Library 16.12 (2016-04-18)

• Fixed behavior when assigning a RoseStringObject to itself.

• Updated zlib to version 1.2.8, and minizip to 1.1 baseline

Changes in ROSE Library 16.11 (2015-12-31)

• Added rose_int_vector

Changes in ROSE Library 16.10 (2015-12-14)

• The scoring used to find the best fit class could fail to factor in the priority flag under some circumstances. This showed up as a bad match in some AP242 tolerance types.

Changes in ROSE Library 16.9 (2015-11-21)

• Annotating anchors with the type of their underlying object to help improve clarity in edition three files.

Changes in ROSE Library 16.8 (2015-10-26)

• Version bump for Windows testing.

Changes in ROSE Library 16.7 (2015-10-15)

• Missed DLL linkage for one of the rose_zip functions.

• No longer line wrapping within \X\ encoded hex escape sequences. Wrapping is legal, but some systems can not handle that. Mailers may still wrap the lines, so the weak systems will eventually need to up their game, but since there are only hex chars, no dots, there should not be any danger of mailer corruption.

• Added enable()/disable() to error context for simpler turning on/off of individual messages.

Changes in ROSE Library 16.6 (2015-10-07)

• Corrected DLL linkage for rose_zip functions.

• Reimplemented the RoseDictionary::emptyYourself() function.

Changes in ROSE Library 16.5 (2015-09-21)

• Reduced the size of applications by 5% and increased performance by making some functions non-virtual and removing ones that were never widely used or can be handled better in a different way. Retired isEqual, the getAttribute with void* (replaced by slotAttribute non-virtual), putData and getData, RoseDictionary::emptyYourself (which was a no-op), and internal find and data buffer functions. Moved capacity from the root to aggregates and made non virtual. Removed virtual from display(), RoseUnion::putAttribute(), remaining emptyYourself, and RoseDesign save functions.

• Integrated the rose_sprintf() functions that were previously in the reporter library.

• Added compiler pragmas for additional checking on printf-style format strings in rose_sprintf, error reporting, etc.

• Renamed the P21 external reference functions to use rose_ref as a prefix, which matches the RoseRef class prefix already in use. Temporary #defs are in place for the older symbols
  • rose_make_ref now rose_ref_make
  • rose_get_ref now rose_ref_get
  • rose_put_ref now rose_ref_put

• Added RoseReference::resolve_usage() to propogate an object value down to all of the fields that use the reference.

• Added the rose_ref_remove() function to disassociate a reference from a field, and the RoseReference::remove_usage() function to do all fields at once.

• Added a rose_put_nested_object() overload that takes an attribute and index, and can create nested selects for an entity or aggregate field.

• Added checking for some obscure cases, like complex instances with user defined types.

• Retired classes that were never used (RoseIterator/RoseSlot)

Changes in ROSE Library 16.4 (2015-08-18)

• Porting changes for Visual Studio 2015

• Revamped the best-fit matching from EXPRESS to C++ classes to now choose a complex instance combination for a subset of types if the full combination is not available. It finds a combination with a supertype if one with a subtype is not available. For plain EXPRESS types, it now finds the class that covers the most attributes or subtypes. This change makes the built-in complex classes much more useful. Previously, a super was used when a combo did not have an exact match. Now a complex class will be used if the combination is close. Most best-fitting came from adding an new extra type or subtype to a combo, which will now be handled as a useful nearest combo rather than a less-useful super.

Changes in ROSE Library 16.3 (2015-07-24)

• Added rose_p21_schema_name_cmp() function for comparing schema names without ASN1 identifiers.

Changes in ROSE Library 16.2 (2015-04-28)

• Added RoseTypesCursor class for traversing several disconnected types at once.

• Error reporting respects ROSE_LOG instead of always using 'roselog'.

• Fixed crashes when renumbering EIDs on an empty design and when writing a null XML attribute.

• Fixed crash when trying to detect the format of a Part 21 file that has an unterminated comment before the ISO-10303-21 token.

• Added check during P21 parsing to make sure that header section entries are described by an entity definition, rather than a select or something else.

Changes in ROSE Library 16.1 (2014-11-18)

• Added check during P21 parsing to make sure that the entity type called out in the file is actually an entity definition, rather than a select or something else.

• Forced the create of a default section in P21 writer, so that a schema is written into file header when using AP Contexts.

• Updated EID Table creation to process reference sections in addition to data sections.

• Fixed P21 default renumber functions to always number RoseReference objects. Previously, it only worked when preserve_eids was false.

• Updated P21 renumbering function to deal with duplicate EIDs.

• Fixed issues with rose_put_nested_object() and rose_create_select() that appeared with deeper nesting of select types.

Changes in ROSE Library 16.0 (2014-04-11)

• Added the ability to give a name prefix for all messages reported through a given RoseErrorContext. As part of this update, the exit and error reporting functions RoseErrorReportFn / RoseErrorFatalFn have both been extended to take a RoseErrorContext parameter. typedef void (*RoseErrorReportFn) ( RoseErrorReporter *, RoseErrorContext * NEW, const RoseError *, va_list ); typedef void (*RoseErrorFatalFn) ( RoseErrorReporter *, RoseErrorContext * NEW, const RoseError * );

• Added read/write support for gzip compression on Part 21 files. As with zip file reading, the gzip data is detected and handled without any need for special filenames or extensions. Use "step-gzip" as the format string to write gzip compressed files.

• Added the following functions on Windows only, to handle conversions from UTF-16 to UTF-8. These allocate a string on the heap, and the caller must delete[] when finished. The argv functions make a UTF-8 copy of the wide argv from wmain() for easier processing of command line options.
  • rose_new_wide_from_utf8()
  • rose_new_utf8_from_wide()
  • rose_new_utf8_argv_from_wide()
  • rose_delete_utf8_argv()

• Updated the P21e3 anchor and reference handling to use the bracketed syntax <> rather than the original quoted string '' syntax.

Changes in ROSE Library 15.7 (2014-01-30, beta6)

• Defining ROSE_DLL now turns on DLL linkage for all ST-Developer libs. The ROSE_CLSDLL define is automatic with ROSE_DLL, but you can use ROSE_BASEDLL and ROSE_CLSDLL separately for fine grained control if needed.

• Now properly exporting rose_zlib symbols in DLL builds.

• Moved RoseXMLWriter from the p28e2 library into roselib.

• Added the beginning of thread support. The ROSE library should still only be accessed by a single thread, but we now have the rose_thread.h header which provides some of the C11 thread.h API wrapped with "rose_" prefixes to avoid any symbol conflicts. This API is used within ST-Developer meshing library to provide multithreaded calculation, and has been moved down into the ROSE library so that other code can begin to leverage threads. It is based on the TinyCThread wrapper by Marcus Geelnard but has been heavily modified. In particular, the system specific types have been moved to rose_threadP.h to prevent unexpected system headers when including rose.h. UNIX applications will now need to link with "-lpthread -lrt", and MacOS will need "-lpthread". No additional libraries are needed on Windows.

Changes in ROSE Library 15.6 (2013-09-09, beta5)

• Added RoseP21Lex::string_cvt_fn hook to handle strings with values outside of the legal P21 alphabet, also preparing for P21e3 support for raw UTF8 within P21 strings.

• Updated ROSE_DECLARE_VECTOR get method to be const-correct.

• Added "p21-zip" file format alias.

• Moved rose_mkdir() function from stixlib into rose. Creates a directory using UTF-8 path.

Changes in ROSE Library 15.5 (2013-05-20, beta4)

• Fixed missing null attribute check when computing reference counts for RoseUnion objects. Fixed similar issue in backpointer code.

• Reworked the RoseObject marking API. You can now nest traversals or use several concurrent marks. For concurrent marking, you pass an optional RoseMark handle identify the mark. If not given, the functions use the most recently begun handle, so old code works as before. The old beginTraversal endTraversal, visit and wasVisited functions now just alias the functions. The only functional change is that is_marked should not be used after ending a traversal, unless you give an explicit handle. RoseMark rose_mark_begin()
  • RoseMark rose_mark_current()
  • void rose_mark_end (RoseMark = ROSE_MARK_CURRENT)
  • int rose_is_marked (RoseObject *, RoseMark v = ROSE_MARK_CURRENT);
  • void rose_mark_set (RoseObject *, RoseMark v = ROSE_MARK_CURRENT);
  • void rose_mark_clear (RoseObject *, RoseMark v = ROSE_MARK_CURRENT);

• To catch code that begins a traversal but never ends it, the mark functions warn past a certain number of open traversals. The point at which warning starts can be controlled by rose_mark_warning_at()

• Deleted RoseInterface::traversalMark() and RoseObject::mark_value() functions, no longer relevant with new marking API.

• Added rose_real_vector, rose_ulong_vector, and rose_uint_vector classes for internal use.

Changes in ROSE Library 15.4 (2013-04-15, beta3)

• MacOS native filesystems are not case sensitive.

• Streamlined and enhanced error reporting. You can now find the maximum severity of issues seen during file reads or other complex operations. You can also collect counts and then query specific errors or print summaries. Simpler cusomization of reporting too.

• If you want more information about errors, you can push an instance of the RoseErrorStats onto a stack in the error reporter. It will then keep counts, codes, and summary messages for all errors seen. Later, you can search for specific errors, or print summaries with counts. The following are the basics:
  • The following compute totals for one code or a range
  • RoseErrorStats::counts(RoseErrorCode);
  • RoseErrorStats::counts(RoseErrorCode ec_min, RoseErrorCode ec_max);
  • The following returns a stats struct for one error
  • RoseErrorStats::get_stats_by_index(unsigned idx);
  • RoseErrorStats::size();
  • RoseErrorReporter::push_stats()
  • RoseErrorReporter::pop_stats()
  • RoseErrorReporter::stats()

• Replaced RoseSeverity with RoseStatus. ROSE_SEV_NULL is now ROSE_OK. The ROSE_SEV_WARNING, ERROR, and FATAL, codes are now ROSE_STATUS_WARNING, etc. A new ROSE_STATUS_MINOR severity is available for style issues. ROSE_SEV_MESSAGE has been retired. Trace messages are not problems so use ROSE_OK as their severity. You can turn individual errors on or off using the following functions, which set a bit flag on the RoseError severity.
  • rose_error_disable()
  • rose_error_enable()

• The RoseError struct now has f_summary and f_errsym fields. These are at the end so arrays of statically initialized errors do not need to change. The f_message field has been renamed as f_detail.

• Changed RoseErrorCode return types to RoseStatus in functions that used it to indicate errors. The RoseErrorCode was not useful beyond checking a non-zero problem value, and did not give the severity of the problem. The ROSE_OK define has changed from a zero error code to a zero status, so only the function prototypes should change. The following hook functions will need to be updated.
  • RoseP21AddSchemaFn / RoseP21Parser::add_schema_fn RoseP21SetSchemasFn / RoseP21Parser::set_schema_fn
  • RoseP21ReadStatusFn / RoseP21Parser::status_fn
  • RoseP21RenumberFn / RoseP21Writer::renumber_fn
  • RoseP21WriteCommentFn / RoseP21Writer::comment_fn
  • RoseP21WriteStatusFn / RoseP21Writer::status_fn

• The error reporter now keeps the maximum error status (warning, error, etc) rather that the last error code seen. The code was not useful because they a chain of issues might overwrite them. It was also difficult to find the severity of an error. Code should now test the value of ROSE.error_reporter()-> status(). The following functions have been removed:
  • RoseInterface::errcode()
  • RoseInterface::errcontext()
  • RoseInterface::error_reset()
  • RoseErrorReporter::errcode()
  • RoseErrorReporter::errcontext()

• The error reporter now has the report_maxcount() field to specify a maximum number of times to report a message. This only works when collecting RoseErrorStats for summary reporting. The report_detail flag supresses all detail reporting, across all error contexts, for applications that only want to show collected summary information afterwards.
  • RoseErrorReporter::report_detail()
  • RoseErrorReporter::report_maxcount()

• RoseErrorReporter now has hook functions for custom reporting. The report_fn() handles display and the fatal_fn() handles behavior for fatal errors. The userfn_data() field can also hold closure data for use by the hook functions. This replaces the old approach where you had to subclass RoseErrorReporter and replace the instance in RoseInterface.
  • RoseErrorReporter::report_fn()
  • RoseErrorReporter::fatal_fn()
  • RoseErrorReporter::userfn_data()
  • RoseInterface::error_reporter() -- retired update fn only

• The RoseErrorReporter::error_file static variable has been replaced by access and update member functions with the same name. A static variable is not needed because applications will no longer subclass and replace the reporter.

• Eliminated RoseErrorNamedTrace. The base RoseErrorTrace class now keeps a local buffer for the location string. Use location() to set the value instead of name().

• Select handling tries harder to find a matching select element when primitive values are given without the required typename qualifiers. Now it warns about the missing qualifiers and falls back to the original 1994 IS search algorithm for values with no keywords that are not an id, null or omitted (which should leave the primitives) This helps with behavior seen from ProE where presentation styles are mistakenly written with an unqualified enum.

• Part 21 file reading now handles enumeration values with doubled trailing dots (typically from email attachment) The reader already handled missing dots or doubled ones at the start.

• Fixed garbled best-fit warning.

• Retired the NULL_INDEX and NOTFOUND preprocessor defines in favor of prefixed versions ROSE_NULL_INDEX and ROSE_NOTFOUND. You can define ROSE_ENABLE_COMPAT_DEFS on the compile command line for transitional use of the old definitions.

• Now avoiding extraneous "+" and leading zeros from exponents when writing floating point values in Part 21 files. The maximum digits of precision can also be adjusted if needed.

• Added RoseBinarySTR / Binary aliases for the various aggregates.

Changes in ROSE Library 15.3 (2013-03-11, beta2)

• Added read/write of zip-compressed Part 21 files. The file format is now detected from the contents of the file, rather than from the file extension. All reading now goes through the rose_read_design() and rose_write_design() functions declared in RoseIO.h and work with input and output stream classes.

• Added API for P21e3 external references. The RoseReference and RoseRefUsage types and the following functions are defined in RoseReference.h. RoseDesign has a new reference_section(), similar to the header_section() and system_section(), that holds reference objects. Anchors are written kept in the RoseDesign::nameTable() so you can use the existing addName() and findName() functions.
  • rose_put_ref()
  • rose_get_ref()
  • rose_make_ref()

• You can now specify upper and lower bounds on the Part 21 editions used when writing. For compatibility, we use the oldest spec that supports features needed for the data. The use_spec_version() function sets max/min to the same value. By default, the min is PART21_TC and the max is PART21_ED2 (for multiple data sections).
  • RoseP21Writer::max_spec_version();
  • RoseP21Writer::min_spec_version(); Call "RoseP21Writer::max_spec_version(PART21_ED3);" before writing to enable writes with the new anchor and reference sections.

• Added read_atts_fn and write_atts_fn hooks to RoseDomain for customizing the attributes used when reading and writing a type. These can return custom lists of attributes to skip or reorder fields. Also renamed RoseDomain::name_hook() to write_name_fn().
  • RoseP21EntityNameFn RoseDomain::f_write_name_fn;
  • RoseP21EntityAttsFn RoseDomain::f_write_atts_fn;
  • RoseP21EntityAttsFn RoseDomain::f_read_atts_fn;

• Error recovery for Part 21 files no longer tries to match string quotes when trying to skip past bad data to the start of the next entity instance. This should prevent a missing or badly escaped quote from hiding a large part of the following data.

• The RoseOutputStream class joins RoseInputStream for use in I/O code. The flush() virtual function is implemented by subclasses. The RoseOutputFile subclass uses a FILE* structure. Moved the zlib code from p28lib into roselib for handling ZIP I/O and added the RoseInputZipMember and RoseOutputZipMember streams. Moved the expat stack from p21lib into roselib for general XML read/write.

• Added RoseIO.h with the following functions, for filetype detection and format handling. These are for internal use. Applications can continue to use findDesign(), format(), and save(). In addition to the following functions there are new hook functions for step, zip, xml and rose detection, read, and writing.
  • rose_io_extfmts_table();
  • rose_io_extsearch_table();
  • rose_io_findfmt()
  • rose_io_fmt_table();
  • rose_io_init();
  • rose_io_regexts()
  • rose_io_regfmt()
  • rose_io_shutdown();
  • rose_io_testfmt_add()
  • rose_io_testfmt_fns()
  • rose_io_testfmt_remove()
  • rose_get_preferred_ext()
  • rose_read_design()
  • rose_write_changed_schemas()
  • rose_write_design()

• Updated RoseP21Writer and RoseP21Parser to use the new stream reading and writing interface. The following have changed:
  • RoseP21Writer::write_design() changed FILE* to RoseInputStream* RoseP21Writer::file() removed
  • RoseP21Writer::stream() added, returns RoseOutputStream*
  • RoseP21WriteCommentFn changed FILE* to RoseInputStream*

• Eliminated several internal classes and related functions as part of a general simplification of the read/write interface. The following have been removed and are now handled by functions in RoseIO.h:
  • class IODotRose
  • class IOSTEP
  • class RoseRepositories
  • IORoot::registerAsExtensionHandler()
  • IORoot::registerAsReader()
  • IORoot::registerAsWriter()
  • RoseDesign::isFileLocked()
  • RoseDesign::isMemoryLocked()
  • RoseDesign::lockFile()
  • RoseDesign::lockMemory()
  • RoseDesign::unlockFile()
  • RoseDesign::unlockMemory()
  • RoseInterface::findRepository()
  • RoseInterface::known_repositories()
  • RoseInterface::known_repositories_dictionary()
  • RoseInterface::repository()
  • RoseInterface::repositoryName()
  • RoseServer::dfltReader()
  • RoseServer::dfltWriter()
  • RoseServer::findReader()
  • RoseServer::findWriter()
  • RoseServer::registerReader()
  • RoseServer::registerWriter()
  • rose_read_part21_file()
  • rose_write_part21_file()

• Retired rose_complex_domain_name_compare(), which was just a duplicate of rose_domain_name_cmp(). The latter is now also tolerant to nulls in the domain list.

• Added RoseKeyLookup.h header with small key/value lookup classes intended for internal use.

Changes in ROSE Library 15.2 (2012-11-18, beta1)

• Corrected hash function that might return different values for a string with high-bit characters in different locales. This caused occasional crashes on shutdown when international filenames were in use and a system was changing the locale.

Changes in ROSE Library 15.1 (2012-09-07)

• This release contains header and packaging changes only, so it should be ABI link compatible with 15.0.

• Added a VERSIONINFO resource to the DLL builds of the library.

• Retired the conflicting Set(), List(), Bag(), and Array() macros in roseHdefs.h. You should now just use the expanded name directly. Token pasting macros are still there but prefixed as ROSE_SET_OF(t), ROSE_LIST_OF(t), ROSE_BAG_OF(t), and ROSE_ARRAY_OF(t). You can also compile with -D ROSE_ENABLE_COMPAT_DEFS to bring back the retired defs for transitional use with old code.

Changes in ROSE Library 15.0 (2012-04-09)

• Improved memory usage by optimizing the creation of aggregates in the Part 21 reader and moving the RoseOID and traversal marking data out of the RoseObject class into managers. Also reordered fields in RoseObject and RoseAggregate to improve alignment on 64bit machines.

• Improved Part21 reading to handle numbers with doubled dots from email corruption (eg 1..234) and numbers missing dots before the exponent (eg 1E5 instead of 1.E5). Also updated the entity id lexing with better checking for out of range ids.

• Added the RoseConstCursor subtype of RoseCursor, for use with constant data (no pnew, delete, or moves). This is safe to use in multiple threads. The default RoseCursor is not thread safe because it makes certain assumtions to deal with add and deletion.

• Added rose prefixes to the following functions to avoid potential namespace clashes. These are used internally and by macros, so the change should not affect any application code.
  • access_object -> rose_access_object
  • update_object -> (retired)
  • update_prim -> rose_update_prim

• Added RoseP21Parser::set_schemas_fn function hook for custom schema handling and deprecated the RoseP21Parser::add_schema_fn hook. The new hook is called once with the list of all schema names, so your code can check for an empty list or certaing combinations of names when assigning schemas. The original hook was called one by one on each name, and was never called if the list was empty.

Changes in ROSE Library 14.7 (2012-02-02)

• Added full support for reading ISO 8859 international characters encoded in Part 21 file strings using the \S\ shift escape. The values are now converted from their given code page representation to UTF-8 UCS values.

• Renamed RoseInputStream getc/ungetc to get/unget to avoid macro conflicts on VC6, and possibly others.

Changes in ROSE Library 14.6 (2011-12-09)

• Improved the RoseTypeTable so that we can now find classes based on a schema qualified name ("schema.type") then changed the code that matches EXPRESS definitions to C++ classes so that it looks for a class using the qualified name first. This prevents conflicts with definitions having the same name in separate EXPRESS schemas, say a POINT in FOO_SCHEMA and one in BAR_SCHEMA. If the C++ class names are different (FooPoint and BarPoint), the code will compile. At runtime, the library now matches the EXPRESS (RoseDomain) to separate classes, in this case FOO_SCHEMA.POINT domain to FooPoint class and BAR_SCHEMA.POINT to the BarPoint class. Previously, both domains were matched to the first class seen with that name, so one was always wrong. In particular, this caused an issue when linking the IGES and StpCAD libraries, because both had datum and variable definitions.

Changes in ROSE Library 14.5 (2011-11-09)

• UTF-8 support for international characters in STEP data. Strings are now assumed to be UTF-8 encoded, and the Part 21 file handling will encode and decode any wide characters properly.

• All file functions now expect UTF-8 paths and work properly on Windows when given UTF-8 strings for wide char filenames.

• Retired the stepi18n.h header and all functions related to the previous technique for handling wide characters that used Part 21 escapes in runtime strings as a kind of pseudo UTF-8 encoding.
  • rose_contains_encoded_wchar()
  • rose_cvt_p21_to_wchar()
  • rose_cvt_wchar_to_p21()
  • rose_enable_wchar()
  • rose_get_wchar()

• Deprecated the RoseStringObject rw_str() and ro_str() functions in favor of new as_char() and as_const() functions.

• Added rose prefixes to the following to avoid potential namespace clashes. Also updated to watch for signed vs unsigned char issues. strcmp_as_lowercase -> rose_strcmp_as_lower strcmp_as_uppercase -> rose_strcmp_as_upper strcmp_insensitive -> rose_strcasecmp strncmp_insensitive -> rose_strncasecmp hash_insensitive -> rose_hash_insensitive
  • strcenter -> rose_strcenter
  • strtoupper -> rose_strtoupper
  • strtolower -> rose_strtolower

• Fixed problem introduced with the 14.1 changes that showed up when booting certain keystone extension types.

• Removed spurious "No match for" warning when activating aggregate RoseTypes.

• Added RoseInputString stream subtype for parsing and lexing from static string data.

Changes in ROSE Library 14.4 (2011-10-02)

• Changed the built-in version messages to include minor revision numbers.

• Added shared library versions of the rose library to MacOSX and Linux platforms.

• Added simplified functions to read/write from FILE* for handling user-opened files. Can be used as a workaround for wide character filename fopen/wfopen issues on windows.
  • rose_read_part21_file (FILE *)
  • rose_write_part21_file (FILE *, RoseDesign *)

• Changed rose_vector::size(), capacity(), and get() methods to const to allow const rose_vector * usage.

• The library should now read and write Part 21 files correctly even if the application programmer has called setlocale() to change the behavior of number formats (123.4 -> 123,4) and such. Previously, you had to be sure to switch back to the "C" locale before reading or writing.

Changes in ROSE Library 14.3 (2011-09-20)

• Reorganized Part 21 file code for significantly faster read times. This rework also adds the internal support for block reads from other data sources, like network connections or compressed files.

• Added RoseInputStream class as for use by the RoseP21Parser and RoseP21Lex classes, as well as other code that needs general stream reading capabilities. The refill() virtual function is implemented by subclasses. The RoseInputFile subclass implements a stream based on a FILE* structure. The following member functions have changed: RoseP21Parser::readDesign() changed FILE* to RoseInputStream* RoseP21Lex::process() changed FILE* to RoseInputStream* RoseP21Lex::file() removed RoseP21Lex::stream() added, returns RoseInputStream*

• Custom P21 comment functions assigned to RoseP21Lex::comment_fn must be rewritten to use the new stream class. Use the getc()/ungetc() functions on the stream() object associated with the lexer to read and push back characters.

Changes in ROSE Library 14.2 (2011-07-15)

• Added RoseP21Writer::fill_column variable for changing or disabling the line wrapping in Part 21 files. Note that disabling wrapping is a bad idea because it makes the files more vulnerable to corruption when emailed.

• Changed like wrapping to break at the fill column, not column+1.

Changes in ROSE Library 14.1 (2011-04-18)

• Changed the domain activation process to make sure that domains are only matched to classes that share the same I/O type (RoseNodeType) Now forcing best-fit classes for basic mismatch (entity/select, or entity/enum) as well as aggregates of mismatched types. Also added messages to the P21 reader and writer to warn about unsupported or mismatched nodetypes.

Changes in ROSE Library 14

• Updated P21 writer to wrap lines when writing an enum or a select keyword tag that would extend beyond the normal wrapping point.

Changes in ROSE Library 12.3

• Removed macro definitions for "declare_begin" and "declare_end". Any old code that used that should now use ROSE_DECLARE_AGG_BEGIN and ROSE_DECLARE_AGG_END.

• Added support for DLL versions of the rose library. The import library is named rosedll.lib (or rosedlld.lib for debug use) and the DLL name includes the cpu and c runtime version (rose_i86_vc9, rose_i86_vc9d, rose_x64_vc9, etc). To use the DLL version you must define the "ROSE_DLL" symbol. The symbol "ROSE_CLSDLL" is used for DLLs built for EXPRESS classes (ap214dll.lib, ap214_i86_vc9.dll, etc)

• The redeclared-as-derived information was not being propogated to ANDOR domains created at runtime, which led to incorrect encoding in Part 21 files for things like si_unit+length_unit, if such things were not pregenerated in ST-Runtime.

• Fixed missing virtual destructor in RoseErrorTrace, requires recompile against new version because the signature changes.

• Improved Part 21 file acceptance of incorrectly encoded data. Updated parsing of primitive types to ignore wrapping with extraneous typed parameter information, better "recover to next field" behavior when given unrecognizable data.

• Reordered and expanded the IO error codes in rose_error.h

• Fixed error recovery issue in Part 21 file reader that was causing an infinite loop when given certain configuration of bad data.

• Improved the handling of Part 21 escape sequences so unrecognized escapes are now saved rather than discarded. This gives closer to the intended result when reading common errors like single unescaped backslashes within a string.

Changes in ROSE Library 12.2 (2009-07-22)

• The RoseDesign::save() function was not setting ROSE.errcode() if the file was write protected or there were other errors during the save process.

Changes in ROSE Library 12.1 (2008-10-03)

• The RoseObject::putBinary() function was not storing a copy of the binary string. This was not detected earlier because our tests used static strings and the P21 filer used its own mechanism to set the values.

• Updated rose_get_nested_object() to use the filter parameter if given. Was previously ignoring it.

Changes in ST-Developer 12 (2007-09-14)

• Added the following convenience functions to RoseAggreate to simplify type testing. There were already some, but these complete the range of possible types.
  • isAggregate()
  • isEntity()
  • isEnumeration()
  • isSelect()
  • isSimple()

• Added the rose_get/put_preserve_file_header flag to simplify test comparisons.

• Added (made public) the rose_is_system_schema() function.

• Added (made public) the RoseEidCursor class and reworked the methods to better match the RoseCursor usage;

• Added the "p21" as a recognized format name for part21.

• Fixed a crash in the rose_p21_dflt_renumber when renumbering empty designs.

• Changed the STR typedef to RoseSTR to avoid potential conflicts between packages. The old definitions can still be used, but can also be turned off.

• Changing internal representation of the BINARY type so that it is now stored as a string. Binary is not used by the STEP schemas, but it simplifies the internals and allows us to implement aggregates of binary, which are now used by the IFC 2x3 schema. The ROSETYPE of the new binary value is RoseBinarySTR, and there is an object class to handle bit and byte level access to the data, RoseBinaryObject.

• Eliminated the late bound get/put functions for unused primitive types. These were from the "persistent C++" days and are never used within the context of STEP and EXPRESS schemas.
  • get/putByte()
  • get/putChar()
  • get/putLong()
  • get/putShort()
  • get/putUint()
  • get/putUlong()
  • get/putUshort()

• Added get/put schema property functions to let us set some string properties on a design. This creates a dictionary of strings and stores it in the nametable, which is only kept for schemas. Setting a null value will remove the keyword.
  • rose_get_schema_property()
  • rose_put_schema_property()

Changes in ST-Developer 11 (2003-06-01)

• Changelog not used.

Changes in ST-Developer 10 (2003-06-01)

• Changelog not used after Oct 2001.

• Fixed bug with cursor that caused the first object to be duplicated when a cursor was reused on a second design after the last object of the previous traversal was deleted/moved.

Changes in ST-Developer 9 (2001-09-18)

• Updated the P21 test cases so that they check more things when the verify script is run. There were a number of tests that were not being run automatically and now they are.

• Updated the header section schema to include the new types added by P21 edition 2. Also updated the writer code to make sure these get put into the proper place in the header. Also updated the parser so that we can handle entities with names that conflict with P21 special names like "header" or "data".

• Reworked RoseType and added cleanup functions. You can now clean up memory at the end of your application, so you could cleanly unload a dll if you want. I also changed RoseType and replaced the RoseTypeTable, so we now use less memory. RoseInterface has two new methods for cleaning up: ROSE.shutdown(); Clears out all of the persistent data in memory and restores rose to a pre-boot condition. You can start over and read things back in if you want to though. ROSE.shutdown_everything(); /* permanent */ Clears out all of the persistent data in memory as well as the runtime C++ type information. Once this is done, there is no way to restart and you should not make any more calls to rose. Removed the following functions on RoseInterface /* legacy error functions, do not use */ RoseErrorReporter * signal () { return error_reporter(); } void signal (RoseErrorReporter * eo) { error_reporter (eo); } RoseBoolean error() { return (error_reporter()-> errcode() != 0); } void errorClear() { error_reporter()-> reset(); } void findCompiledSchemas(); List(String) * systemSchemaNames(); List(RoseDesign) * userSchemas(); Also removed the ObjectStore conditional code. This should free us to make more significant changes to the class layouts.

• The P21 filer now ignores long ISO identifiers in the schema name. Given AUTOMOTIVE_DESIGN { 1 2 10303 214 0 1 1 1} the library will look for automotive_design.rose Also, the RoseDesign::useSchema() and RoseDesign::addSchema() fns now know about the P21 conventions, so you can specify uppercase or the iso versions and it won't break. I've had some customer requests for that.

• Corrected the attribute type checking in the P21 filer. It used to do type checks for object references based on class rather than domain. When you used it in a late bound program, it wouldnt pick up some errors.

• Removed $env expansion from PC file handling. $ is a valid character and required for W2K branding.

• Changed the P21 filer to do CC2 correctly. Root entities are actually supposed to be internal mapping.

Changes in earlier ST-Developer releases

• Not tracked by changelog.