FlagShip logo  
    FlagShip 5 and 6 (Visual FlagShip)
    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
    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 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 (not for MS-Win) 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, 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 **
    Maximal size of .dbf, .dbt 2 to 4 Gigabyte **
    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 * (65000) 
    Simultaneously opened files unlimited **
    Indices per working area unlimited *
    Relations per working area unlimited *
    Records per database 4 billion
    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
    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 64 KB ea. 
    Structure of .dbv file blocks of variable size, up to 2 GB ea. *
    Structure of .idx file Binary header + Btree binary structure incl. integrity data *
    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 more than 50 * incl. Linux
    Supported MS-Windows systems all 32bit: Windows-95, 98, NT4, 2000, XP
    User requirements none
    Developer requirements FlagShip for the target system + standard C compiler (for MS-Win: 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.

    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. Printed manual (1500+ pages) is a part of the usual distribution (except for Linux, Windows), or can be ordered separately.

    For further information and local distributors, contact:
        multisoft Datentechnik GmbH, Pf.1312, D-82027 Gruenwald, Germany
        Telephone (voice): ++49-89-6490040,  Telefax: ++49-89-6412974 (24 hr)
        E-mail : info@fship.com
        Web : http://www.fship.com