Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123]

▼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.