WHAT IS DCLIP........A brief description of the dCLIP Engine
DBMS.................The dCLIP Database Management System
DOT-PROMPT...........The Dot-Prompt Interpreter
TURBO ASSISTANT......The Menu-Driven Turbo Assistant
IDE SYSTEM...........A Clipper Integrated Development Environment
TURBO-EDITOR.........Using the Turbo-Editor to quick-test UDF's
EDITING..............Editing your Source Code
COMPILING............Compiling your Source code
DEVELOPMENT..........Developing and debugging applications with a dCLIP engine
WHAT IS DCLIP
A brief description of the dCLIP Engine
Description:
A dCLIP Engine is an .EXEcutable program which allows a Clipper
developer or end-user to use all Clipper-compatible commands
and functions, third-party commands and functions, RDD commands
and functions, or custom end-user commands and functions in an
"interactive" or "live" environment.
By combining the features of an interpreter, pre-processor, and
dynamic-linker, dCLIP provides for development and debugging of
Clipper applications "without linking". A dCLIP engine is
simply a Clipper application built from the following
libraries:
1. Clipper Libraries
CLIPPER.LIB, EXTEND.LIB, TERMINAL.LIB, DBFNTX.LIB, etc.
2. dCLIP Libraries
DCLIP.LIB, DCLIPNL.LIB, DCLIPR.LIB, DCLIPS.LIB
3. Third-Party Libraries
Any Clipper-compatible library developed in C, ASM or
Clipper.
4. End-User Libraries
Any set of .OBJ files and/or libraries that are compatible
with Clipper.
All functions from the DCLIP.LIB library are linked into the
engine thereby providing the following features:
a. Dot-prompt interpreter
b. Turbo-Assistant
c. Database Assistant
d. Dynamic-Linker
e. Pre-Processor
f. Multi-Window Database browsing and editing
g. Clipper tutorial system
h. Clipper-code Debugging
DBMS
The dCLIP Database Management System
Description:
dCLIP is a complete DBMS system that provides the ability
create and edit any database file that is supported by the
Clipper Replaceable Data Driver (RDD) system and any third-
party data driver.
Database editing and reporting is accomplished either by
dot-prompt commands or an integrated menu system.
The dot-prompt supports DBMS commands like USE, MODIFY
STRUCTURE, INDEX ON, REPORT FORM, EDIT, BROWSE, REPLACE,
etc. This includes all DBMS commands supported by Clipper,
many more new dCLIP unique commands like HUNT, PURGE, etc.,
and any DBMS commands supported by third-party products
such as USE SQL, etc.
All menu-driven DBMS features of dCLIP can be accessed via
the Database Assistant which is invoked by the ASSIST
command from the dot-prompt or START=ASSIST in the
DCLIP.SYS file.
The Assistant pull-down menus access the Work system for
saving and restoring work areas and browse/edit screens,
the Browse/Editing system for quick editing of data,
Database Utilities, Printer Manager, Report Editor and
Manager, DOS Gateway, etc.
DOT-PROMPT
The Dot-Prompt Interpreter
Description:
The dCLIP engine starts-up at a "Dot-Prompt" indicating that
dCLIP is waiting for you to enter a command.
When you enter COMMANDS from the dot prompt they are passed
through the interactive pre-processor and converted to
expressions that are evaluated with the Clipper runtime
macro-compiler. All Clipper and third-party functions that are
linked into the engine will be "resident" in memory so they
will be executed when they are macro-compiled. The dCLIP dot
prompt is fully-interactive, meaning that you get an instant
response to the command at the moment you enter it from the
keyboard.
Any function that is not in the engine or has not been loaded
into memory (dynamically-linked) will generate an "undefined
function" error if it is called from dCLIP.
If you like working from a command-line, then the DOT-PROMPT is
the starting place or "home" for just about everything you need
to do in dCLIP. You can run any other executable program
(regardless of size), run any DOS command, run any Clipper or
dCLIP command, run any Clipper function or UDF, execute any
batch file, edit source files, even compile and run object code
without ever leaving the interactive environment of the dot
prompt. When you run an application program, you will return
to the DOT. When you run another executable program such as
your own editor, word-processor, spread-sheet, calendar, etc.
you will return to the DOT. When you compile your source code,
you will return to the DOT.
See Also:
DOT PROMPT
TURBO ASSISTANT
The Menu-Driven Turbo Assistant
Description:
The "Turbo-Assistant" is a set of menus that provides a simpler
user-interface to handle some of the smaller Clipper
development and database management tasks. Due to the fact
that menu-driven systems are always limited to the number of
items that can be included in an integrated menu system, it is
recommended that you become familiar with the dCLIP dot-prompt
command set to get the most power from dCLIP. A complete
function reference is provided to allow you to create your own
menu-driven development environment in the event that you are
not satisified with the features provided in the Turbo-
Assistant menus.
The Turbo-Assistant recognizes both keyboard input and mouse
input and is invoked by several methods:
1. Enter the command TURBO at the dot-prompt.
2. Use the DC_TURBO() function.
3. Enter the command START=TURBO in your DCLIP.SYS
configuration file.
If you grew up with any of the Turbo languages such as
Borland's Turbo-Basic or Turbo-Pascal and graduated to Clipper,
you will find yourself in familiar territory when you select
use the Turbo-Assistant feature of dCLIP.
If you like working from a "menu", then the Turbo-Menu is the
starting place or ~g"home"~h for just about everything you need
to do in dCLIP. You can run any other executable program
(regardless of size), run any DOS command, run any Clipper or
dCLIP command, run any Clipper function or UDF, execute any
batch file, edit source files, even compile and run object code
without ever leaving the pull-down menu system. When you run
an application program, you will return to the MENU. When you
run another executable program such as your own editor,
word-processor, spread-sheet, calendar, etc. you will return to
the MENU. When you compile your source code, you will return
to the MENU. You can run and debug your programs or even
invoke the "dot-prompt" for command- line operations and then
return to the MENU.
See Also:
OVERVIEW
IDE SYSTEM
A Clipper Integrated Development Environment
Description:
An Integrated Development Environment (IDE) for Clipper is
simply an integration of functions from Clipper libraries,
dCLIP libraries, third-party libraries, and user-created
libraries/objects to allow development of Clipper applications
much faster than by conventional methods, i.e. the standard
Edit-Compile-Link cycle.
The dCLIP IDE system is NOT an application generator and does
not automatically write any Clipper code nor is it a
data-dictionary system. The IDE tools provided in the dCLIP
libraries are meant to give to Clipper many of the features
provided in other xBASE languages such as dBASE, FoxPro, and
Arago/dBXL. In order to accomplish this task, the dCLIP engine
provides commands and menus that allow development tasks to be
accomplished in a "live" application rather than requiring that
the program be quit, re-built and re-run to perform the
debugging.
This is accomplished as follows:
1. Gateway
The "gateway" system provides the means to call your
third-party editor, the Clipper-compiler, or any other DOS
program from anywhere within your application and edit and
recompile code without quitting the application.
2. Dynamic-Linker
The "dynamic-link" system provides the means to link
Clipper-compiled .OBJ files "on-the-fly", even "overwrite"
functions that were linked into the .EXEcutable program.
3. Dot-Prompt Interpreter
The Dot-prompt and interactive pre-processor allow commands and
expressions to be instantly evaluated without editing,
compiling or linking.
TURBO-EDITOR
Using the Turbo-Editor to quick-test UDF's
Description:
The "Turbo-Editor" mode can be invoked by selecting the TURBO
EDIT-COMPILE-DO option (.PRG mode) / EDIT-RUN option (.DCB
mode) from the RUN menu of the Turbo-Assistant or by using
the / command at the dot prompt.
EDIT-COMPILE-LINK-RUN (*.PRG) files
An automatic EDIT-COMPILE-LINK-RUN sequence on any .PRG file
that has been pre-defined as the Turbo file with the
SLASH=(cTurboFile).PRG command in your DCLIP.SYS file or the
SET SLASH TO (cTurboFile) command at the dot prompt will be
invoked. If no file name has been pre-designated with the
SLASH option, then DC_CLIP.PRG is the default file name.
EDIT-RUN (*.DCB) files
An automatic EDIT-RUN sequence on any .DCB file that has been
pre-defined as the Turbo file with the SLASH=(cTurboFile).DCB
command in your DCLIP.SYS file or the SET SLASH TO
(cTurboFile).DCB command at the dot prompt will be invoked.
The source-code editor which is desired to be used as the
"Turbo-Editor" is defined with the TURBO=(options) command in
your DCLIP.SYS file or the SET TURBO TO (options) command at
the dot-prompt. If no external editor has been defined then
the internal editor will be used.
Entering the dot-prompt command:
. / (enter)
or
. /(file).PRG
will invoke the following sequence of EDIT-COMPILE-DO events:
a. The (cTurboFile).PRG file pre-designated with the SLASH
option or (file).PRG will be opened by your turbo-editor for
editing. Enter your commands and functions in the file as
you would write any Clipper function or procedure, then save
the file and quit from your editor.
b. The program file will be compiled into (cTurboFile).OBJ
with the Clipper compiler. If any compile errors occur,
you will be returned into your editor on the first line of
code that experiences compile errors.
c. The (cTurboFile).OBJ file will be "dynamic-linked" into
memory. If a previous version already exists in memory it
will be overwritten.
d. The function (cTurboFile)() will be automatically executed.
NOTE: If you include the /n switch as part of your compiler
options with the CLIPOPT=(options) command in your
DCLIP.SYS file, then you must have a starting function or
procedure in your .PRG file with the same name as the
.PRG file.
Example:
* TEST.PRG
FUNCTION test
Entering the dot-prompt command:
. / (enter)
or
. /(file).DCB
will invoke the following sequence of EDIT-RUN events:
a. The (cTurboFile).DCB file pre-designated with the SLASH
option or (file).DCB will be opened by your turbo-editor
for editing. Enter commands and functions in the file as
you would use them at the dot-prompt, then save the file
and quit from the editor.
e. The .DCB file will be automatically executed.
See Also:
TURBO =
dc_turbedit()
/
EDITING
Editing your Source Code
Description:
The dCLIP gateway system allows you to edit your source code
without quitting your "live" .EXEcutable Clipper program or the
dCLIP engine program.
dCLIP includes an editor which can be invoked by several
methods or you can use your own editor.
USING the dCLIP EDITOR
The dCLIP editor is functionally equivalent to the MEMOEDIT()
function of Clipper except there are row and column counters,
a help screen, and selections to block text for cut and paste,
insert text from a file or memory, or save text to a file or
memory. If you do not configure dCLIP for using your own
editor with the EDIT=(options) command in DCLIP.SYS, then the
internal editor will be used.
You invoke the dCLIP editor in any of the following methods
from the dot prompt:
. MODIFY COMMAND (cSourceFile)
or
. EDIT (cSourceFile)
or
. EDIT FILE (cSourceFile)
The MODIFY COMMAND method is identical to dBASE and does not
require that you include the .PRG extension.
The EDIT or EDIT FILE method allows you to edit any ascii file
by entering the file name preceded by an optional drive and/or
directory name. In any case, if the file does not exist, it
will be created, if it already exists, it will be opened for
editing.
USING YOUR OWN EDITOR
You may invoke your own editor for modifying programs by any
of the following methods:
Let us assume that you like to use QEDIT, and are accustomed
to entering the command Q (enter) every time you want to
modify a program.
You can configure dCLIP to call QEDIT with a dot prompt
command by entering the following command in the DCLIP.SYS
file:
COMM=Q,Q2,128,E:
| | | |
| | | )) Swap memory to RAM DISK
| | )) Release 128K memory to run QEDIT
| )) Invoke Q2.BAT
)) Create a command titled Q
You can configure dCLIP to call QEDIT as the DEFAULT editor
when using the EDIT (file) or MODIFY COMMAND (file) commands
by entering the following command in your DCLIP.SYS file:
EDIT=Q2,128,E:
| | |
| | )) Swap memory to RAM DISK
| )) Release 128K memory to run QEDIT
)) Invoke Q2.BAT when the EDIT command is used.
or you can configure dCLIP temporarily by entering the
command:
. SET EDITOR TO Q2,128,E:
Then enter the following at the DOT:
. EDIT (file name) (line number)
or you can call QEDIT by entering the command:
. RUN Q2 (file name) (line number)
See Also:
EDIT PRG
dc_turbedit()
/
dc_editprg()
EDITOR =
COMPILING
Compiling your Source code
Description:
The dCLIP gateway system allows you to compile your source code
without quitting your "live" .EXEcutable Clipper program or the
dCLIP engine program.
After editing your source code files with the EDIT (file)
command you can invoke the Clipper compiler to compile the code
by using the CLIPPER command at the dot prompt:
You may use the CLIPPER command at any time from the dot prompt
provided that CLIPPER.EXE exists in your current DOS path or
you include a CLIPPATH=(directory) statement in your DCLIP.SYS
file.
SYNTAX: . CLIPper [ (module) | ALL] [/(options...]
Using the CLIPPER command followed by NO PARAMETERS will
automatically compile all changed .PRG files. This method
does NOT use any MAKE or RMAKE programs to accomplish the
compiling. Instead, the CLIP command compares the date and
time stamp on all .PRG programs to all .OBJ programs recompiles
all .PRG's with a date and/or time greater than the respective
.OBJ.
CLIPPER always calls the Clipper compiler with the /m option to
compile the .PRG's into separate .OBJ's.
OPTIONS : (module) - If a module name is entered, then only
the (module) will be compiled, otherwise all modules
which have been updated will be compiled.
ALL - If the ALL option is used, then ALL .PRG files
will be compiled regardless of the date and time.
/(option...) - If any compiler options are included
on the command line they will be passed on to the
compiler in addition to any options pre-defined in
your DCLIP.SYS file with the SET CLIPOPT=(options)
command.
See Also:
dc_turbedit()
dc_compile()
CLIPPER
DEVELOPMENT
Developing and debugging applications with a dCLIP engine
Description:
Developing and testing applications using a dCLIP engine can be
accomplished in many ways, however one of three (3) basic
methods are recommended depending on the complexity of the
desired task:
1. Evaluating expressions
Evaluating expressions that use functions linked into the
dCLIP.EXE engine are as simple as entering the expression at
the dot prompt as follows:
. ? (expression)
or
. nNumber := (expression)
Evaluating expressions that use functions which are in UDF's
that have not been linked into the dCLIP.EXE engine are the
same as above except that the .OBJ containing the UDF must
first be loaded into memory with the OBJ command as follows:
. OBJ (object file)
2. Running and debugging SMALL application programs
Very small applications that consist of several source code
files can be run by loading all the the compiled .OBJ files
into memory with the OBJ command at the dot prompt then
executing any public function within the set of .OBJs from the
dot prompt.
Example:
. OBJ MAIN
. OBJ MYFUNCS
. OBJ MENUS
. MAIN()
NOTE: You must make sure that you have sufficient memory to
load all the .OBJ's into the dynamic-link pool by allocating
the pool size with the SET CLIPPER=(memory) command before
running the dCLIP.EXE program.
3. Running and debugging LARGE application programs
Very large application programs that consist of many source
code files can be run by linking the application .OBJ's or
library into the dCLIP.EXE engine and then using the IDE
environment as a debugging system and "incremental-linking"
system.
This is accomplished by first including all your .OBJ files and
or .LIB files in the DCLIP3.BL (Blinker) or DCLIP3.RT (Rtlink)
link script file and re-linking the dCLIP.EXE engine. After
starting the custom dCLIP.EXE program, you can call any of your
procedures or functions from the dot-prompt or run the entire
program. Program modification is then accomplished by using
the EDIT, CLIPPER and OBJ commands from the dot-prompt to EDIT,
COMPILE, and DYNAMIC-LINK the changed code over the code linked
into the dCLIP.EXE engine. This "incremental updating" of your
application code can be accomplished even while your databases
are still open and your public/static memvars are still alive.
This Edit-Compile-DynaLink cycle can be used over and over
again until you are satisfied that your application is running
satisfactory, then you can update the dCLIP.EXE by relinking it
again with the new .OBJ's or link the .OBJ's into a finished
application.