FlagShip FAQs


What is FlagShip? The Compatibility FlagShip Licensing Running the Application Third Party Libraries

What is FlagShip?

FlagShip is the perfect language for most data oriented or business tasks, as well as a great language in which to do many system administration tasks. Because of it's flexibility and speed, when combined with Webkit, FlagShip is fabulous as the data engine running behind a Web Page on a Web Server. You can even embed Java code within the FlagShip database in order to do client server with a remote system, and much more. FlagShip includes the very best features of many other languages. FlagShip is a superset of Clipper 5.x, as well as Fox, and dBase.

FlagShip is a cross-platform database development and xBase porting system for any Unix OS. It is source compatible to CA/Clipper 5.x and earlier.

FlagShip is an easy, productive 4GL programming language and database engine ideally suited to building data oriented business applications. With CA/Clipper compatibility, FlagShip allows you to build cross-platform applications for DOS and Unix. Companies choosing have access to millions of trained CA/Clipper & xBase Programmers.

... for the DOS/Clipper/XBase People

FlagShip allows use of your xBase skills to capitalize on UNIX. Create true executable code, and pay no royalty or runtime fees. An easy and productive Object Oriented Programming Language, FlagShip brings to millions of Abase Programmers access to the powerful and stable world of Unix.

Unix has multi-tasking, multi-processing, multi-threading, Client/Server support, and virtually no memory limitations. Unix is also available from the smallest to largest of hardware.

FlagShip is source code compatible with CA/Clipper 5.x, FoxBase 2.x (With FoxKit), and Dbase III. FlagShip supports In-line "C" code and the Clipper Extend System. You can also use FlagShip as a DBMS and/or I/O library for "C" with its "Open C API" Interface. FlagShip allows you to have a common set of source code for Unix and DOS.

... and for the UNIX People

Bring the productivity gains of the xBase languages to your already powerful Unix system, making it more powerful. Take advantage of a strong third party market and the many utilities available. Take advantage of Object Oriented programming with Code Blocks, Methods, Classes and Functions.

Reduce coding time without leaving "C" Behind. FlagShip supports In-line "C" code, and the Clipper Extend System; you can use FlagShip as a DBMS library for "C" with its Open "C" Interface. With add-on software drivers, FlagShip can be the 4GL language of choice working in Client/Server fashion against Oracle, Informix, Ingres, Sybase and other SQL DBMS engines. FlagShip allows creation of true executable code to be distributed with no payment of royalty or runtime fees!! FlagShip also allows you to have a common set of source code for Unix and DOS.

Why FlagShip?

FlagShip lets you easily create and distribute multi-user applications with full-featured record and file locking for data integrity. There are no LAN Packs, multi-user charges or runtime licenses required. The program you create is YOUR program.

Mainframers, MIS, or Network Administrators can take the lead once again, bringing order to the chaos in most corporations. Fancy applications have popped up on PC LANs. Departmental PC programmers have been going wild with a language (Clipper) that allowed them to do the "End Run" around your applications development staff. Order can come as MIS rightsizes to Unix with FlagShip. Give your staff a superset of that same language that has worked so well at the departmental level. Move the PC applications to Unix. Moving these applications adds serious computing power, as well as providing for better data-sharing. Let those productive PC developers work for you as you also continue to do development and then deploy it for them. You could usher in a whole new era of co-operation!!!

... has a cross-platform guarantee

Many have promised it! But we deliver on the two most significant platforms today, and in the future. Use a common set of source code for both DOS and UNIX. Simply compile with FlagShip on Unix, and CA/Clipper for DOS.... It is that simple.

... has room to grow

FlagShip allows you to build your language with User Defined Commands (UDC), and Functions(UDF). You can build your generic libraries to use over and over again and speed your programming. You can buy libraries already pre-built by others. You can also build specialized libraries and applications for serial communications, accounting, real estate, personnel management, billing, invoicing, or anything other process that utilizes data of any kind.

FlagShip has a large installed base, and an active third party market from whom you can buy pre-made add-ons and utilities if you wish to accelerate your productivity. There is also room for you to enhance and sell the libraries and applications you have created in this marketplace.

... saves your money

FlagShip creates "C" code as its intermediate step to building your executable for you. 10 Lines of FlagShip code can create well over 100 lines of "C" code which is completely bug free. When working primarily in "C", you have to worry about stacks, and pointers, and memory allocation, and other issues that are sometimes useful, but more often cause you to generate bugs. It is far more effective to program in FlagShip which takes care of them for you. You do not have to give up any of the power of "C" however. FlagShip has built in I/O libraries, and file access libraries, and other functions that do not exist as a part of "C". Taken together, these features allow a FlagShip programmer to run rings around a "C" only programmer in applications for which FlagShip is suited. It allows integration of "C" for areas where it is not as well-suited.

... has a direct access to C

If you would like to expand the FlagShip functionality, use "C" and integrate it into FlagShip via any of the different methods available such as "In-line C", "C Extend System", "Open C" interface or others. Using this combination, you can create robust applications and utilities for Unix in a fraction of the time as working only in "C".

One of the strengths of Clipper has been the capability to do "trial and error" programming without endangering your system. As any experienced C programmer knows, it is possible for a neophyte let loose with "C" and the right permissions to crash a Unix system by mistake. This is not the fault of Unix, but rather a testimony to the power of "C". It is just as easy to crash a DOS or any other system. FlagShip goes a long ways toward removing this danger, by allowing "trial and error" programming without danger to systems. It does so without losing the power of "C" when nothing else will do.

... has all that you need

FlagShip is a robust Object Oriented Language with a flexible Pre- Processor, and high-performance executables.

When used with a Unix development system, FlagShip has make utilities, editors, and debugger. It has dynamic and lexical variable scoping, user defined commands, and functions, code blocks, nested multidimensional arrays, pre-defined object classes and other features. FlagShip variables can be modified from the debugger, and reactive error handling is customizable. FlagShip reads and writes Clipper native Data files, and can also be attached to other data engines. FlagShip also provides substantial screen and user interface handling utility.

... doesn't require additional knowledge

FlagShip has millions of trained programmers available because it is an extension to Clipper, and other familiar xBase languages such as Dbase III, and FoxBase.

FlagShip allows seamless integration with other languages such as C, C++, C Shell, Bourne Shell, Korn Shell, Dbase, Informix, Oracle, Sybase and others.

... is versatile

FlagShip is FAST, faster than any SQL Engine you can use for data file manipulation.

If you have run into the speed or language limits using Oracle, Sybase, or Informix's 4GL tools, take a serious look at the FlagShip/Clipper 4GL Language. It is complete, extensible, and excellent for downsizing (right sizing) while creating the kinds of fancy applications that PC users have come to expect. All this in a heterogeneous, scale-able, environment that can be extremely cost effective while still use the SQL data engines you have.

... and avoids

Client/Server Downfalls; complex setup procedures, inflexible databases, limited vendor inter-operability while still requiring mixed vendor setups, super expensive programmers in short supply, slow speed, high cost, high knowledge requirements, limiting languages, no common access methods, requirements for excessively high-powered computers, extremely high cost of distribution due to expensive runtimes.

Press hype aside, as a general solution, FlagShip excels.

Why UNIX instead of DOS, or Novell, or other PC-Networks?

Contrary to popular opinion, Unix is quite easy and gives you power that before now you have only dreamed of.
In short   <by John E. Davis>:
Q:  I am new to unix and would like to know a couple of things. How in simple terms is UNIX better than MS-DOS or MS-Windows??

A:  I work with MS-DOS, Unix, and MS-Windows everyday. Below are descriptions of the psychologically feelings that I have when working with these systems.

Working under MS-DOS is like being in a small room with no windows and no doors.

Working under MS-Windows is like being in the same room with no doors and no windows but with lots of mirrors on the walls.  It looks a lot bigger but I am still stuck in the same room.

When working under Unix, I have doors and windows in the room.  I can move from one room to another.  There is alot of freedom.

No more memory limitations! You can build executables up to 2 Gigabytes in size, provided your system is properly configured. Questions like, "Will the program still run on my PC with only 520KB of memory available are History!!"

Unix and FlagShip support multi-user AND multi-tasking AND multi- processing, all at the same time! You don't have to fake Unix out to do these things as many try to do to DOS; just use it! Unix will allow many people to use it at once, with each doing many things at the same time, and toggling between them. With FlagShip you can even emulate an entire PC LAN on a single computer; therefore it may even be practical for you to use FlagShip to develop software for PC LANs! It makes for less money invested in your hardware for development purposes.

No more speed limitations (scalability)! You can start with a 386/SX and Linux; whatever you create will work on a 386/40, a 486/33 or 50 or 66, or Pentium, or even a Multiple Pentium box. It will even work in machines from a number of vendors with 2 to 100 processors. You need never change the binary you created to run the full scale. Very similar machines can support one to several hundred simultaneous users; they can each have any number of sessions or programs running at the same time. For instance, a 386/40 does a respectable job of supporting 5 to 10 simultaneous users. Scalability is one of the promises that NT has been holding out. Many buyers do not realize that Unix has had it for years. While Unix at first may appear to be expensive, when you compare systems to a PC-LAN with a similar number of users, Unix is usually quite a bit less expensive.

More Speed! When you use a PC on a typical PC LAN, it stores its files on a Novell or similar file server. The PC does the sifting, sorting, indexing, etc. in the files. As a result far more data is transferred across the LAN than just the data the program is supposed to work with. In fact, often the whole file is transferred across the network cable hundreds or even thousands of times during a user session. This is impractical, and can really bog down everything on the network. It is practical to do word processing (Files are only occasionally retrieved or save, mostly manipulated in RAM) this way, but not data access, especially as the file sizes increase. A local user's PC on a LAN is often far less powerful than the network file server, and yet it is the one that actually has to so the seeking, calculating, indexing, etc. with database applications.

In a Unix configuration, the power of a host machine is shared between users. This relieves the network of all the extraneous data transfer. One attempt at this in the past has been to use xBase or other Client-Server NLM's on a Novell server. FlagShip/Unix does not prevent this, but in fact takes this concept to the next logical step.

Availability of larger file systems, RAID, Optical jukebox, LAN Wide backups! DOS does not handle large file systems very well. Unix systems can easily be configured for 1 to Hundreds of Gigabytes if you wish, using RAID (Redundant array of inexpensive drives) techniques, Optical media, and even optical jukeboxes.

In addition, Unix has Peer to Peer LAN capability to share file systems among machines. Unix file systems can easily be set up for fault tolerance. It is also easy to set up dual fault tolerant systems configurations if you wish. Unix can have file systems and I/O throughput rates that DOS users only dream about.

Inexpensive terminals OR PCs allow very low cost per user. You can connect inexpensive terminals costing 200-400 dollars to a very high powered Unix server. This will be MUCH less expensive than a PC LAN because it does not require high-powered PCs at each station. The Unix machine in fact does not have to cost any more than a Novell Server would. Also sharing the hardware, and centralized maintenance can result in higher quality, and lower cost overall than PC LANs.

Expensive hardware attached to a Unix system can easily be shared by all users on the system; on a PC LAN each user may need their own.

Centralized maintenance of one machine is often far more practical than maintaining separate software on a lot of PCs. Any update done on a PC LAN must be done on each station. On a Unix system it can be done in only one place, the main system for all users. Backups on the Unix system are generally done automatically and at night for all users, programs, and data.

You do not have to worry about individual CONFIG.SYS and AUTOEXEC.BAT settings for individual machines when terminals instead of PCs.

Unix is a perfect Network Server for PC LAN or other Unix machines! You do not have to give up PC LAN capability to get Unix. Unix can support inexpensive terminals simultaneously to providing file service as well as print and other services to a network of DOS/Windows PC's.

Unparalleled communications capabilities! Unix was designed and used by AT&T for many years to support the International Telephone network. Every time you make a phone call you are using one or more Unix systems. Unix communicates to other machines with TCP/IP, NFS, Netbios, IPX, SPX, 3270, Token Ring, Ethernet, RS232 and every other method you have ever heard of when used with the appropriate software and hardware. It can do them all simultaneously if so configured. It has a large library of functions and routines that can be used to allow your programs to interface with these capabilities.

Data Security! Unix brings complete and well-tested security mechanisms with it. You can choose to make your data as available, or as protected as you like. In a central Unix system with appropriate security, someone cannot just slip a diskette into the drive and walk off with your data files; they often can on a PC LAN.

You can use any hardware and processor type! Unlike DOS or MS-Windows which is for only one hardware platform, some version of Unix is available for nearly every hardware platform known to man, from nearly the smallest to the largest.

Superb programmers development system, utilities, and tools, source code control, make, linking, etc., etc! Most of the things you have to buy separately for DOS, already come with a Unix system. If you have some utilities in DOS from which you are inseparable, generally there are Unix versions of them, or very similar add-on products for Unix that you can buy separately. Don't forget, you can always share the Unix file system with a DOS machine, or a DOS emulator for that matter. You can still use a lot of the utilities you currently use (editors, for instance).

In fact, on Unix you can easily test and debug one program while another is compiling. You can test entire network environment on just one terminal simply by switching sessions.

Virus Protection! There are very few virus programs for Unix. Because of the way Unix is designed, it is nearly impossible to design a virus that will work in the destructive way the ones in the DOS world do. Only by getting super user privileges can it have the system access it needs. This kind of privilege must first be granted by an administrator who has been deceived, or who is not setting passwords on accounts, or making other obvious errors. Any other kind of virus can only cause minor annoyances without really doing any serious damage.

Unix is very stable. It has capabilities that NT and OS/2, and Novell are only just now beginning to talk about & implement, such as ability to distribute applications and computing resources logically.

You can use Unix as a file server to PC apps, as a database data server to PC clients for database programs. You can use it as an application server for big power-hungry apps, which are still displayed on the PC. Unix can be both an applications machine, and a server machine, even at the same time.

There are millions of existing Unix users and xBase programmers available to help with questions electronically any time of the day or night. Many are on the Internet's Usenet News worldwide Bulletin Board system. More are on CompuServe, as well as other electronic networks and Bulletin Boards, and this doesn't even count the WorldWide Web, where over 80% of the connected machines are Unix boxes. It would not have been possible to build the Internet without Unix, Unix power provides the backbone and the flexibility.

Unix is super stable, tested, and proven. Unix is cost effective when used with inexpensive character based terminals. Unix can have graphical windowing, nearly indistinguishable from MS-Windows by users. Unix can run DOS and MS Windows applications while multitasking, multiprocessing these and other applications. Unix on the right hardware has power to burn, ease of use, and has flexible networking built in. Unix can be used as a Data Client/Server, File Server, Application Server and other kinds of servers simultaneously. Unix can be mix & matched with PC machines and networks, and allows distributed processing. Unix has hundreds of thousands of pre- trained users. What more could you want?

Isn't UNIX Hard to Use?

Do not be deceived by this common perception. If you have learned to use DOS, then you know almost everything you need to know to use Unix. The reasons people traditionally have thought Unix is hard actually have very little basis in fact.

Most of it comes from the observation that the manuals are so thick, that there are so many different versions, and that the commands are often missing their vowels, and have so many options.

The majority of the problem has occurred because every vendor of hardware that has given Unix their own name and added few utilities of their own. They then proceeded to advertise it as different and better. In actual fact among the 100 or so versions of Unix, there are only three major versions. Even these major versions are so alike that moving from one to the other is rather trivial. The percentage in which they differ is as small as the differences when comparing MS DOS, IBM PC DOS, and Novell DR DOS. Only a few commands really differ. If you know one, you may be a bit annoyed for a few hours when moving to a different version, but then you get used to the difference, and become productive again.

Unix could be difficult if you tried to learn everything it has to offer all at once. But the same occurs when learning DOS, and especially Windows. In fact, the configuration files under the hood of MS-Windows are more complex than Unix's.

Keep in mind that when you first learned DOS, there were about 20 basic commands that you needed to understand; the rest could be looked up and learned as needed. It is the same with Unix; each command that you learned in DOS actually has a direct parallel in Unix. To do what you need with FlagShip should not require more than these.

You could even write a very short Shell Script (Read "batch file") which would actually allow you to use the same DOS commands you already know. It is possible to purchase utilities where this has already been done. Yes, there are hundreds, and even thousands of commands, choices and options available in Unix. This is one reason Unix is so powerful. It is comforting when you think about it, if you need the power it is there; if not, then you can just safely ignore it.

Doesn't UNIX Require expensive machines or workstations?

No, Unix is available to run very well on machines that actually choke when presented with Windows NT or OS/2. SCO Unix and Interactive Unix, and Free or near free GPL Linux do fine on an Intel or AMD 386/40 with 4MB of RAM, and 120MB of Hard disk. Linux, SCO ODT, Novell's UnixWare, or Sunsoft's Solaris x.86 (Graphical, Windows Based Unix capable of running MS Windows and DOS Applications, as well as Unix Applications) run just fine on a 16MB 486/33 with 500MB of hard disk space, even supporting multiple simultaneous users.

How much UNIX do I need to know? How similar is it to DOS?

Installation usually involves copying software from tape, establishing a few user logins, and choosing a system name. It is far easier than installing or configuring a Novell server, or even Microsoft Windows for WorkGroups in some cases. Depending on the Unix vendor you chose, installation may be entirely menu driven. SCO is a good one; it is the reference system on which we do our writing, testing, and beta testing. Linux also keeps getting better by leaps and bounds, and is well supported on the Internet, and Compuserve and is free or very cheap on CD-ROM, therefore it is well worth your time. Soon Linux may be the standard in Operating Systems technology if it keeps developing as it has over the last few years.

The remainder of this section assumes that you already know DOS commands and concepts. The Unix equivalents of these DOS commands is the same as the Unix commands that it is necessary to know. By the time you get done, you will see how much Unix you already know.

As you look at the following list of commands, keep in mind that the DOS file system of Directories and Sub directories concept was adopted from Unix. Where DOS uses "\" (Path name separator) Unix uses "/", where DOS uses "/" (Options to a command) Unix uses "-". DOS also adopted from Unix the concept of filters and piping ("|" connects output of one program to the input of another [i.e. "type filename|more"], and ">" or ">>" redirect output and "<" redirects input). When you are using DOS, though you may not realize it, you have been using a subset of Unix (in concept) all along. You need to learn more, only if you want to expand your use of the power of Unix.

DOS does not care about upper or lower case; Unix does. By default, in Unix always use lowercase unless you have a specific reason for uppercase. This is a bother at first, but as you get used to it you will realize how great a strength it is for flexibility of file naming. DOS requires 8 Digits of letters followed by a three letter extension (XXXXXXXX.XXX) for filenames. Unix allows this as well, but also allows very long names (up to 256 characters in most versions) using either case or both. When you do networking with DOS systems however, you will want to be careful and restrict yourself to the DOS naming conventions.

DOS vs. UNIX system commands

For more thorough explanations of the following Unix commands, please use the online UNIX manual pages on your system, or your printed Unix command reference. Online descriptions can be seen on most systems by entering the man command followed by the command you want described. "man chmod" for instance will provide explanation of the command "chmod".
DOS/Novell     UNIX      Description
Supervisor     su, root  Super-User login id, can do anything
                         regardless of file permissions, or other
                         restrictions, keep password protected

n/a            ln        LiNks a file in one directory to a name
                         in another, allows files to have more than one
                         name in more than one place.  If one gets changed
                         so does the other.  Very useful when you want the
                         same data in more than one place but do not want
                         the overhead of duplicate storage, or to have to
                         maintain them both separately.  Not possible on
                         DOS, Novell, or Windows NT.

ATTRIB         chmod     CHange MODe, where -rwxrwxrwx on the
                         directory listing refers to {-}Type of file, d for
                         directory, - for standard file, etc. First {rwx}
                         is permissions for the owner read, write and
                         execute, second {rwx} is the permissions for the
                         group of people the file belongs to, read write
                         and execute, and the last {rwx} refers to everyone
                         else.  If the letter exists, then the permission
                         does, if replaced with - then it doesn't.  See
                         also LNG.3.3 in the online FlagShip manual.

n/a            chown     CHange OWNer on file or directory and
n/a            chgrp     CHange GRouP on file or directory.  This
                         is actually simpler and more elegant than the
                         permissions and methods of setting them which
                         Novell uses.

BACKUP,        tar,      Tape ARchiver, or CoPy In/Out can move entire
RESTORE        cpio      directory trees or individual files into a
XCOPY                    holding file, floppy disks, or from one
                         directory or file system to another.

CD or CHDIR    cd        Change Directory and remember to use "/"
                         instead of "\" as the pathname separator.  Plain
                         cd without a path moves to the home directory
                         assigned to the user you logged in as.

CHKDSK         df,du     Disk Free, and Disk Used utility, can
                         report on the entire file system with everything,
                         individual directories, or specific directory

COMP or FC     diff,cmp  CoMPares files, or directories to one
                         another, and displays DIFFerences, similarities,
                         etc. as defined by options supplied by the user.

COPY           cp        CoPy by using of dot (.) for the current
                         dir instead of nothing on DOS.  Example: DOS: copy
                         \tmp\file would bring the file from \tmp to the
                         current directory.  In Unix: cp /tmp/file.

DATE, TIME     date      Unix includes both functions within one
                         command, you simply use - options to determine
                         which you want, and in what format.

DIR            ls        LiSt directory, almost always used with
                         the "-l" option, like ls -l *.  These options are
                         similar but have a more extensive range of choices
                         than the DOS / options to the DIR command.

ERASE, DEL     rm        ReMove a file.

EXIT           exit      Exits the current Shell (COMMAND.COM on

FDISK          fdisk     This is correct on SCO Unix, others may
                         call it something else, but will have the
                         equivalent functionality.

FIND           grep      Get REPetitions or Get Regular
                         ExPressions Retrieve lines that match a pattern
                         from a file, similar to Norton ts (text search).
                         Also egrep and fgrep which extend capabilities
                         further are available on most Unix systems.

FORMAT         format    Formats a floppy diskette.

MD, MKDIR      md        Make Directory.

MODE,CTTY,     stty      Sets  modes such as baud rate, parity
                         and other
BREAK                     attributes on  a  tty (serial  port  or
                         printer port).

MORE           more, pg  Pages output for display on the screen.

PATH           PATH      Environment variable which tells the
                         system where to look for files to execute when
                         named.  Each user can have their own, which is
                         usually in addition to a system wide path
                         statement for sharing of the most common

print          lp        Line Printer.  Print spooling facility,
                         runs in the background.
                         lpstat    tells status,
                         lpshut    shuts it down,
                         lpsched   starts it again,
                         enable    enables a printer,
                         disable   disables a printer,
                         accept    tells it to accept print jobs,
                         reject    tells it to reject print jobs,
                         cancel    tells it to cancel a print job.

RENAME         mv        MoVe a file from one place to another,
                         or just rename it.

RMDIR          rmdir     ReMove a DIRectory.
                         rm -r     ReMove a directory, including all files
                         and subdirectories.

SET            =         <VarName> = <Value>, same as DOS but
                         don't need the keyword SET in sh, or ksh (Bourne
                         Shell or Korn Shell).  To make the variable
                         visible in sh and ksh, export it using "export
                         <VarName>".  On csh (C shell), use the "set"
                         keyword (to set) or "setenv" keyword (to set and
                         export) the environment variable.

SORT           sort      SORT the contents of a file

TYPE           cat       conCATenate: to add characters to a
                         file, or from one file to another, more powerful
                         than DOS type but includes it's functionality)

ANSI.SYS       TERM=ansi; export TERM (Setting Environment
                         Variable for Screen output).  Better: TERM=FSansi
                         ; export TERM for the extended FlagShip support.

Batch file     Shell script (DOS Batch .BAT were designed after
                         these, and have similar syntax.  The unix versions
                         have far more options and power.  Refer to "man
                         sh" manual pages.

AUTOEXEC.BAT   .profile  There is a system wide profile for every user on
               .login    the system, and an individual profile
                         that adds to or overrides whatever is in the
                         system wide profile. .profile in the user's home
                         directory is used by sh and ksh, .login is used by

CONFIG.SYS     sysadmsh  SYStem ADMinistration SHell On SCO, SAM
                         on HP, SMIT on AIX, and other names on other
                         systems.  also see Kernel Parameters in your
                         system documentation for the system tuning
                         information which is rarely needed, but useful.
                         Menu Driven system modifications configurations &
                         Options may be done with the administration
                         shells.   Also Refer to FlagShip online manual
                         (fsman), section SYS.3.

shell=         sh,csh,   simply different command line or Batch file
command.com    ksh       interpreters, very similar but have
                         differing capabilities.

A: B: C: etc   n/a       Unix does not use these by default,
                         although it can.  (SCO Unix does come configured
                         with a: and b:) View the Unix filesystem as your
                         C: drive (Without the Drive letter attached), and
                         everything, including floppy drives, tape drives,
                         etc, are sub directories to the main file system.
                         Usually these types of things are kept in the /dev
                         (Devices) sub directory, but do not have to be.
                         For instance you could create a file in the root
                         (/) file system called A: or a: which then refers
                         to /dev/fd0(Floppy Drive 0).  Any additional hard
                         disks also simply become sub directories "mounted"
                         to the main one.  Think of One Huge Directory tree
                         on your C drive, with many sub directories.  Refer
                         also to FlagShip online manual sections LNG.3,
                         LNG.9, SYS.1.1.

Networking     NFS & TCP/IP         Many Different networking
                         possibilities are available on Unix Systems, but
                         the ones listed here are most common on UNIX
                         systems (Often included at no extra charge), and
                         are becoming more common on all other operating
                         systems.   Microsoft and Novell both support

How difficult is the Port to Unix?

It isn't difficult!!! FlagShip automatically supports most of the Unix/DOS system differences.

Describe a typical Conversion to Unix?

The first action after installing the FlagShip software is to copy your DOS Clipper or other xBase source files to the UNIX machine. There are many ways to accomplish this (refer also to the FlagShip manual, sections FSC.6, FSC.7 and SYS.1).

One of these ways is to simply copy all your files, .prg, .mem, .dbf, .dbt, .frm, .ch, etc files to floppy disks. Then put those disks one by one in the floppy drive on the Unix machine, and run the FlagShip supplied "FSload" utility. Other possibility is to connect the DOS drives directly (mount) or via NFS, TCP/IP, Internet, Intranet, LAN, serial cable and copy it directly....

"FSload" imports the files into the current directory on the Unix system. It strips the ^M, and ^Z symbols which DOS has in its text files in the process. (DOS uses linefeed-carriage return pair to end lines of text in a file, Unix uses only line feed, DOS uses Ctrl-Z to end a file, Unix needs no file end character) This is for convenience in editing only. In most cases FlagShip does not care whether these characters are in the file or not, providing they follow DOS' rules. Sometimes a ^Z at the end of a line, rather on its own line can cause problems, as can ^M in .ch files. So it is safer to remove them.

Compile the code with the command "FlagShip program.prg" (where program.prg is the main entry routine to your programs, it could have any name and/or UNIX wildcards), see more in the manual section FSC.1.

Run the Executable, your program is converted.

Possible issues I may deal with?

  1. Use the UNIX "make" to do what "rmake" does for Clipper, see also FlagShip online manual, section FSC.2
  2. Use a list of files, and define the main module for FlagShip (see FSC.1.2). This allows more control over how your program is built.
  3. Undocumented Clipper Functionality: Clipper from one version to the next has had various undocumented bugs, and features. If you have done much trial and error programming, you may have used some of these. If so, we would like to know about it. FlagShip almost always reproduces these undocumented features if they are not dangerous to data, and do not conflict with how the latest version of Clipper (Currently 5.2) works. FlagShip is actually more compatible with Clipper Summer 87 than any Clipper 5.x version is. It is good programming practice to make your code conform to what is documented. We have fully implemented Clipper's documented functionality from all versions, with preference in a conflict given to the latest version.
  4. Run commands containing DOS specific commands. In most cases it is very simple to substitute the equivalent Unix command, or create a shell script (Batch) file by the name of the DOS command that calls the Unix command. See more in the CMD.RUN manual entry.
  5. Path names, and Filenames, Upper Case, Lower Case, File Extensions, etc. Please look at our FS_SET() function (section FUN), which has extensive features to make these issues as transparent as possible. Often you need to use FS_SET once at the beginning of your main routine for each type of problem and they will go away for the entire application. Refer to QRF, LNG.9.4, LNG.9.5
  6. DOS Specific Code. Use the #ifdef FlagShip, #else, #endif pre compiler statements to have the Unix Specific code in the if, and the DOS specific code in the else section. You can then compile for DOS with Clipper, and Unix for FlagShip, knowing that only the correct code will be included in each version. Refer to LNG.9.5, PRE.2
  7. Third party Libraries. They are not as much of a problem as they first appear to be, Please see the section in this document on this issue.
  8. Hardware & Terminal Issues. Depending on the terminal types you are using, certain display modes, and certain keystrokes may not be available to you. ALT for instance is rarely available, Shifted Function Keys are sometimes not available, Background Shading may not be available especially on monochrome terminals, Color may not be available, etc. Some Control Characters may have special meanings to Unix (Like Ctrl-S and Ctrl-C do to DOS). These are not FlagShip limitations, as FlagShip will support anything you have done, providing the terminal hardware, Unix version, and communications settings you choose will also do so. For more information, refer to LNG.5, FSC.3, SYS.2. Printers and other devices MAY face similar issues, but usually only the name of the device needs to be changed in the code.
Having dealt with these issues, you now have working Unix Software!

Do I have to continue my programming in DOS?

Not necessary! You may create and/or modify your programs on DOS -or- on UNIX and transfer this common code to the other system, if needed.

The way you program in DOS with Clipper, is to write Clipper Code using a Text Editor, Compile and Link using the Clipper compiler, and then Debug using the Clipper debugger.

The way you use FlagShip is exactly the same on the Unix machine. Simply replace the appearances of the word Clipper above with the word FlagShip, and the word DOS with Unix.

FlagShip produces C code. Do I need C knowledge?

No! FlagShip actually is three things:
  1. A Compiler/Translator that Creates "C" Code from Clipper Code.
  2. A Powerful Set of Clipper/Xbase libraries and Utilities for Unix.
  3. A Run-Time system embedded in the produced Executable for the fully support of dynamically scoped variables, Macros, code blocks etc.
FlagShip calls the Unix "C" Compiler and linker FOR YOU, and creates a true binary executable from your code together with the libraries we deliver. You can ask FlagShip to do both steps from one command, so you can use FlagShip just like Clipper, and you never have to know anything about "C" code if you do not want to. However: If you know "C" you can use it together with FlagShip in many ways:
  1. FlagShip allows you to link in external "C" programs and utilities by emulating Clipper's extend system.
  2. FlagShip allows Inline "C" code with the Pre-Compiler statements #Cinline and #endCinline. This means you can use "C" without having to modify produced "C" Code, and worry about losing changes to it should you recompile. Use FlagShip/Clipper code for it's power, elegance, and efficiency, and "C" only where Clipper falls Short of the power you need.
  3. Open "C" Interface. This allows you to call FlagShip's Utilities, and Data Engine from your own "C" code, and use FlagShip as an extremely powerful set of libraries for your "C" or "C++" code.
  4. Use FlagShip as a Clipper to "C" Converter, and then continue working in "C" using FlagShip's libraries. Due to the effectiveness of the previous methods, please think long and hard about the pros and cons of this method before using it. FlagShip language (a superset of xBase and Clipper) is much faster to develop in, and much easier to keep Bug Free than "C" code.

Can't I simply use the FlagShip produced C code on DOS or other systems?

Sure, you can copy it there, but it won't do you any good. To be as complete a language as FlagShip is, it has to make extensive use of hooks into the operating system, and the operating system's libraries. Since FlagShip is designed for Unix, (about 50 of them), it cannot currently fit into the memory management and file system needs of DOS, or the very different operating system interfaces of VMS, OS/2 and others.

Is FlagShip a porting tool only?

Does FlagShip install and run on DOS and then create file which I move to run on a Unix Machine?

No! FlagShip is a true Development System including a Language and Database for Unix. It installs on the Unix System. The Clipper compatibility, and FlagShip's use as a porting tool for Clipper code is actually a side effect of what it really is; a high-powered Programming Language & Database Development System for use on Unix.

FlagShip code that you have created on one Unix System can be moved and compiled by FlagShip on any other Unix system without changes, so long as you have the FlagShip libraries for the target system.

So FlagShip is not a porting tool, but it can certainly be used as one!

Do you have a DOS version of FlagShip?

FlagShip installs on Unix, not DOS. CA/Clipper is considered to be our DOS version, so if you need FlagShip for DOS, buy CA/Clipper 5.x from Computer Associates.

Isn't it better to use OS/2, or NT?

A special FlagShip version for native Win32 (i.e. for Windows-NT 4, Windows-95,98 and Windows-2000) will be available soon (in 2000). It will fully support the Windows GUI interface without additional programmer's work, i.e. the usual Clipper code will run graphically in the Windows look & feel.

Right now, everything that these operating systems claim to bring to the world have been standard features of Unix for years; Unix is stable as a rock. I would not bet my future on an unproved environment for lack of knowing what the alternatives are.

What these operating systems have going for them is only big advertising bucks, and press attention. If Unix vendors were to pull together on common advertising campaigns, these products would be totally dwarfed. In fact Bill Gates recently said in a public address at a major trade show, that NT WILL BE (Get the future tense here) a better Unix than Unix. Then he listed various things that NT is going to have, that Unix already does....

Also IDC (International Data Corp) states that nearly 95% of the World's business is transacted on Unix machines, and that there are still more seats (people using) Unix than ANY other operating system, including DOS/Windows. Yes, there are less Unix Machines than DOS PCs, but that is an unfair comparison. The number of users supported is a better apples to apples comparison.

IBM, pushing the RS/6000 with their new version of Unix (AIX), is advertising that OS/2 is going to have a Mach Kernel (one form of Unix). Their deal with Apple for PINK (The object oriented operating system) is based on putting the Apple interface onto the Unix operating system. NEXT STEP is the Unix operating system with a Mach Kernel and a nice object oriented User Interface. Solaris from Sun is also true Unix. I, for one, think that the Future is in Unix (or what it becomes). If you use any version, you need learn only a few minor things to use another version. A FlagShip developed product can be ported very quickly and made available easily on virtually any Unix based system. Simply buy an additional development library, copy your code, and compile.

There is no hardware vendor we know of, which does not already sell Unix, or hardware on which Unix will run. The dreams of scalability that Microsoft and IBM tout already exist. The "Binary Compatibility Daydream" cannot exist even under NT, except where the processor type used on each system is the same. Unix already is criticized for this. In NT, the implementation and therefore the criticism are yet to come. And the story goes on. Please refer to other parts of this document for more details.

Throughout the world, there may be as many users, if not more, connected to Unix systems than there are users of DOS machines. OS/2 and NT have an uphill battle to overcome Unix's lead in the Server market.

Can I use Windows on Unix?

Unix has X-Windows and Motif, which is a graphical operating environment which most users cannot tell from Microsoft Windows (one reason why people using Unix systems think they are using MS-Windows). It can be displaying on one machine while the actual program runs on another (another form of Client/Server, for display rather than data).

Moreover, Unix can be the File Server for PCs running Microsoft Windows. You can simultaneously have a Unix session with in a window on the PC. You can even run X-Windows applications within MS-Windows on a PC.

For that matter DOS emulators exist which run on Unix, and will allow the use of DOS or MS-Windows applications on Unix systems. Linux, SCO Open Desktop, UnixWare and others have this available automatically as a standard part of the operating system.

FlagShip runs in the X-Windows environment. Currently in text mode (e.g. without the proportional and scaleable typeset and mouse), but will use all the X-Windows features in upcoming releases.

What about Client/Server Data Access?

No Problem, simply put the Data Files/Engine on one Unix Box (Oracle, Informix, Sybase, FlagShip, others), and the applications on another Unix Box, or a PC networked to it. Viola! Client Server in its truest sense. See also Compatibility to other Data Engines.

You could also run the application and the data on a powerful Unix box, and simply have the PC (Even a lowly XT, or Cheap Terminal) share that power. Some applications make sense to have on a PC. Example of this are personal applications such as; a word processor, a spreadsheet, a drawing program, etc. Other applications which require high power, and multi-user simultaneous access to shared files make much more sense to have on the Server/High powered Unix box: Accounting, and most Database functions, or business processes requiring work to flow from one person to the next.

How can my PC work with Unix?

You can use it many ways:
  1. Use your PC to emulate a terminal using something such as Century Software's Tiny Term, or Term, Procomm, Telix, Ice-Ten and others, sharing applications running on the Unix System.
  2. Use your PC as a Network Node Sharing Files on the Unix System using Samba, Netcon, NetManage Chameleon, Lan Manager, PowerFusion, PC-Interface or a hundred others.
  3. Use your PC as an X-Windows terminal, doing graphical display for running Unix applications on the Unix System using Xwindows Server software such as NetManage Chameleon/X, Hummingbird, PC/X or many others.
  4. Use Your PC Client/Server style, with an application on the PC, requesting and storing data in a data engine on the Unix system.
  5. Load Unix on your PC instead of, or in addition to DOS or Windows.
Or Do all the above at the same time!!!

The Compatibility

FlagShip's File Compatibility to DOS?

FlagShip is fully compatible with .mem, .dbf, .dbt of Clipper, and also read and write .dbf, .dbt, and .mem files from the other xBase variants, such as FoxBase, FoxPro, dBase III, Dbase IV.

We and several Third Party suppliers are working on RDD (Replaceable Database Drivers) to provide complete and sharable compatibility with Clipper .ntx or Fox .cdx index files, and as well as the full file structures of the other xBase variants. Some additional RDDs are already available in the distribution (e.g. for CodeBase) or are downloadable for free (e.g. for SQL) from our ftp or Web server.

What about the Code Compatibility?

Very compatible with Clipper S87, Clipper 5.2, and Dbase III. Quite compatible with FoxBase, there are a few commands and functions that are not supported, with array syntax being the main one. FoxBase uses "()" for array syntax, where FlagShip and Clipper use "[]".

FoxKit is available, and has a processor that will convert the array and other syntax in the source code. It also adds more complete Fox compatibility to FlagShip with additional commands and functions from FoxBase. Same as with FoxPro, the FoxBase toolkit and/or the stdfoxpro.fh file may be used for additional compatibility.


Although there is a large amount of code compatibility already, we do not yet support compound Indexes, popups, menu commands and other "Developer tools" that FoxPro has added to FoxBase. A general FoxPro and FoxBase compatibility is supported by the preprocessor file stdfoxpro.fh, which can simply be included in the application or in the std.fh used by the FlagShip preprocessor. Additional tools (foxkit and fxpro) are available for a free download (check now).

Dbase IV

Although there is a large amount of code compatibility already, we do not yet support compound Indexes, popups, menu commands and other "Developer tools" that dBaseIV has added to dBaseIII+. A compatibility kit is being considered.


Recital is a collage of all other xBase variants, plus a number of changes and additions of their own. For any particular xBase statement they may have used any other xBase vendor's definition (Fox, Dbase, Clipper) or their own. Recital therefore can be VERY difficult to use as a porting tool. FlagShip strictly follows what we feel is the best xBase language implementation, Clipper 5.X, and will provide external kits to add to FlagShip when other xBase variants behavior is desired. We are considering a kit to implement Recital's extensions, but it is not a particularly high priority. If you think otherwise, please let us know.

FlagShip and Clipper are such flexible and stable object oriented products, that other xBase variants can be largely emulated by them, simply by defining new commands and functions. This is how our compatibility kits will be largely implemented.

What about the Compatibility to other Data Engines?

You can use the Oracle, Informix, Sybase, and other engines right now, by using the company's ESQL/C interfaces, and linking them via FlagShip's Inline C code, or the Extend C or Open C API System.

Typically Informix (and other) 4GL Tools work by issuing an SQL request for data, which is then retrieved into an array within which it is manipulated. When finished, the changes are flushed back into the database with another SQL command.

With FlagShip you simply write a routine (UDF or User Defined Function) to call the database engine vendor's ESQL/C access library. This library call can fetch data into an array, or .dbf file. Then operate on the data with your code, followed by a flush with another function when finished.

Nevertheless, add-on software, FlagShip's RDDs (Replaceable Database Drivers) will be soon included as separately purchasable kits for FlagShip in order to integrate this capability directly into the FlagShip development system. The result will be that using other database engines will be as easy as using .dbf's. Visit the FlagShip's Web site (RDDs or Tools), some of the SQL drivers are already available there for free.

What about a DOS version of FlagShip?

Converting Clipper to "C" on a DOS platform looks mighty attractive to me?

Not for 16-bit systems! When you take into account all the pros and cons, this no longer looks anywhere near as attractive as it does at first thought. DOS has such memory limitations that it is not practical to do such a thing. There are other products that do portions of this task, such as X2c, CodeBase, or Force, among others. But due to the memory limitations they are nowhere as complete a product as FlagShip. It is like comparing a Ford Pinto to a Cadillac.

True Executable code is almost always larger than Psuedo code with an embedded interpreter such as Clipper is. Our executables are about three times the size on the average as Clipper's. Even the smaller Clipper executable has terrible problems with memory management, and we are not willing to play those games. Not when we can give you something much better.

The idea of FlagShip is to allow the language that makes you productive, to let you work in Unix with very little additional knowledge. All this in an environment that also will add to rather than detract from your productivity. DOS will be around for a long time. We consider CA/Clipper to be our DOS version, while FlagShip is the Unix version.

Put away the fear. Do a little investigating on your own of the advantages Unix brings to you, advantages you have probably already thought of and wanted but not known where to find. Or check for the native FlagShip port to 32bit MS-Window systems.

Can I maintain Common Source Code for Unix and DOS?

Yes! You may have common FlagShip and Clipper sources.

FlagShip has a number of features which make it very easy to write code that is easily copied back to DOS and compiled with Clipper, or for that matter maintained on a common network file system available to both DOS and Unix.

Compile ONE version of code with Clipper for DOS executables, or with FlagShip for Unix executables...

FlagShip Licensing

Does FlagShip need runtime Licenses?


FlagShip is licensed for the developer only, similar to the way Clipper is. You may compile as many applications as you like and sell as many copies of your executables as you will and can.

What kinds of Licenses does FlagShip offer?

We have two license levels:
  1. FlagShip Personal license. For creating two user utilities, two user programs, and working with programs on a system where the FlagShip Personal compiler actually resides. It is fine for producing programs that do not need to support more than 2 users at a time on a single machine. Developers often buy the Personal license to start a project, and prove the concept for a client.
  2. FlagShip Pro Unlimited User license. For full deployment of an unlimited user application. Will support as many simultaneous users as the Hardware, and Operating System can handle. This is the license that we ultimately think everyone will want. It also includes the right for the programmer to distribute the created binary programs to any binary compatible system at no extra charge. No royalty or runtime is needed.
Upgrading from one license to the next level is always encouraged by giving almost complete credit for the price already paid at the previous license level.

Upgrades to newer versions are always a percentage of the list price of the new version at the same license level you already own.

Do I need to buy FlagShip for each UNIX platform?

Do I have to port to each one individually?

Sort of, and No!!!

Since there are many different versions of Unix running on many machines with differing processor types, we have to produce and test FlagShip on each of them. If you have your product working with FlagShip on one machine, you do not need to make any changes to your code to use it on another type of machine. You will already know, and have everything you need to move from one system to the next. FlagShip insulates you from most details that might differ between versions.

You do however need to have a FlagShip for each type of Machine you support, and each machine on which you do development work. This is because a binary created on one will not work on another. There are two ways to accomplish this.

  1. Another FlagShip PRO license is heavily discounted to existing owners of FlagShip unlimited licenses. This allows you to move the FlagShip or Clipper code to the other machine, compile to create the executable binary, and run.
  2. When the other system is used internally be few users only, you may purchase the economic Personal license for this Unix system.


You have a FlagShip for SCO Unix, and you have created a program. You have a client with another SCO Unix system who wants the program. You simply copy the executable code, and some terminal configuration files to his system, and collect his money. Then you have a client that has an HP/9000 and wants to run it on his system.

If you move the produced binary/executable code to the HP, it will not work. You therefore add to the client's bill, or pay for yourself, another heavily discounted FlagShip, copy the Clipper or FlagShip Source Code or the "C" Code, and tell FlagShip to compile. Then collect the customers money and move on. If someone then wants your program on an RS/6000, it is the same story as the HP, and SUN, and Data General, and so on. As soon as you have created the executable code for another platform, you may then sell that code to as many people owning the same platform as you like without restrictions.

Be aware that you may sell less copies of your software for Unix than for DOS, but you can charge substantially more money for your program running on a Unix system than on a DOS or Network system.

What UNIX versions does FlagShip currently support?

All the major ones:

SCO, IBM, SUN, AT&T, HP, Data General, Motorola, Unisys, NCR, UnixWare, Linux, Silicon Graphics and many others. See our FTP site, or Contact us for a current version of the Porting list containing more than 50 systems.

What about Unix versions or other operating systems that you do not currently support?

We are considering NetBSD, FreeBSD, BSDI, QNX, Coherent and many other variants that we do not yet support, in most cases we have tried to port to them, and found them to either not be complete enough, or stable enough or incompatible to SystemV/Posix. We are continuing to work with their manufacturers to help them solve issues we find and will be releasing FlagShip for them as we are able.

But the *BSD Unix varaints have Linux binary compatibility box, so you may compile the application on Linux and execute it freely on NetBSD, FreeBSD etc.

In addition, if you own a particular special Unix system not on our porting list, we may be able to port to it under an individual contract with you.

Running the Application

How big of an executable can I use?

Theoretically up to 2 Gigabytes! UNIX, unlike DOS handles programs in memory different ways.
  1. virtual memory (RAM usage, swapping, paging)
  2. shared code (several instances of the same application running concurrently share the same text segment in memory)
Unix can act like it has much more memory than it really does via #1 above. FlagShip can take advantage of this, and also of #2. In #2, which is a Unix mechanism, the executable is loaded into RAM only once, and then when another user invokes it, Unix recognizes that it already has a copy in memory, and shares the text (Non Variable) portion of all the code. Additional memory is only used for the data segments (variables, environment, etc.) which is specific to the individual user and session.

How large do FlagShip's executables get?

Depending on the kind of linking (statically vs. dynamically), FlagShip's executables may get quite large, approximately 2-3 times the size of the equivalent Clipper executables (when statically linked). This is because of the native 32-bit (or 64-bit) code compared to the 16-bit P-Code produced by Clipper. But it does not matter because of the way that Unix handles memory. Up to 2 Gigabyte executables may be used if your system is correctly configured. You may also use dynamic libraries on systems where this is supported to drastically reduce the memory used. Also bear in mind that du to the way Unix manages memory, for each person that uses another copy of the program, only additional data space is used, and another full copy of the program is NOT copied into memory. However, dynamically linked executables are much smaller, typically some hundreds KB only. Dynamically linked applications shares common libraries (*.so), similarly to *.DLLs in Windows.

The size of the executable depends on the assembler translation produced from C for the target processor. A RISC processor always produces significantly larger code than a CISC (the program of 1.5 MB on SCO may reach 7.5 MB on DEC).

In the FlagShip library there are more than 400 standard functions available for the user (from the sum of more than 900). That's much more, then in any other standard xBase library. The portions of the FlagShip library actually used are linked into the executable. This includes the limited interpreter module necessary for dynamic support of the xBase language and the UNIX system, such as:

The size of the EXECUTABLE is not significantly increased by the FlagShip library, but is mostly the application itself plus the standard UNIX libraries (like curses, std C libraries etc.). In a mid-size application, the percentage of space used by FlagShip library modules is only about 10%the total size. In the DATA segment, additional tables holding the information for dynamically scoped variables have to be maintained at runtime and are also stored in the executable.

How fast is FlagShip?

FlagShip runs about 2 to 100 times faster than Clipper on an equivalent hardware platform. See benchmarks later in this document. The Language itself is also substantially faster than any other xBase language on Unix.

The Application Speed on UNIX

In most performance tests, FlagShip is much faster than Clipper (on equivalent hardware) on the average 2 to 8 times, but up to 20-100 times faster when using typed variables (see LNG.2.6.1 and CMD.LOCAL...AS).

I have heard that FlagShip is actually quite slow, could this have to do with configuration?

Yes!!! Some users have reported in a few cases that FlagShip is only 20% of the Clipper's speed. This is impossible, if the system is set up properly.

Macros, Runtime Variable typing, and Runtime Code block evaluation tend to slow any application down. These issues are frequently overlooked in comparisons of FS produced code to C code, or CodeBase code, neither of which have these capabilities.

If these capabilities are not used in FlagShip, then our code does not pay the speed price either.

Users reporting speed problems are almost always older SUN Sparc, or especially IBM AIX owners that have been sold on unrealistic expectations of the machine they own and also of the Intel Boxes they have spurned.

On database and index access, faster access is always observed if Unix I/O speeds are equivalent to the DOS machine, and if the hardware is not otherwise too loaded. The only difference is the Clipper database and index access in single user mode, where the Clipper uses RAM only (does not r/w on the disk !!!) This is not possible in the same manner on Unix. In SHARED mode, FS is also faster than Clipper. In order to be a fair comparison, make sure Clipper has the files open in SHARED MODE.

Benchmark results

All times in seconds.
The speed difference <faster> is calculated by: Clipper (sec) / FlagShip (sec)

Source: bench1.prg (primes, Sieve of Erotosthenes)

Guideline values for identical hardware

a) 80486DX50, 16MB, DOS5 vs. SCO UNIX:     Clipper 5.2  FlagShip 4.3 =  faster

1. numer.calculation,   200 interations       4.78 sec    0.92 sec   =   5.2 x
2. string manipulation, 200 interations      41.19 sec    1.91 sec   =  21.5 x
3. num.calc, C-inline,  200 interations       4.78 sec    0.04 sec   = 119.5 x

b) PP200, 64MB, Win-NT4 vs. Linux or SCO:  Clipper 5.3  FlagShip 4.4 =  faster

1. numer.calculation,   500 interations       9.61 sec    1.27 sec   =   7.6 x
2. string manipulation, 500 interations      76.35 sec    2.51 sec   =  30.4 x
3. num.calc, C-inline,  500 interations       9.61 sec    0.07 sec   = 137.2 x

Source: bench2.prg (calculations, database)

Guideline values for identical hardware (PP200, 64MB)
Clipper 5.3 on DOS/WinNT+Novell vs. FlagShip 4.42       Clipper   FS  = faster

Empty loop     200,000 x .............................  1.37 vs. 0.03 = 45.7 x
Addition       200,000 x integer .....................  1.71 vs. 0.48 =  3.6 x
Addition       200,000 x typed int ...................  1.70 vs. 0.06 = 28.3 x
Increment      200,000 x integer .....................  1.65 vs. 0.46 =  3.6 x
Increment      200,000 x typed int ...................  1.65 vs. 0.05 = 33.0 x
Multiplication 200,000 x integer .....................  2.53 vs. 0.37 =  6.8 x
Multiplication 200,000 x typed int ...................  2.52 vs. 0.09 = 28.0 x
Multiplication 200,000 x float .......................  2.31 vs. 0.33 =  7.0 x
Multiplication 200,000 x typed float .................  2.31 vs. 0.09 = 25.7 x
Division       200,000 x float .......................  2.31 vs. 0.37 =  6.2 x
Division       200,000 x typed float .................  2.37 vs. 0.11 = 21.5 x

Create database ......................................  0.05 vs. 0.04 =  1.3 x
Append     10000 records, exclusive ..................  1.49 vs. 0.35 =  4.3 x
Append     10000 records, shared ..................... 57.61 vs. 1.76 = 32.7 x
Replace 2x 10000 records, shared ..................... 34.06 vs. 7.24 =  4.7 x
Index      10000 records on character ................  8.91 vs. 1.95 =  4.6 x
Index      10000 records on number ...................  8.52 vs. 1.96 =  4.3 x
Seek       1000x shared on character .................  2.70 vs. 0.46 =  5.9 x
Seek       1000x shared on numeric ...................  2.64 vs. 0.43 =  6.1 x
Replace 2x 1000x records, shared w.2 indices ......... 12.68 vs. 0.98 = 12.9 x
Replace 2x 1000x records, shared w.2 ind. & DbCommit() 17.91 vs. 1.09 = 16.4 x
Replace 2x 1000x records, shared w.2 ind. & COMMIT ... 17.96 vs. 5.41 =  3.3 x
Append     1000x records, shared w.2 indices ......... 17.35 vs. 0.51 = 34.0 x
Append     1000x records, shared w.2 ind. & SKIP 0 ... 17.35 vs. 0.71 = 24.4 x
Append     1000x records, shared w.2 ind. & DbCommit() 22.74 vs. 0.71 = 32.0 x

Your results may differ according to the processor and operating system used, try it by yourself by recompiling the sources available in the ftp://flagship.de/pub/multisoft/flagship/docu/bench-src.tar  file or accessable via Web by the "Docu" button in  http://www.flagship.deThe speed on Unix workstations may even be significantly faster.

Why is the screen output slower than on DOS?

The only speed disadvantage on UNIX is with screen output. Clipper writes directly to the video RAM, FlagShip cannot due to the multi-user nature of UNIX and the probable usage of remote terminals. FlagShip uses curses instead. Curses does screen mapping, and allows for many different users using same executable to be using many different types of Terminals at the same time.. The speed is comparable with Clipper's when linking in ANSI.OBJ with ANSI.SYS. To be a fair comparison, force Clipper to use the ANSI.SYS screen driver which is also a simple screen mapping utility.

RISC, CISC or Workstations?

The processor architecture (RISC or CISC) is not the only criteria for the execution speed. The clock speed, available RAM, bus architecture, disk controller, disk cache, size of executables and many other factors results in the overall execution speed.

Many workstations from Sun, HP, DEC, Motorola, Silicon Graphics, Sequent etc. may be SIGNIFICANTLY faster than a 486 processor, but may not be. It depends on the manufacturer model used (the CPU and clock speed), and the task being performed. Some RISC hardware may run noticeably slower, than a 486/50 or Pentium CPU. Linux for instance performs startlingly well on all platforms we have used it with. The Intel chips are a lot more powerful than they seem when handicapped by DOS, or MS-Windows.

How can I increase the speed?

  1. Increase the amount of available RAM memory.
  2. Check the Kernel tuning for the amount of disk cache (disk buffers) configured, because if data is in the Cache, it needn't be pulled off the disk (Bigger is better).
  3. Use faster I/O devices, and intelligent or caching controllers.
  4. Write more efficient code using e.g. TYPED variables instead of LOCAL, Code-Blocks instead of Macros or "filtered" indices instead of SET FILTER.
  5. Consider the effect of any other load that the machine may have to simultaneously support.
  6. Use file systems that implement RAID (Redundant array of inexpensive drives) techniques, especially striping, and redundancy. This not only provides much better data security, but since all disk drives may retrieve at once their piece of any file which is spread out over more than one drive, you can end up with far faster retrieve times than a single disk drive.
Check also:
  1. Does the machine have enough physical RAM to run all its processes or does to have to do virtual memory swapping? Add memory, and Increase swap space.
  2. Is the hard disk over 75% used? If so, things will slow down, Reduce Usage of Hard drive.
  3. For a large database replacement, use DBCOMMIT() instead of COMMIT or DBCOMMITALL(), since the first works asynchronously while the other two synchronously.
  4. Check the hints in the FlagShip manual to speed-up your application.

How does FlagShip's speed compare to Clipper?

Benchmarks running on THE SAME EXACT hardware 80486/DX50 shows, that: Since in some countries it is not allowed by law to publish benchmark results, we will send you the sources on request, and/or results if your country's law allows.

Third Party Libraries

Does FlagShip support 3rd party libraries?

Because of the difference in operating systems and hardware, the object libraries written for DOS cannot be used directly in UNIX. This is similar to the impossibility of running DOS object files directly on Apple etc.

You have to either recompile the sources on the target UNIX system, or purchase the special UNIX release of the third party library.

What to do if I use 3rd party libraries?

I have used a ton of third party libraries. Isn't this going to stop me from moving my programs to Unix with FlagShip?

Probably not!!

The easiest way is, when you own the source code of the library (Clipper, xBase, C)is to recompile it with FlagShip (see also paragraph 10 below) - and it is ready for your UNIX application!

We have ported a number of programs that used third party libraries to Unix. These are the steps we have found practical.

  1. Call the third party library manufacturer to see when they will have a FlagShip Unix version, if they do not already. Some do, and more are working on them. The more calls like this they get the more likely they are to do the job.
  2. If they do have a FlagShip version, buy it. If not, insist that you want it, and tell them that the FlagShip manufacturer and distributors are helping third party People port their products under acceptable terms. The FlagShip distributor network will help with both porting and marketing of the converted product to our existing and potential user base.
  3. Call your FlagShip distributor and give him the name of the manufacturer, and what they said. We maintain a list of who is and is not moving to Unix with us. We continually encourage those who have not yet done so.

  4. If the above does not work, you still have not lost anything, it will just take a little more work.
    At first thought, it seems like you have to have all those fancy third party libraries to move your Clipper program to Unix. But this is only partially true. We have ported a number of applications that used third party libraries, without having the libraries for Unix. Here are some more steps we take in this case.
  5. Compile the Code with FlagShip. It will not link, but it will tell you what the missing symbols are when it tries to link. Create a dummy UDF (User Defined Functions) for each of the missing functions. These UDF's should initially contain nothing useful, usually just an @Say or ? Function XXX, telling which UDF you've hit when running the code, and a RETURN statement. It will however serve to fool the linker into thinking that the missing function in fact exists. Link again, it may now find more missing functions, again add UDF's, and continue this cycle until your entire program compiles, and links (An executable is created).
  6. You now have with your UDF's a complete list of all third party functions that you used. Look each of them up, and know what they do. Most people own many libraries, and thousands of functions. Very few people however use more than a handful of those functions.
  7. Is xBase source available for these functions from the third party vendor? If so, no problem. Put the appropriate source in the UDFs. Grumpfish works, as do other Clipper Source third party libraries.
  8. Look at Clipper Tools (You got it with your 5.2 upgrade didn't you?) to find out if those functions have equivalents there (many do). If they are there, order a copy of FS2 Tools which is compatible to Clipper Tools in the same way that FlagShip is compatible to Clipper. This includes many string and numeric manipulations, Windowing, Serial Interface utilities and much more. Then insert the FS-Tools function into the UDF in place of the print statement. Sometime a minor translation of input or output data types or parameters may be needed as well.
  9. Look at the CompuServe NanForum library (or The Oasis), and if what you need is there, download it.
  10. The function may simply be something cosmetic that can easily be abandoned, and will not materially affect your program by being missing. If so, abandon it.

  11. Most people have their third party issues covered already by the time they get to this stage in the process.... however there are a few more, and they get a little more difficult at this point.
  12. If the third party function is written in "C" and source code is available, it MAY be easy to use it in Unix. What makes the difference is whether or not they use DOS Specific "C" extensions and/or hardware dependencies, such as Video Memory, I/O Addresses, BIOS Calls and other such issues. These would have to be fixed before it could be expected to work on Unix.
  13. If the third party function is written in Assembler, whether source is available or not, or in "C", but the source is not available, and one of the above steps does not resolve the issue, then it becomes more difficult.

  14. However all is not lost. Since very few issues get to this stage, all FlagShip distributors are willing to help.
  15. Forward a copy of the manual pages for the functions you must have, and we will quote a price to reproduce this function for you, providing we cannot get the third party vendor's co-operation in porting their function.

Which additional libraries do you have?

I have heard that you have a toolkit of Functions that is equivalent to Clipper Tools. What Functions does it contain?

The FS2 Toolbox for FlagShip is call-compatible to Clipper Tools, formerly the NT2.LIB (CA/Nantucket) and is available for the same range of operating systems as FlagShip. See also the list of additional tools on http://www.flagship.de/tools.html and http://www.flagship.de/rdds.html  for replaceable database drives (RDDs).

Back to FlagShip home page