Visual FlagShip 7 specification


 

What FlagShip is

The FlagShip database development system consists of
• A powerful and flexible programming language, which is mostly compatible in syntax to Clipper and dBASE. Its commands and functions are mostly compatible to Clipper (87 up to 5.3), with many extra features and enhancements. A FoxBase and FoxPro compatibility is available as far as possible.
• The FlagShip Preprocessor acts as one pass of the Compiler. It performs syntactic source checking and translates the preprocessor directives and user defined commands to UDFs (user-defined-functions). The preprocessor uses the standard include file "std.fh" by default (usually stored in /usr/include), as well as other optional include files.
• The FlagShip Compiler which translates the preprocessed FlagShip (and also Clipper or xBASE) source code into C source, checks it for syntax and plausibility, and then invokes the UNIX C compiler to complete the translation into the machine language (also named native code).
• The accompanying FlagShip Library, containing all necessary modules to support the language, dynamic variable scoping, statements and commands,
• all standard functions linked as needed,
• the runtime system to support macro evaluation at run-time,
• the database and index engine, - the input/output system,
• the object classes,
• a debugger enabling checking and setting actual variables and more.
• Tools for file handling, interpreter for ad-hock database maintenance, and many more.

Mode of operation

FlagShip is a true compiler. The language definition complies to great extent with Clipper definition, including some extras and enhancements. Thus, all conceptual differences between Clipper and dBASE apply for FlagShip, too. FoxBase and FoxPro is supported as far as possible. Most notable is the difference between a compiler (i.e. FlagShip) and an interpreter (i.e. dBASE). The main property of a compiler being that it produces executable files, not requiring any kind of a run-time module. The byproduct is protecting the source code.

The compilation of your application is done in the following phases:

• precompiling the FlagShip language, syntax checking and resolving the preprocessor directives,
• translation from the FlagShip language in the C code
• compilation and optimizing the C source into machine language (object code) using the standard Unix (or MS-Windows) C compiler
• linking the object code together with the FlagShip and Unix/Windows libraries using the standard linker, either statically or dynamically.
  
All these steps are done automatically when invoking FlagShip, however each separate step can be individually executed with the proper commands. You may use wildcards (*, ? including regular expressions etc.), make utility,  and/or specify additional flags, e.g. to compile file-wise or to collect required files automatically, to create GUI, Textual or Stream based application only (instead of the default hybrid executable), to link statically or dynamically, and much more.

System differences

FlagShip takes into consideration, and adapts to the differences between MS-DOS and various flavors of Unix for you, so that you do not have to bother with this. Also the small differences between MS-DOS and MS-Windows/32 system are considered. The main differences to MS-DOS operating system are:
• Composition and length of filenames: in UNIX, lower and upper characters are distinguished, and dot (.) is treated as any other character, i.e. it has no predefined meaning and can be repeated in the filename as many times as chosen. In UNIX the filenames are usually given in lower case characters, directory and paths are written with "/" instead of "\". FlagShip translates most of these differences fully automatically. In MS-Windows, there is no difference in lower/upper case names.
• RAM size and overlays: Unix (and MS-Win32) has no concept corresponding to DOS overlays. Instead, it uses paging and/or swapping to achieve virtually unlimited memory. Therefore, linking is straight-forward, without overlays. FlagShip compiler consider it automatically. In MS-Windows, the virtual memory manager has similar functionality as in Unix.
• Disk space and file system: Unix utilizes the concept of mounting physically separate disks into one file system (a tree-like structure of directories). Thus, from the user's point of view, all disks and partitions look like one. Asking for free disk space returns the value for the physical disk and partition on which the current directory resides. In MS-Windows, separate disk partition space is reported. In Unix, there is no equivalent to the MS-DOS drive selector (like C:) in the path specification, but FlagShip translates these automatically to a Unix directory using the environment variable x_FSDRIVE. Drive letters are of course fully supported in the MS-Windows port of FlagShip.
• Compatibility of programs: FlagShip supports the structure and semantics of Clipper or dBASE .prg files as closely as possible, no semantic or syntactic program changes are necessary. Since .fmt files are essentially program files they are fully supported, too. The syntax of commands, standard functions and preprocessor directives is compatible with Clipper '87 to 5.3. Also the Extended C system of Clipper is supported. In addition, the FlagShip programmer may also use inline C code within a .prg file or the Open C API interface with additional features.
• Compatibility of database files: .dbf and .dbt file structure of dBASE III+, Fox or Clipper is fully supported by the default DBFIDX driver without any transformations. Dbase IV and V databases have to be converted (by dBase) to dBaseIII format. FlagShip has own index structure (2-4x faster than Clipper's) which also automatically checks the data integrity (index vs. database) - hence one INDEX ON is required at the first invocation. RDDs for other structures (dBase, FoxPro, Clipper, SQL) are available via Replaceable Database Drivers, see details here. Memo files .mem,  label files .frm and reports .lbl are compatible to other Xbase dialects.

Basis of the FlagShip Language

The FlagShip language is based on the Xbase standard with all the extensions of CA/Clipper. Therefore, all Clipper '87 or 5.x programs and most other Xbase dialects (dBASE, FoxBase etc.) will be compiled by FlagShip without any modification. Only some system specific differences have to be considered. Even the GUI look & feel is created automatically without any source code modification, see examples here.
 
 

Language  & Compiler
	Fully source compatible		Clipper 87, 5.0, 5.2, 5.3 and FlagShip 4.4, 5, 6
	Almost source compatible		dBASE, FoxBase, FoxPro *
	Common source code for DOS (Clipper), UNIX and MS-Windows		yes *
	User defined commands and functions		yes
	User defined OOP classes		yes *
	Preprocessor directives of Clipper 5.x		yes
	Additional preprocessor directives		yes *
	Macro evaluation at run-time		yes
	Code blocks		yes
	All Clipper commands, functions and predefined classes		yes
	Additional commands, functions and classes		yes *
	Abbreviation of commands and some functions		yes
	Function or procedure name length		128 chars, first 10 chars are significant
	Class method name length		unlimited, fully significant
	Number of UDFs and procedures		unlimited *
	Nesting of UDFs		unlimited *
	Structure nesting		unlimited *
	Number of nested loops		unlimited *
	Expression and macro length		up to 4 KB *
	Nesting of each macro		up to 255 depth *
	Break from loops		yes *
	Save & restore screen		yes
	PC-8 and ANSI character set support in source code		yes *
	Binary 0 in string		yes, selectable *
	Extend-C system (Clipper compatible)		yes
	Open-C system with unlimited access to variables and UDFs		yes *
	Inline C code within the .prg file		yes *
	Translation of .prg source into the C language.		yes *
	Produces native executables		yes (32bit * or 64bit ** mode, statically or dynamically *  linked)
Mode of operation
	GUI environment		yes * auto-detected, compiler-switch or via user request
	Terminal environment (also remote terminals)		yes auto-detected, compiler-switch or via user request
	Stream/basic mode (e.g. for CGI or background)		yes * compiler-switch or via user request
Input / Output:
	GUI environment		yes *
	Color and b/w terminals		yes
	Stream i/o mode (e.g. for CGI)		yes *
	ASCII/PC-8/OEM or ISO/ANSI character set		yes *
	Additional character mapping		yes *
	Printer output		spooled *
	Low-level input/output		yes
Variable  system:
	Dynamic variable scoping		yes
	Public, private, arrays, static, local, constant*		yes
	Typed static, local, global		yes *
	Number of memory variables		unlimited *
	Length of variable name		unlimited, first 10 chars signif.
	Character variables		size up to 2GB *
	Numeric variables		8 byte double float, precision 15 digits
	Date variables		4 byte long integer
	Logical variables		1 byte character
	Screen variables		4 byte memory pointer *
	Arrays		one- and multi-dimensional
	Array size		limited by memory only (65000 each dimension) *
	Array element type		all variable types incl. arrays and objects
	Store/restore of arrays in .mem files		yes *
	Automatic (and user defined) garbage collection		yes
Classes,  Objects:
	Predefined classes, Clipper compatible, many of them with additional properties and extended functionality* (each for GUI, textual and basic/ stream mode - assigned/detected automatically)		CheckBox, Error, Get, ListBox, MenuItem, PopUp, PushButton, RadioButton, RadioGroup, Tbrowse, TbColumn, TopBar
	Additional predefined classes, many of them are VO compatible (each for GUI, textual and basic/stream mode  - assigned/detected automatically)		Applic, AppWindow, Color, ColorPair, ComboBox, DataServer, DbServer, Dbfidx, Dimension, ErrorBox, Font, InfoBox, MessageBox, Mouse, Point, Printer, Prompt, Rectange, Size, TextBox, WarningBox (all *)
	User definable classes in VO  syntax		yes *
	Inheritance of classes		yes *
	Number of user defined classes		unlimited *
	Class inheritance depth		unlimited *
	Method, Access, Assign		yes *
	Protected and Static methods		yes *
	Instances, protect, hidden, export		yes *
	Prototyping of methods		yes *
	Automatic prototypes by the FS compiler		yes *
Files,  Multiuser,  Multitasking
	Maximal program size (executable)		2 to 4 Gigabyte ** (system specific)
	Maximal size of .dbf, .dbt, .dbv, .idx		nearly unlimited, large files >> 2GB (up to 16 TB ***) are supported * **
	Fully compatible .DBF and.DBT files		yes
	Compatible .MEM files		yes
	File & record locking, exclusive & shared dbf		yes
	Multiple record locking		yes *
	Automatic locking, user-modifiable		yes *
	Network database share		yes
	Multiuser, multitasking		yes *
	Filename Length		up to 255 chars **
	Path name Length		255 characters **
	Simultaneously opened files		unlimited **
Database  and Index
	Simultaneously opened working areas		unlimited *  (64.000)
	Simultaneously opened files		unlimited ** (64.000 in Linux and Unix, 2.400 in Windows)
	Indices per working area		unlimited *  (64.000)
	Relations per working area		unlimited *
	Records per database		4 billion (4.000.000.000)
	Fields per record		65000 *
	Character field		8-bit ASCII, up to 64 KB *
	Numeric field		ASCII format up to 19 digits incl. sign and deci point
	Date field		ASCII 8 digits incl. full year (1/1/0001...12/31/9999)
	Logical field		one ASCII character ('T','F','Y','N')
	Memo field (.dbt)		10 digits pointer to .dbt block
	Compressed memo field with variable block size (.dbv)		yes * with up to 2 GB block size each
	Other field types		Int, Real, Byte, Blob *
	Structure of .dbf file		Binary header + sequential records of fixed length in ASCII format
	Structure of .dbt file		blocks of 512 bytes, up to 32 MB ea.
	Structure of .dbv file		blocks of variable size, up to 2 GB ea. *
	Structure of .idx file		Binary header + Btree binary structure, automat. data integrity*
	Index key size		430 bytes *
	Database vs. index integrity checking		yes *
	Record and File locking		yes
	Multiple record locking		yes *
	Automatic locking (user-modifiable)		yes *
	Network database share		yes (also via NFS or Samba) *
	Other RDDs (replaceable database drivers)		available * (click here for details) including SQL
	Creating own RDDs via OOP		possible * (examples available)
System:
	Supported Unix systems		32 and 64 bit: more than 50 * (see more...) incl. Linux (see more...)
	Supported MS-Windows systems		32 and 64 bit: Windows systems like NT4, 2000, 2003, 2008, XP, Vista, Windows-7 (see more...)
	User requirements		none
	Developer requirements		FlagShip for the target system + standard C compiler (for MS-Windows: BCC or MS-VC6++)
	Run-time royalties		none
	Produces stand alone executables		yes (32bit * or 64bit ** mode)
	Full Y2K conformance		yes * (click here for details)
	Additional 3rd party tools		available (click here for details)

Notes:
    * marked items are FlagShip extensions to Clipper.
    ** marked items depends on the used Unix or Windows system.
    *** the size of .dbf, .dbt, .dbv and .idx files is nearly unlimited, theoretically up to 2^63 = 9.223.372.036.854.775.808 bytes (9 EB = 9.000.000 GB), practically approx. 16 TB (= 16.000 GB), limited only by the used operating and file system.

Please see additional details in the FlagShip manual, section LNG and REL. The on-line manual named "fsman" is installed automatically also with the test drive. Complete manual (2500+ pages) is a part of the usual distribution, or available on-line.

For further information and local distributors, contact:
    multisoft Datentechnik, Ludmillastr. 23e, D-84034 Landshut, Germany
    Telephone (voice): ++49-871-3300237,  Telefax: ++49-871-96561648 (24 hr)
    E-mail : info@flagship.de or sales@multisoft.de
    Web : http://www.fship.com

Last modified: 28-Sep-2011