Flexsys - Development Systems
Flexsys - Development Systems 
Update/Extend
License
Download/Install
Flexsys Overview: Flexsys provides an ideal complement to SoftBuilder by supporting legacy systems. Flexsys' components automate many reengineering and conversion solutions and Flexsys' meta-components facilitate the construction of custom tools. Such tools make it possible to cost-effectively automate a wide variety of general-purpose and application-specific solutions -- for example, by passing data (e.g., XML) or code (e.g., Java) between applications and extracting business logic in legacy applications.
In addition to a wide variety of code generation, reverse engineering and conversion components, Flexsys includes patented meta-components that automate the construction of new and customized reengineering and conversion components.
In effect, Flexsys is an unique software tool factory which greatly facilitates, even automates the construction of custom tools for automating a wide variety of reengineering, conversion and E-commerce solutions: Solutions ranging from finding and fixing mundane Y2K and Euro-conversion problems to integrating legacy applications over the Internet (e.g., via XML), extracting business rules and web enabling legacy applications.
Flexsys is the first system of its kind. It is designed for use by software service providers and others responsible for maintaining large software systems, whether they be local, on Intranets or on the Internet. The software can be written in any language that has a well defined grammar. In addition to empowering users, support is currently available for many dialects of C, C++, FORTRAN, COBOL, Pascal, Ada. Recent additions are Java and XML. These extensions are all fully interoperable and make it possible to automatically import arbitrary source code into Flexsys unique Abstract Syntax Tree (ASTs with semantic attributes) repository.
Once in ASTs, patent pending processes can be used to easily create patterns and high level design code to automatically detect and modify arbitrarily complex code structures. In addition, code can be viewed and easily modified manually in our patented AST-based Flexform environment. Documenting and maintaining source code as visual Flexforms has been shown to make code 25-50% easier to understand, document and/or modify.
Flexsys consists of an easily extensible set of interoperable components and meta-components. Many of these components are written in the C/C++ language for optimal speed. Others are written in Flexsys' High Level Design (library) and/or SLANG languages for ease of development and maintenance. HLD provides the full power of a language designed for use in manipulating arbitrary ASTs (which can be used to model essentially any structure, real world or otherwise). SLANG is a very fast functional language for processing textual statements in ASTs. Collectively, they combine ease of use with the power and efficiency necessary for automating essentially any reengineering and/or conversion tasks.
Whether written in C/C++ or HLD all Flexsys components are fully interoperable HLD components in their own right. Both high and low level Flexsys components can be freely assembled to achieve arbitrarily complex goals based solely on semantic requirements. Moreover, new components can easily be added to accomplish unforeseen tasks. In addition to the HLD and SLANG languages, this is greatly facilitated by Flexsys' meta-components. The are components that automate many of the task involved in supporting new languages or for creating custom converters to meet application specific needs.
Thumbnail descriptions of Flexsys' Repository, Languages and Meta-Components are given below. Descriptions of Flexsys existing and sample "off-the-shelf" components follow. Flexsys runs on PC's running Windows95/98/NT.
Flexform Repository: The Flexform repository consists of linked ASTs with semantic attributes that directly support real world semantics. This repository provides an ideal environment for representing arbitrary data structures, operations on those data structures and groupings of these data structures (e.g., libraries, objects, units, systems, sets of systems, etc.). It supports all programming languages as well as the dynamically extensible, semantics-based HLD language. All levels of the Flexform repository can easily be accessed from other tools via a simple semantically meaningful interface. The repository also can be accessed and manipulated directly via a visual environment which supports contextual viewing and editing at any and all levels of abstraction (U.S. Patent 5,262,761).
High Level Design (HLD) Language: The HLD language is a powerful, easy to use language that is ideally suited for manipulating the Flexform repository, at any level of abstraction, from individual characters to high level semantic relationships between Flexforms and elements thereof. The HLD language makes it possible to quickly create custom components for performing essentially any definable reengineering task. Not only can the HLD be used to gather information implicit in any Flexform repository, but it can be used to modify the repository automatically. Among other things, the HLD can be used to create mini-procedures, which work in conjunction with SLANG (see below), to convert from one language or operating system to another. Mini-procedures operate at the parser token, statement, before and after module, and before and after system levels. Mini-procedures and Semantic Postprocessors are used where it is necessary to manipulate information in a broad semantic context. Source is available for several language conversions.
SLANG Language: SLANG is a simple, highly efficient language for rapidly manipulating parser tokens. SLANG is used both in reverse engineering and for simple statement by statement conversion where speed is of importance. Easily customizable source is available for FORTRAN and COBOL to Pascal, C, C++ and Ada; Pascal to C, C++ and Ada; C to C++ and Ada.
Language Generator: The Language Generator (GenLang) meta-component is used to create, edit, compile and debug grammars for Flexform editing, code generation, reverse engineering (from source code to modular Flexforms) and for conversion (from Flexforms in one language or dialect into another). GenLang automatically generates needed support files for essentially any language. Source grammars, and supporting files, are available for most commonly used languages.
Reverse Engineer: Automatically reverse engineers source code into Flexform AST repository as fully structured pseudo-code. Ordinary text or source code also can be uploaded into Flexforms and moved into desired structures. The Reverse Engineer also imports information in the form of simply structured ASCII files from other tools. Reverse engineering is fully automatic with well over 99% of code for a wide variety of languages and dialects. Minor preprocessing may be required with some Fortran or COBOL. The FortPrep utility automatically closes DO loops consistently with CONTINUE statements. Optional FORTRAN restructurers perform more sophisticated preprocessing. New reverse engineers may be constructed as desired using Flexsys meta-components (see below).
Flexform Designer: The Flexform Designer automatically adjusts itself to the current source code language. The C Designer, for example, is used to create and modify the Flexforms in which nodes contain C pseudo-code. Anyone familiar with the C language will immediately be familiar with C pseudo-code (which simply omits redundant braces, semi-colons, etc.). Flexforms containing pseudo-code in other supported languages is equally easy to recognize. The user can choose from text and Windows-based visual representations. Text based editing is instantaneous (and often preferred by those familiar with traditional text editors). Windows based Flexforms (including simulated 3-D) provide more flexibility and will be preferred by others. The latter are fully event driven, among other things making it possible to simultaneously view and edit as many Flexforms as desired . As with the HLD repository, Flexsys' Flexform repository includes relationships between modules (e.g., structure charts) and compilation files (units), and the modules themselves -- at all abstraction levels. Based on patented display technology (U.S. Patent 5,262,761, 1993), Flexforms may be expanded directly in context, as well as in separate windows. High level system overviews and individual modules may be linked, viewed and edited in a highly interactive, uniform visual environment. Switching between high level overviews and individual modules is instantaneous. It is impossible to create Flexforms which are incorrect semantically. Language specific checking includes: (a) syntax, (b) consistency of process with respect to data (i.e., everything referenced in procedural Flexforms must be "declared" in data Flexforms), (c) redundancy of data with respect to process (declared data must be used in procedural Flexforms), (d) data consistency (data can be in only one data section), (e) automatic identification of global identifiers.
Pseudo-code Generator: Generates full source code from corresponding pseudo-code. C pseudo-code, for example, consists of C statements embedded in visual Flexforms without distracting "{",";" or other compiler tokens that get in the way of human understanding. Pseudo-code provides full flexibility of the basic language in an easy to understand visual environment -- without having to learn a new language. The Pseudo-code Generator also supports multiple versions and/or platforms in one set of Flexforms. Conditional compilation meta commands and/or environment-specific code are automatically generated via simple labels attached to Flexform structures.
Update System Repository: A major problem in using traditional software tools is that designs and code quickly get out of sync. Carefully constructed designs go for naught once programmers start changing the underlying code. In Flexsys, this problem is avoided because all system changes, including the lowest level code (not just system designs), are made directly in the Flexform repository. Update System Repository automatically updates system designs to reflect changes in individual module Flexforms. The addition of a subroutine parameter, for example, or a call on a new subroutine, will automatically be reflected in the associated system call hierarchy (structure chart) and unit (file) hierarchies.
Invert Hierarchy: Inverts any given hierarchy Flexform (e.g., produces a uses hierarchy from a call hierarchy).
Simulator: The Simulator is included when Flexsys is supplemented with an HLD Source license. This empowers licensees to modify, test and run HLD components to meet custom specifications. High level virtual as well as executable functions and procedures may be intermixed in developing HLD components. Indeed, HLD applications can be simulated dynamically at any specified level of abstraction. The Simulator can interpret arbitrary HLD programs which reference components in any given set of DLL libraries. The Semantic core library is statically linked with the Simulator, but could easily be made available as a separate DLL. All listed Flexsys DLL's also are available to the Simulator. Even the Simulator DLL is available to itself. Additional (e.g., graphics and multi-media) may be added as desired. The Simulator comes with a powerful and easy to use debugger, which enables the user to intermix executable and manual (to be simulated) operations at will. This makes it easy to develop and prove systems incrementally at any combination of top-down and/or bottom-up programming and design.
Report Generator: Formats reports and/or extracts selected information from Flexforms. Any logical combination of conditions may be used for extraction. (Conditions are designated by Flexform labels, such as ">PC_only>".) Listings of modules used by given identifiers and export ASCII files representing Flexform structures can also be generated.
Design Recapture: Includes Construct Call/Object List and Construct Call/Object Hierarchy. The former automatically constructs call lists and object/inheritance lists (Ada/C++). Call list Flexforms show which and how many times modules are called by each of the system modules. Object/inheritance list Flexforms show object/inheritance relationships. Construct Call/Object Hierarchy automatically constructs Flexform hierarchies from Call and Object List Flexforms. These Flexform hierarchies depict full call or object/inheritance relationships. Modules which have two or more parents are represented as clones.
QA Measure: Provides documentation, unit cohesion and dependence metrics as well as common module (e.g., cyclomatic, essential complexity) metrics for C, C++, Ada, Pascal, Fortran and COBOL, and object metrics for C++ and Ada.
Find Uses: Takes a list of identifiers in C, C++, Ada, Pascal, Fortran or COBOL as input and returns every use of each in all units of a system.
Make C Header/Make File Lists: Automatically constructs C header files, supporting the movement of C functions, global variables, typedefs and defines among compilation units. Make C File Lists automatically constructs Flexforms showing where global variables and functions used in any given unit are defined, also which functions use these identifiers.
The following sample components that can be enhanced as desired.
HLD Checker: Statically checks HLD applications for common mistakes prior to execution.
HLD to C Generator: Provides fully extensible prototype showing how high level designs might be converted automatically into language specific pseudo-code Flexforms.
Reorganize C System: "REORG" is designed to automatically remove cyclic calling relationships between different C compilation units, and to insure that units are organized hierarchically.
REORG provides a good start in this direction but will require further work before it can reliably be used in practice.
The following code restructurers are examples of third party components which offer a useful complement to Flexsys.
FORTRAN Restructurer: Flexsys includes an GUI interface to a third party restructurer which takes unstructured FORTRAN source code and generates four levels of structured FORTRAN.
COBOL Restructurer: Before translating COBOL code to a new language it is highly desirable to first make sure that the COBOL is structured. Toward this end, you may either use Flexsys to build one, or use a third party restructurer to convert the unstructured code before it is reverse engineered into Flexsys' AST repository.
