gmslAPI
0.1
gmslAPI: An API for Developing Upgrade Solutions using Great Migrations Technology
|
▼NgmslAPI | |
CgmStudioTask | |
CScriptRules | |
▼NgmslLibrary | |
▶NEnums | |
CDefines | |
CObjectType | |
▶NModel | |
CProject | |
CSelect | The Select class contains a large number of properties which control the behavior of the translation process at every phase. The properties within this class are designed to mimic the attributes of the gmPL Select statement. |
CtCoclass | A coclass is a union of a group of classes and/or interfaces defined in an interface description class. |
CtCodeBlock | The tCodeBlock class controls the content of blocks of code retrieved from a VBI file. |
CtEnumEntry | The tEnumEntry class in used for entries within enumerations defined in the source code. They are used to contain values and value types of those entries. They are children of the tVbComp class. |
CtInfoFile | Within the class structure of the tool, language source files are associated with the tInfoFile class. This class contains not only but the source file that was compiled but also the translation file that was produced. The entities that are represented via the tInfoFile class are: project files, form files of various types, class files, module files, asp files, and include files. |
CtInterface | The tInterface class is used for class interfaces defined via the "Class" statement in interface description files which are typically derived from the "Interface" declarations in the raw "idf" files. These interfaces are the children of "tLibrary" components. A primary barrier to the migration of applications that use these external components is the implementation of these components on the target platform. This class is a child of the tMigInfo class and is the parent of the value bearing "tLibComp" external components. |
CtLibComp | The tLibComp class is used for value bearing components defined within interface description files via the "Enumeration", "Entry", "Method", "Argument", "Property", "Field", "Accessor", "Event", "Constant", or "Structure" statements. These components can exist at various levels within the description file and are the primary focus of migrations. This class is a child of the tMigInfo class. |
CtLibrary | The tLibrary class is used for libraries defined via the interface description files. The term "library" refers to an external component like a "dll", or an "ocx", or an "olb", or a "tlb" whose components are referenced by a source code but not defined within the source code. A primary barrier to the migration of applications that use these external components is the implementation of these components on the target platform. This class is a child of the tMigInfo class and is the parent of the main components defined within the interface description. |
CtMigInfo | The tMigInfo class is the initial parent class of those component classes that can be migrated. |
CtOpcInfo | |
CtPostSet | The tPostSet class controls the information needed for searchs. It is a small scratch storage area whose content should not be used by the caller. Note that as many simultaneous searchs as desired may be conducted so long as each search has its own unique iPostSet allocated. |
CtQuantity | The tQuantity class controls the content of component description blocks that contain values as defined in the user code. It is a child of the tVbComp class. |
CtReference | The class tReference records individual component references in the source code. |
CtStateLabel | The tStateLabel class controls the content of statement label description blocks that where produced by the VB6 compiler. |
CtVariable | The tVariable class in used for fields, variables, and parameters defined in the source code. They are used to contain values and therefore are children of the the tQuantity class. |
CtVbComp | The tVbComp class controls the content of component description blocks that where produced by the VB6 compiler. It is a child of the tMigInfo class and is the parent of the classes that represent the various VB6 components. |
CtVbConst | The tVbConst class controls the content of constant description blocks retrieved from a VBI file.They are used to contain values and therefore are children of the the tQuantity class. |
CtVbControl | The tVbControl class controls the content of user defined control description blocks retrieved from a VBI file which specify the content of controls within the various types of VB6 form files, designer files, document files, and user control files. They do not have values and therefore are children of the tMigInfo class. |
CtVbDeclare | The tVbDeclare class controls the content of components produced by the compiler to represent the VB6 Declare statement. They have values and therefore are children of the tQuantity class. |
CtVbEvent | The tVbEvent class in used for events defined in the VB6 source code. They are children of the tVbComp class. |
CtVbName | The tVbName class represents components produced by the compiler to link class files to class names. They are children of the tMigInfo class. |
CtVbSub | The tVbSub class controls the content of subprogram description blocks retrieved from a VBI file which specify the content of subprograms, functions, and event handlers defined in the user code. They have values and therefore are children of the the tQuantity class. |
CtVbTypedef | The tVbTypedef class controls the content of typedef description blocks that where produced by TYPEDEF declarations in external library files. |
▶NOpcodes | |
CACC | |
CADD | |
CALH | |
CALI | |
CALM | |
CANA | |
CAND | |
CAPP | |
CARG | |
CARR | |
CASM | |
CASP | |
CATT | |
CBAS | |
CBKS | |
CBOS | |
CBSY | |
CCAL | |
CCAT | |
CCBO | |
CCBS | |
CCBX | |
CCFX | |
CCHS | |
CCHV | |
CCLC | |
CCLF | |
CCLM | |
CCLP | |
CCLR | |
CCLS | |
CCMB | |
CCMD | |
CCMP | |
CCMT | The CMT class defines a set of operation codes that comment out preceding statement code. |
CCNV | |
CCOL | |
CCTY | |
CCUE | |
CCUF | |
CCUP | |
CDAB | |
CDAT | |
CDEC | |
CDEF | |
CDIV | |
CDMO | |
CDRB | |
CDSY | |
CDUE | |
CEQL | |
CERR | |
CEXI | |
CEXP | |
CFDT | |
CFDW | |
CFDY | |
CFNT | |
CFOR | |
CFRA | |
CFRM | |
CFSY | |
CGTE | |
CGTR | |
CHBR | |
CIDE | |
CIDV | |
CIFS | |
CIMA | |
CIME | |
CINV | |
CINX | |
CIOF | |
CIOR | |
CISA | |
CKEY | |
CLAB | |
CLAR | |
CLBC | |
CLBS | |
CLEV | |
CLFI | |
CLIK | |
CLIN | |
CLOK | |
CLSB | |
CLTE | |
CLTH | |
CLVT | |
CMBT | |
CMBU | |
CMDI | |
CMEM | |
CMEN | |
CMOD | |
CMPO | |
CMRE | |
CMUL | |
CNEG | |
CNEQ | |
CNOT | |
COBU | |
COLE | |
COMO | |
COPC | |
COPO | |
COPT | |
COST | |
CPAL | |
CPBS | |
CPBX | |
CPPA | |
CPRN | |
CPTY | |
CRLD | |
CRTY | |
CSBC | |
CSCA | |
CSCM | |
CSCR | |
CSCV | |
CSFT | |
CSHA | |
CSHC | |
CSPV | |
CSTR | |
CSTY | |
CSUB | |
CSUP | |
CTAB | |
CTIM | |
CTMP | |
CTNL | |
CTRI | |
CTXB | |
CTYP | |
CUDC | |
CUNQ | |
CUSC | |
CUSR | |
CVBC | |
CVBF | |
CVBR | |
CVCX | |
CVTY | |
CWPO | |
CWSA | |
CWST | |
CXOR | |
▶NServices | |
CAnalyser | The Analyser class contains utilities used to allow the introduction of external library component transformations into the analyser phase of a translation. |
CAuditVbi | The AuditVbi class writes component audit reports to the currently selected output file in the syntax style specified for that file. It is used extensively by the "gmMetrics" program but may also be used for debugging purposes by any translation program. |
CCharacter | The class Character processes character strings in various ways. Externally all character strings are of the standard string type. In most cases the standard .NET string methods should be used. The methods here are supplied only when exact gmSL compatibility is needed. Within the tool's storage system, all character strings are sequences of 8-bit unsigned bytes – i.e. with values in the range 0-255. Though not required all current implementations of this class use ASCII, UTF-8, or Shift_J variable length encoding. |
CCodeGroup | The CodeGroup class contains utilities used in the migration of grouped related sections of compiled code that are associated with a reference to a target component such as a method, property, or event. |
CCodePattern | The CodePattern class processes decriptions of operation sequences stored within compiled tCodeBlock code sequences. It contains methods to process a notation for doing code sequence content tests. |
CControlData | The class ControlData accesses information about controls which was compiled from the property bag specifications in the various form files. |
CDataTable | The class DataTable uses the Write class to produce structured tabular reports using the content of the runtime data queue. The reports themselves can be produced in one of three outputStyles: simple tab delimited, text tabular, or html tabular. |
CExecute | The class Execute executes the mainline translation operations performed by the tool. The individual methods correspond exactly with the gmPL commands of the same name, have string parameters whose names match the attribute names of the corresponding gmPL command, and literally execute the same implementation code in the tool. In addition to the matching parameters the ability of gmPL commands to process embedded refactoring and fix commands is also implemented in this class via the use of the text buffers. |
CFileSystem | The class FileSystem interacts with the operating system to form, decompose, and determine file names and attributes so that they conform the requirements of the hosting platform. In addition, it performs several low level file management operations such as searching for files, loading text files into internal text streams, and generating GUIDs. A full file name is viewed as consisting of three components. The pathname contains the location within the file system of the file. If it is omitted the the currently selected location is assumed. The localname contains the actual name of the file. This is the only component that cannot be ommitted. The extension contains a short extension that describes the type of the file. If it is omitted then the context is often used to determine its value. Note that in the scripting language itself the class is called "System". |
CgmBasic | The gmBasic class is the primary interface to the gmBasic tool. It contains the utilities that the start up and terminate interactions with the tool. In addition it contains the low level utilities needed to mediate between the C# level and the C level. |
COpcode | The class Opcode works with the intermediate language streams. Its methods actively manage and reference the opcodes of the intermediate language. Their description and use assume a knowledge of that language and of its internal structure as applied by the toolset. |
CParser | The class Parser analyses character strings in a known computer language, according to the rules of of that language. At the present time there are two language types processed by this class, "Basic" and the set of contemporary OOP languages referred to here simply as "Java". |
CPostingPair | The PostingPair class manages a small integer SortPair used for looking up links and relationships betweeen components in storage based on their defining root offsets. The information structure associated with posting pairs itself is allocated locally on the stack and is never left open; therefore, posting pairs do not have handles and are controlled entirely via their root offsets. |
CReferences | The References class provides utility methods to produce, scan, and audit sorted lists of tReference records sorted by the offset of the symbol being referenced. These reference lists are produced automatically by the compiler to aid in the analysis process. In addition, more extensive reference lists can be produced via this class. |
CRegistry | |
CRuntime | The Runtime class contains various middle level services implemented within the main translation tool. |
CSequence | The Sequence class offers simple read-only access to sequences stored in long memory. A "sequence" is an open ended list of entries. In this case the entries themselves all consist of a single integer value. Entries in the sequence are numbered starting at one. |
CStore | The Store Class contains the methods needed to manage data organized into hierarchical fields and records. When dealing with language processing, program storage must be viewed as containing a wide variety of different structures; indexes, lists, fixed records, long unformatted records, variable length strings, and so on. In addition, it may be purely memory bound or it may be stored in a persistent file system. The role of this service class is to provide a single interface for storing and retrieving information. It is sufficiently robust to allow for the management of large files in the multiple gigabyte size range, while it is still efficient for use by purely memory bound applications. |
CSymbol | The class Symbol works with the symbols as stored in the various active storage areas. |
CText | The class Text contains those methods needed to manage ordered sequences of text records, numbered from 1 to n. The typical retrieval pattern for text sequences is that they are first positioned to a certain record in the sequence and then a series of records is accessed from there. The algorithm used is optimal for moving forward through a sequence records once a starting location has been established. As such, the general approach differs from those for "normal" sequences in that the notion of a "current record" or "cursor" is used. The sequence is positioned on a record and that current record can then be manipulated. In addition to optimizing the traversal through the records, the approach also optimizes the storage and changing of records. The individual records are stored in fixed sized blocks in long memory. When a record in inserted into the stream or when the size of a record is changed only the block containing the record needs to be repositioned, not the entire stream. Finally, each text record in the stream consists of two parts: a fixed length component called the "record associated information" followed by the remaining text part, simply called the "record". |
CWrite | The Write class contains the basic methods needed to write structured reports and text files of various sorts using binary information. It is used very extensively by the tool during every phase of its operation and is fully exposed via gmSL. Ultimately, at any given point in time, only one coded output report can be written at one time. |