Index

1 Overview

1 Overview

1.1 Filename and Identifier Conventions
For readability, the coding standards used by Conroy & Conroy Company define identifier naming conventions of mixed case (init-capped) identifiers with underscores used to separate words within identifiers. All-uppercase identifiers are used for acronyms (such as CPU). This convention allows one to tell, at a glance, if the identifier is a Subroutine library identifier or one from Windows or other third-party code.

For abstract class definitions (pure virtual classes, in C++ parlance), the filename begins with an underscore. Including a reference to one of these files does not link in any significant code, although other abstract definitions may be pulled into the compilation.

Hungarian notation is not used. However, all type definitions begin with "T" to distinguish them from other identifiers. "P" is used to denote a pointer to an object.

1.1 Layers
The Subroutine Library is organized into layers. Each layer represents a group of related functionality. Dependancy rules require that routines only reference routines that are in the same, or a lower, layer. The lowest layer is layer 0, which has no dependencies (except upon inherent features of the language). Note that for languages other than Pascal the subroutine library only includes some of the routines and layers.

Layer 0 - Object model layer
This layer includes the base class definitions from which all classes of the Subroutine Library derive. It also includes some basic type and constant definitions, localization support, and collection classes, which are used by various units in this layer.
_ASCII: ASCII definitions
_BIOS: Constants for BIOS
_Colors: Defines TRGB and TWide_RGB color values
_COMInter: Abstract base COM classes
_Common: Abstract base class definitions
_DebugIn: Base debugging interface
_GenVal: Generic value (variant) class definition
_Octal: Constants for octal values
_RGB: RGB definitions
_TSRs: DOS internals structure definitions
Types: Simple type definitions
_UE: Unified exception
ASCIIDef: ASCII support functions
Collect: Collection classes
COMInter: Base COM classes
L10n: Text localization support
TypeDefs: Basic type definitions

Collect: Collection classes
Common: Base class definitions
_NameVal: Named values classes
_ObjectF: Subroutine object factory
_Propert: Dynamic property support
_Streams: Base stream interface
_TestInt: Abstract test interface

_COMLists: Abstract COM list class
COMLists: Defines a COM list class
CommBase: Common non-COM base classes that all other subroutine classes derive from.
Streams: Base stream classes to assist in creating stream descendants.
_TE_Interface: Abstract text editor class definition.

Layer 1 - Utility layer
This layer contains various utility classes and functions, such as logging mechanisms, data cache support, and numeric conversions.
_AEL: Application Event Logger class definition
ArrayInt: Interfaces to arrays
Behavior: Base Behavior class definitions
BehavMan: Behavior manager class
Button_2D: 2D GUI speed button class
_Cache: Cache handling class definitions
Cache: Cache control classes
_CacheMa: Cache manager class definition
CacheMan: Including this unit creates the cache manager on program startup
Commands: Command object classes
CommonUt: Common utility routines
Compress: Compression/decompression routines
CVT: Numeric conversion routines
DebugInt: Base classes from which to descend debug interfaces and support routines
DebugMa: Standard Debug Manager instance
Disk: Absolute disk read/write routines (MSDOS)
EBCDICs: EBCDIC support routines
English: English language support routines
Format: Various text formatting routines
Heaps: Memory heap class
Instrs: Instr and Rinstr functions
MStores: Managed store classes
NameVals: Standard named values implementation
Num1s: Number to string conversion routines
Operatio: Multi-part operation logger
_Deferred: Deferred execution class definition
_Events: Event class definitions
_FacMan: Facility manager class definition
_Fonts: Abstract font characteristic class definition
_Buffers: Generic buffer class definition
_Languag: Language support
_Lib: Abstract librarian class definitions
_Loggers: Defines a logging class
_ObjectM: Defines the object manager class
_Stores: Defines store classes
Radix50s: Radix-50 conversion and support routines
Randoms: Random number generator
RGB: RGB to angstrom conversion
RPG_Character: Abstract classes related to Role-Playing Games
Soundx: Provides the Soundex function
SpellChk: Spell checker
SStreams: String stream classes
Symbols: Symbol table classes
_TPM: Text Presentation Manager class definitions
UE: Standard Unified Exception classes
_Validate: Validator class definition

_Applic: Application class definition
Compatib: Provides consistent types and functions across different Pascal platforms
Decorations: Class for non-Windows-handle objects that can draw themselves on other controls
Deferred: Standard deferred manager
_DevMan: O/S Device Manager class definitions.
DPropert: Dynamic Properties class
ExtentSt: Extent store class
_Chars: Abstract character class definition
_Files: File class definitions.
_FiP: File system interface
FStreams: Stream class for PFiles.
_OS: Operating system interface
TSRS: MSDOS Terminate and Stay Resident function
Devman: COM wrappers for static Device Manager instances
_FileSys: File system class definition
FSError: File system error codes
Language: Language-related numeric conversion routines
Maths: Arithmetic routines
Stores: Base classes from which to descend stores.
Weather: Wind-chill factor routine
XLate: Wildcard support functions

RAMDisk: An in-memory buffer accessed as a 64-bit store
VCL_Std: Various routines supporting VCL/LCL controls

Layer 2 - Application framework layer
This layer contains classes that support the Subroutine Library Application Framework. This framework provides a consistent, advanced framework for all types of applications. It includes such things as unit/application testing, debugging support, and event logging.
_APM: Application Performance monitoring
_CompInt: Abstract compiler interface class definition
_DebugMa: Debug manager class definition
_TestMa: Test manager class definition
Test: Routines to aid in testing

AEL: Default Application Event Logger class
APM: Default Application Performance Monitor class
TestMan: Test manager implementation
_UOS_File_System: Abstract UOS file system class definition

Layer 3 - Platform abstraction layer
This layer contains classes that provide an abstraction to the underlying hardware/software platform, including interfaces to the Operating System and File System.
OS_DOS: TOperating_System descendant for the MSDOS operating system. Accessed via O_S unit.
OS_Windows: TOperating_System descendant for the MS Windows operating system. Accessed via O_S unit.
OSWinDeb: Debugger for Windows operating system class

Allocatr: Allocation table classes
Allocatr64: 64-bit Allocation table classes
Allocation_Cluster_Manager: Allocation Cluster Manager
Applic: Standard Application Manager instance
Database: Database class definitions
Dates: Date and time functions
Filestd: File access functions and classes
FileSys: File System server class
FiP: File Processor class. Allows for abstraction of files and file systems.
FSFH: File System and File Heap classes
GetChars: Keyboard input classes
GIO: General I/O functions, such as Log_Error
Intlist64: 64-bit integer list
MSWin: Support for Microsoft Windows programming
O_S: Operating system class instance
Parse: Parsing functions
SMUBIOS: I/O drivers for SMU.
Standard: Misl. common-use functions and classes
UStrings: String utility routines
Wildcard: Filename wildcard routines
WinAPI: Wrapper for Windows
WinEvents: Windows event classes

Layer 4 - Application layer
This layer contains various classes and routines that are built upon the previous layers.
B_Dialog_Button_Nav: Button navigate behavior
B_Dialog_Default_Key: Button default behavior
B_Horizontal_Spacing: Horizontal spacing behavior
BigFH: 64-bit address file heap
CRCs: Checksum functions
Express: Expression analyzer.
ExtStore: Extendable Store class
GenVal: Simple Generic Value class
HTML: HTML and XML parsing classes
LoadArra: Loads arrays from tables in files
MemStore: In-memory contiguous store class
Menu_2D: 2D menu class
Menu_Popup_Form: Form for popup menus used in Menu_2D
Misc: Various routines, such as Sleep and Mid.
ObjectFa: Including this in uses constructs a default object factory object
Outlines: Outline class
Performa: Performance monitoring support
SMU: Screen Management Utility
StorHeap: Store heap class (a managed store on a store)
_StoreLis: List-in-a-store class definitions
StoreLis: 64-bit store list class
Structur: Various data structure classes
Tables: Random table class
TDialogs: Base dialog class
UEditor: Text editor class
VCLDebug: Debugger support for VCL/LCL controls

Layer 5 - GUI layer
This layer includes graphical UI components.
ArrayDis: Displays array contents on a Windows control
Array_Display_Main: And array display form with optionsc
TPanels: Transparent panel control
Editor_Panel: Windows control for a text Editor.
EditPref: Preferences dialog for editor.
EditWin: Embeddeable Text editor
Linenumb: Line number dialog
Output_Panel: Scrolling text output panel
SaveEdit: Save changes dialog
ScrollPanel: Automatically scrolling panel
SMU_Pane: Window that wraps an SMU window.
SReplace: Save/replace dialog
SSearch: Search dialog

1.2 Template files
The Subroutine library contains various support files, including the "x.app" files which are templates for applications, where "x" is the programming language in question. For instance, "Pascal.app" contains a template for pascal applications. It simply makes for a more consistent starting point for code.

1.3 Conditional Compilation
For languages which support conditional compilation symbols, the subroutine library reserves some symbols that begin with "CC_", as follows. Not all symbols apply to all platforms.

SymbolDescription
CC_Regression_Test Surrounds regression test code. If defined, the application will run regression tests when it starts.
CC_Balance Used to validate proper pairing of matched operations (such as allocations and deallocations).
CC_Debug Surrounds debugging code. If defined, debugging code will be included in the compile. This can slow the application down due to the extra work involved with logging data, etc. It may also enable certain options, especially on UI elements.
CC_Auto_Free_Application_Manager If defined, the application manager is automatically destroyed as the application exits.
CC_Auto_Free_Operating_System If defined, the Operating System interface is automatically destroyed as the application exits.
CC_Track_Resources If defined, resources are tracked.
CC_Validate If defined, data is validated. For instance, calls to methods of nil objects is checked for.

2. Language Interfaces

3. Subroutine Reference