START-INFO-DIR-ENTRY
* RHIDE: (rhide.inf).           Documentation about RHIDE, an IDE for DJGPP.
END-INFO-DIR-ENTRY

This is the documentation for the Integrated Development Environment RHIDE
for DJGPP.

Copyright (C) 1996 Robert H”hne

This documentation may be freely distributed with the RHIDE package or any
part thereof, provided this copyright notice is left intact on all copies.

RHIDE
*****

   Table of Contents
   *****************
1. Introduction
  1.1 Copying
  1.2 Installing RHIDE
  1.2.1 Configuring RHIDE
  1.3 What is RHIDE?
  1.4 Requirements
  1.5 Getting started
  1.5.1 Supported languages
  1.5.2 Debugging RHIDE
  1.6 The program GPR2MAK.EXE
2. General information about how RHIDE works
  2.1 Known suffixes
  2.2 Syntax of arguments
  2.3 Running under Windows 95
  2.4 Running under OS/2
  2.5 General use of RHIDE
  2.5.1 Creating a program
  2.5.1.1 Creating a program without a project
  2.5.2 Creating a library
  2.5.3 Saving/Loading the options
3. Description of the pull-down menus
  3.1 System menu
  3.1.1 About
  3.1.2 Bug report
  3.1.3 FSDB
  3.1.4 GREP
  3.1.5 GDB
  3.1.6 Refresh Desktop
  3.1.7 Calculator
  3.1.8 Puzzle
  3.1.9 Calender
  3.1.10 ASCII table
  3.2 File
  3.2.1 Open
  3.2.2 New
  3.2.3 Save
  3.2.4 Save as
  3.2.5 Save all
  3.2.6 DOS Shell
  3.2.7 Exit
  3.3 Edit
  3.3.1 Undo
  3.3.2 Redo
  3.3.3 Cut
  3.3.4 Copy
  3.3.5 Paste
  3.3.6 Show Clipboard
  3.3.7 Clear
  3.3.8 Expand all tabs
  3.3.9 Compact text
  3.3.10 Macro
  3.3.10.1 Record
  3.3.10.2 Stop
  3.3.10.3 Play
  3.4 Search
  3.4.1 Find
  3.4.2 Replace
  3.4.3 Search again
  3.4.4 Goto line
  3.4.5 Jump to function
  3.4.6 Next message
  3.4.7 Previous message
  3.5 Run
  3.5.1 Run
  3.5.2 Step over
  3.5.3 Trace into
  3.5.4 Go to cursor
  3.5.5 Program reset
  3.5.6 Arguments
  3.6 Compile menu
  3.6.1 Compile
  3.6.2 Make
  3.6.3 Link
  3.6.4 Build all
  3.7 Debug
  3.7.1 Set/Reset Breakpoint
  3.7.2 Evaluate/Modify
  3.7.3 Watch an expression
  3.7.4 Breakpoints
  3.7.5 Call stack
  3.7.6 List of Functions
  3.8 Project
  3.8.1 Open project
  3.8.2 Close project
  3.8.3 Add item
  3.8.4 Delete item
  3.8.5 Local options
  3.8.6 Includes
  3.8.7 Main targetname
  3.8.8 Primary file
  3.8.9 Clear dependencies
  3.8.10 Delete rebuildable files
  3.8.11 Write Makefile
  3.9 Options
  3.9.1 Directories
  3.9.1.1 Include directories
  3.9.1.2 Library directories
  3.9.1.3 Object directories
  3.9.1.4 Sources directories
  3.9.2 C/C++-Compiler
  3.9.2.1 Warnings
  3.9.2.2 Optimizations
  3.9.2.3 Debugging
  3.9.2.4 C options
  3.9.2.5 CXX options
  3.9.2.6 Pascal options
  3.9.2.7 How to toggle these flags
  3.9.3 Libraries
  3.9.4 Linker options
  3.9.5 Compiler options
  3.9.6 Environment
  3.9.6.1 Colors
  3.9.6.2 Editor options
  3.9.6.3 Preferences
  3.9.6.4 Mouse options
  3.9.6.5 Reserved words
  3.9.6.6 Pascal reserved words
  3.9.6.7 C-Flags
  3.9.6.8 CXX-Flags
  3.9.6.9 Pascal-Flags
  3.9.6.10 Warning-Flags
  3.9.6.11 Debugging-Flags
  3.9.6.12 Optimization-Flags
  3.9.6.13 User words
  3.9.7 Save options
  3.9.8 Load options
  3.10 Windows
  3.10.1 Size/move
  3.10.2 Zoom
  3.10.3 Tile
  3.10.4 Cascade
  3.10.5 Next
  3.10.6 Previous
  3.10.7 Close
  3.10.8 List
  3.10.9 Project
  3.10.10 UserScreen
  3.11 Help
  3.11.1 Help
  3.11.2 RHIDE Help index
  3.11.3 Syntax help
  3.11.4 libc reference
  3.11.5 Help about help
4. Detailed description of some parts of RHIDE
  4.1 Selecting a window
  4.2 How the editor works
  4.2.1 Erasing commands
  4.2.2 Cursor moving commands
  4.2.3 Text selecting and searching commands
  4.2.4 Block commands
  4.2.5 Other commands
  4.3 Some hints and problems
  4.3.1 Problems with automatic dependencies
  4.4 Project window
  4.4.1 Items of your project
  4.4.2 Open a project item
  4.4.3 Dependencies of project item
  4.4.4 Local options for a project item
  4.5 Builtin compiler specs
  4.6 Builtin variables
  4.7 Change the defaults of RHIDE
  4.8 Message window
  4.9 Syntax highlighting
  4.10 Checking the dependencies
  4.11 What is Turbo Vision
  4.12 How the dialogs work
  4.13 Defining macros
  4.14 The INFO Viewer
5. Debugging with RHIDE
  5.1 Limitations of the integrated debugger
  5.2 Dual display debugging
  5.3 Using the integrated debugger
  5.3.1 Stepping trough the source code
  5.3.2 Evaluating the contents of variables
  5.3.3 Watching the contents of variables
  5.4 Problems with C++ programs
  5.5 Using Breakpoints
  5.5.1 Setting a breakpoint
  5.5.2 Modifying and setting a breakpoint
  5.5.3 Problems with breakpoints
6. Debugging with RHGDB
7. Some FAQs
8. Index
9. Index of key commands

1. Introduction
***************

1.1 Copying
===========


RHIDE is copyright by Robert H”hne.
Parts of RHIDE are copyright by other people which is notated in the
source files.

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

For contacting the author send electronic mail to

Robert.Hoehne@Mathematik.TU-Chemnitz.DE

or paper mail to

Robert H”hne
Am Berg 3
D - 09573 Dittmannsdorf
Germany

1.2 Installing RHIDE
====================

There are two archives

`rhide??b.zip'
     This contains the executable and the documentation for RHIDE

`rhide??s.zip'
     This contains the sources for RHIDE.

where `??' in the above filenames stand for the digits of the actual version
of RHIDE.

These archives can be found at The RHIDE home page, at this URL:

     http://www.tu-chemnitz.de/~rho/rhide.html

or at any ftp site, which mirrors DJGPP.

To install these archives, you have to unzip them in the DJGPP-root
directory, like any other DJGPP package.

1.2.1 Configuring RHIDE
-----------------------

In most cases you have to do nothing for configuring RHIDE. But there are
some special things, which must be configured which have mostly to do with
the editor (or better) the keyboard layout.

The editor of RHIDE is configurable for the keyboard. For this it uses a text
file `keybind.txt', which is searched in the following directories (in that
order). If it was not found in any of these directories RHIDE uses builtin
defaults. For more information about creating (customizing) the file and
about the syntax of that file See Documentation about the keyboard in "SET's
editor", or point your Web browser to http://editor.html

   * The current directory

   * `%DJDIR%/data'

   * The directory, where `rhide.exe' is stored

The binary archive of RHIDE includes already the config files for the US
keyboard layout (`us.txt') and many others, which are based on the Linux
keytables. If you have problems with the keyboard layout try to copy one of
the files to `keybind.txt' (probably the one, which has a name similar to
your country).

RHIDE also contains the file `keybind.txt' which IS `us.txt'.

As an example, if your are using a german keyboard, and you have installed
`keyb.com' as your keybord driver program, you need to copy `de.txt' to
`keybind.txt' otherwise (for example) the keys <y> and <z> are exchanged.

If you are using a keyboard driver (like I), which converts the scancodes of
the keys (`keyb.com' does that NOT) you will probably not need the file
`de.txt' (but the default `keybind.txt').

1.3 What is RHIDE?
==================

What is RHIDE? RHIDE is an Integrated Development Environment for compiling
C- or C++-files (GNU-Assembler source files also supported) in an
environment, which has an integrated editor where you can edit your source
files and a project management, where you can define, which files are needed
to build a program or a library.

For what stands the name RHIDE? This has nothing mystic in it. It comes
simply from my initials RH and IDE (Integrated Development Environment).

RHIDE works like the IDE from Borland, which comes with Turbo C++ 3.1 and is
written with the Turbo Vision library, which I have ported to use with DJGPP.
Features of this IDE are:
   - Syntaxhighlighting is now supported and you can customize all colors on
     your desktop.

   - You can redirect the stdout and stderr from your program to a window in
     the IDE.

   - You can generate a makefile for your project, so you can build the
     program also without the IDE.

   - Most of the commandline-options of gcc can be customized.

   - You can also build a library instead of an executable.

   - When saving a file to disk, the modification time of this file will be
     set to the time of the last modification in the editor.

   - You can interrupt external programs (the compilers or your program) by
     pressing <Ctrl+C>  or <Ctrl+Break> , which are ignored by the IDE. That
     means also, that you cannot interrupt the IDE by pressing these keys. If
     you want to enable this, compile the IDE without the `-DNO_BREAK'-flag.

   - The integrated debugger. You can debug your program within RHIDE by
     executing each source line of your code and evaluating/modifying
     variables and expressions.

   - You can define other compliler to compile your source files.

In addition to RHIDE I have included a standalone debugger (called
`rhgdb.exe'), which is GDB 4.16 with a Turbo Vision user interface.

1.4 Requirements
================

RHIDE works under and is compiled with DJGPP V2.01.  To compile your programs
you need a working GCC-configuration, that means, gcc must be found in your
path. Because DJGPP works only under DPMI you need a DPMI-Server.  If you run
it under Windows 3.1(1)/95, you have DPMI. Under MS-DOS you need either a
memory-manager, which give you DPMI-services (I think QEMM is it, EMM386 has
no DPMI-support), or you use CWSDPMI, the free DPMI-server from Charles
Sandman, which you can find on SimTel-ftp-sites. I use it and it works fine
for me.

The builtin editor uses a simple heuristic to check, if a file is in UNIX or
DOS text format. It checks the first 1024 Bytes, and if there is a lf without
a cr, all lf's will be translated to cr/lf's. This is done at first only in
memory. But if you save your file to disk, it will be saved in DOS text
format.

At this time the program is only tested with a SVGA-video card (et4000), I
don't know if it works with other cards, but I think so.

1.5 Getting started
===================

To run RHIDE type
     rhide [options] ['file-name']
or
     rhide [options] 'project-name' [options]
Here stands 'file-name', for a file, which you want to open at start up.  If
it has no suffix it is assumed to be a 'project-name'.

'project-name' stands for a name of your project. If you don't type it, RHIDE
searches the current directory for a project file. If there exists only one,
it will be opened. If there exist more than one or none, RHIDE will not open
a project, you have to do it manually (See Section 3.2.1 project)

Possible options are for debugging RHIDE itself (See Section 1.5.2).  If no
project was open, you will see an empty desktop.  At the top-line of the
screen you can see the menu. This is activated by pressing <F10>  or by
clicking with the mouse at this line.  Alternatively you can press <Alt> plus
the highlighted character of a pull-down menu. e.g. to activate the *File*
menu, press <Alt+F>. At the bottom-line you can see the statusline with some
hotkeys and it functions.

Other options are:

`-y'
     Use long filenames (only under Windows 95)

`-n'
     Do not use long filenames (only under Windows 95)

`-c'
     Do not convert the case of any file name

`-h'
     Show a short help about all the possible options.

`-b'
     Use BIOS calls for setting and resetting the behaviour of the 7th bit in
     a color attribute (blinking or 16 background colors) instead of direct
     outputs to the VGA registers.

`-k KEY_FILE'
     The editor in RHIDE is now configurable also for the keyboard.  The
     file, where the key bindings are stored is searched at first in the
     current directory, then in the directory `%DJDIR%/data', and then in the
     directory where the executable is. If all this fails default values are
     taken.

     With this switch you can override the default name of `keybind.txt' to
     whatever you want.

`-p'
     Normally RHIDE converts all the numpad keys to the equivalent keys on the
     other keyboard (of course also by checking the num-lock key). With this
     switch you can disable this.

`-G n'
     Select which methode is used for swapping the display. Currently there
     are two little different functions are implemented.

     If you have problems with display swapping when in graphics mode, try to
     use an other methode and see if that helps.

At the upper right corner of the screen you can see the free virtual/physical
memory (where M stands for Megabytes, K for Kilobytes and B for Bytes), if
enabled (See Preferences).

If you try to open a project, which does not exist, RHIDE will create a new
one.  The way for creating a new project is done by RHIDE as follows.  If
there exist in the directory of RHIDE (usually in %DJDIR%/bin) a project file
with the root name of the executable and the suffix `.gpr', this file is
copied as your new project file with all customizations, which you have done
in it. If this standard project file doesn't exist, a new project file is
created with the hardcoded defaults.

To create such a standard project file, change to the directory, where the
executable is and call the exe-file with the argument of its name without the
suffix `.exe'. After leaving the program, the standard project file is
created.

1.5.1 Supported languages
-------------------------

There is also support for multiple languages. For this RHIDE uses the GNU
gettext library. With this lib it is possible to support multiple languages
without changing any code of RHIDE, when adding a new language.

There are two ways for selecting the language. Either you set the environment
variable LANGUAGE to the language you want or give it as a commandline
argument to RHIDE. The normal way is by setting LANGUAGE. If you have
installed RHIDE like described in the `readme', you should specify the
language with a two character shortcut. Here is the list of the current
supported languages together with the two character code:

`da'
     Danish maintained by Erik Bachmann <ebp@dde.dk>

`de'
     German maintained by Robert H”hne
     <Robert.Hoehne@Mathematik.TU-Chemnitz.DE>

`es'
     Spanish maintained by Salvador Eduardo Tropea (SET) <ice@inti.edu.ar>

`fi'
     Finnish maintained by Jari Anttonen <janttone@iwn.fi>

`fr'
     Frensh maintained by Eric Nicolas <nicolas@dsys.ceng.cea.fr>

`it'
     Italian maintained by Normando Marcolongo <i094968@spv.ing.uniroma1.it>

`nl'
     Dutch maintained by Martijn Laan <mlaan@cs.vu.nl>

`pt'
     Portuguese maintained by Goncalo Farias <mad@telepac.pt>

`sv'
     Swedish maintained by Christian Axbrink <sa9471@ida.utb.hb.se>

When you want to specify the language on the commandline, use the following
syntax:
rhide -L LANGUAGE
where LANGUAGE represents the language code.

If you do not specify any language, English is assumed.

Because it was not possible to get all the translations at the time when
RHIDE was ready, I included only the message files (that are the files with
the `.mo' suffix) as they are ready in the binary archive. That means, that
it is possible, that you see some strings in English instead of your language.

I will update the language files at the RHIDE homepage when they are
complete. You can then download and use them without recompiling RHIDE simply
by installing them in the correct directory.

1.5.2 Debugging RHIDE
---------------------

I have added some commandline options, to debug the IDE itself. These options
are the following:

`-dt'
     Do not remove the temporary files, which the IDE creates. The names of
     these files will be printed to stderr.

`-dc'
     Print to stderr the commands which the IDE executes.

`-dd'
     Print to stderr how the IDE checks the dependencies.

`-df'
     Print to stderr how the IDE searches for files.

`-da'
     Turns on all of the above

You can also combine these options like `-dct', which is the same as `-dc
-dt'.

To examine this debugging information, it is the best to use the redir
command, to redirect the stderr to a file like
redir -e err rhide -da project
which will redirect stderr to the file `err'.

If you want to supply certain switches for RHIDE as a default, you may put
them into the environment variable `$(RHIDEOPT)'.  The contents of this
variable is used before the the real commandline is parsed.  That means you
can overwrite the switches from the environment variable.

1.6 The program GPR2MAK.EXE
===========================

This program can be used to create a makefile from your projectfile.  It does
exctly the same like the function which is selectable from the RHIDE menu
(See Section 3.8.11).

In RHIDE you have only the possibility to say, if in the generated makefile
all dependencies should be included or not. With `gpr2mak.exe' you can tell
also to create recursively all the needed makefiles. This makes sense only if
you have included other projects in your project.

Here are the possible commandline options for `gpr2mak.exe'.
`-d'
     Include all dependencies in the makefile

`-d-'
     Include only the needed dependencies to create the final program or
     library.

`-r'
     Call `gpr2mak.exe' recursively, if there are other projects part of the
     project.

`-r-'
     Do not call `gpr2mak.exe' recursively.

`-o OUTFILE'
     Use `OUTFILE' instead of the project name (with the suffix `.mak') as
     the created makefile. If you want to write the makefile to `stdout', use
     `-' as `OUTFILE'.

And the complete syntax for calling `gpr2mak.exe' is also:

     `gpr2mak.exe [-d[-]] [-r[-]] [-o OUTFILE] project-file'

If you give no options (the project-file must be given), `gpr2mak.exe'
assumes the flags `-d- -r-' as default.

2. General information about how RHIDE works
********************************************

In this section I will give you some comments about the concept of RHIDE.
RHIDE works with the GNU compilers. As a result of this, most of the options
are fixed and they are mostly also specific only for these compiler. If I
speak about compilers, I mean GCC, which calls the right compilers for you.
(`cpp' for preprocessing your input files, `cc1' for compiling C programs,
`cc1plus' for compiling C++ programs and `as' for compiling assembler files
and so on)

Selecting the right compiler for a specific file is done by RHIDE in the same
way as GCC it does. It looks for the extension of the file and determines the
language of this file.

2.1 Known suffixes
==================

The list of the known suffixes is taken from gcc. Remember the fact, that gcc
and RHIDE check the suffixes in a case sensitive way especially when running
under Windows 95 (See Section 2.3).

   * Valid suffixes for C source files are
    `.c'
          Normal C source file

    `.i'
          C source file, which doesn't need the preprocessor

   * Valid suffixes for C++ source files are
    `.cc'
    `.cpp'
    `.cxx'
    `.C'
          Normal C++ source file

    `.ii'
          C++ source file, which doesn't need the preprocessor

   * Valid suffixes for Objective C source files
    `.m'
          Normal Objective C source file

   * Valid suffixes for Pascal source files
    `.p'
    `.pas'
          Normal Pascal source file

   * Valid suffixes for object files
    `.o'
          Normal object file

    `'
          any other suffix, which has no predefined meaning

   * Valid suffixes for libraries
    `.a'
          Normal library file

   * Valid suffixes for executable files
    `.exe'
          Normal executable file for MS-DOS

    `.'
          No suffix means the raw COFF image of an executable file. These can
          be handled only by programs, which know about this format.  (DJGPP
          programs know this)

   * Valid suffixes for include files
    `.h'
          Normal include files

    `.hpp'
          Some people telled me, that this suffix should be treated also as a
          valid suffix for header files, so I applied it.

    `'
          Theoretically there is no restriction for such a suffix, but RHIDE
          searches and finds only files with the above suffixes in the
          specified directories (See Section 3.9.1.1)

   * Valid suffixes for Assembler source files
    `.s'
          Normal Assembler source file

    `.S'
          Assembler source file, which must be preprocessed by `cpp'. If you
          have such files, there is a problem, when long filenames are not
          enabled (default in MS-DOS), because RHIDE converts all filenames
          in this situation to lower case. But you can add to the local
          options for this item (See Section 3.8.5) the commandline argument
          -X ASSEMBLER-WITH-CPP, to tell `gcc' to preprocess this file first
          before assembling it.

2.2 Syntax of arguments
=======================

In RHIDE you can specify some arguments to other programs. These arguments
must be a space separated list of strings. If you want to have one or more
spaces as part of an argument, you have to enclose the whole argument in
single or double quotes.

2.3 Running under Windows 95
============================

With DJGPP 2.01 were many bugs fixed, which caused problems under Windows 95
with the long (and case sensetive) filenames. Now all filenames are shown in
lower case, except they contain characters with different case. That means,
all normal 8+3 DOS filenames, which are normaly reported in Windows 95 in
upper cases, are automatically converted to lower case. For more information
about  filename conversion look at the libc reference.

If you really need the filenames exactly  as they are reported by the OS, you
can use the -C switch (See Section 1.5).

You can also run more than one instance of RHIDE at once, in several
DOS-boxes, because RHIDE creates and uses its own temp directory every time
it starts to disable conflicts, when running multiple compilers at the same
time. This is done by creating a directory in the directory pointed at by the
environment variables %TMPDIR%, %TEMP% or %TMP%, in that order, until one of
them exists. If none of them exists, the current directory is assumed. Then
RHIDE puts the value of this directory into the environment variable
%TMPDIR%. After leaving RHIDE this directory will be removed, if it is empty.

2.4 Running under OS/2
======================

Because I have no access to OS/2, I cannot say anything about it. But some
people said  that they run RHIDE under OS/2 successfully, but there must be
the exclusive mouse access to the DOS window disabled.

2.5 General use of RHIDE
========================

2.5.1 Creating a program
------------------------

For creating a program, RHIDE allows you to define multiple source files
which should be compiled and linked to your final program. This is done by
creating a project. In this project you insert your source files (and not all
the include files).

After a source file (which is inserted in your project) compiled at least
once, RHIDE knows about all dependencies of this file, so this file will be
compiled again only, if one of the include files have changed.

2.5.1.1 Creating a program without a project
............................................

Because of many requests of users I made RHIDE to work also without using a
project. This may be good, if you have a single file, but if your program
should be build from more than one file I suggest you to use a project.

If you have only one editor window opened, the name of the resulting program
is taken from the name of the source file by removing the suffix and
appending `.exe'.

If you have more than one files opened, I saw no other way for determining
the name of the produced program, than naming it `aout.exe'.

2.5.2 Creating a library
------------------------

You can also create libraries (a collection of object files, which can be
linked with other programs) with RHIDE. The way for doing this is very
simple. Because RHIDE knows about the meaning of file suffixes, you can
change the name of the main target (See Section 3.8.7) to have a suffix `.a'
and that's all. Now RHIDE will run `ar.exe' instead of linking

2.5.3 Saving/Loading the options
--------------------------------

RHIDE supports two different ways for saving the options which you have
customized.

The first one (which I prefer) is the use of the so called default project.
This is the project `rhide.gpr' and must be located in the same directory
where `rhide.exe' is. To create or modify this default project change to that
directory (normally %DJDIR%/bin) and type there

rhide rhide

Now chnage any options you want and exit RHIDE. From now on these options are
used for any newly created project or when running RHIDE without a project.

The second way is to save your options to a project file (See Section 3.2.3
options) or to load them from any existing project file (See Section 3.9.8).

3. Description of the pull-down menus
*************************************

This chapter describes the pull-down menus and all their sub-menus.  The main
menu bar, the topmost line of the screen, is selected with the hotkey <F10>
or by clicking with the mouse at this line. You can walk through the menu
with the cursor keys and a menu entry is selected with <ENTER>  or by
clicking with the mouse on it.

3.1 System menu
===============

This menu has its name only that one can speak about it. The symbol for this
menu is the leftmost symbol in the menu bar and can be selected by <Alt+SPACE>
.

3.1.1 About
-----------

This brings up a window with information about the author and the version of
RHIDE.

3.1.2 Bug report
----------------

This menu entry opens an editor with some important information which should
be part of a bug report and where you can describe the problem.

3.1.3 FSDB
----------

With this menu item you can call the FSDB debugger, which comes with DJGPP.
But remember, this runs the debugger as an external program and it is not
integrated in RHIDE.

3.1.4 GREP
----------

This is a very useful function. You can type the arguments for grep in the
input line, which will be shown, and after this the program grep is called.
The messages from grep are redirected to the message window (See Section 4.8).

3.1.5 GDB
---------

This is analog to the call of FSDB (See Section 3.1.3).

3.1.6 Refresh Desktop
---------------------

This function is sometimes useful, if you had run your program and it wrote
some things to the screen (for redirecting `stdout' and `stderr' from your
program to a window in RHIDE (See Preferences)).

3.1.7 Calculator
----------------

This brings up a dialog, where you can do some calcualtions. This dialog is
similar to the evaluate dialog (See Section 3.7.2), but it uses not the
feature of gdb, but it is a separate calculator.

There can be used also some of the standard functions like `log', `sin' and
so on and it can convert also integer values between different bases (`hex',
`oct', `dec').

3.1.8 Puzzle
------------

This will open a small window, where you can play a little puzzle game. The
"stones" are moved with the cursor keys or by clicking with the mouse on it.

3.1.9 Calender
--------------

This will open a little calender. With the cursor keys <Up> and <Down> you
can switch to the next/previous month or click with the mouse the small
symbols int the upper corners.

3.1.10 ASCII table
------------------

This will open a window with all the ASCII characters. Move around with the
curser keys or press any key to select any wanted charcter.  In the bottom
line you will see the the character and the value of it (decimal and
hexadecimal). The decimal value can be used to create that character for
instance in the editor by holding the <Alt> key down and typing the value on
the numeric key pad.

3.2 File
========

In this menu you can find functions, which deal with files like open, close,
save and so on.

3.2.1 Open
----------

Brings up the file-open dialog, where you can select a file to open (hotkey
<F3> ). This dialog contains an inputline for the filename, a list of
filenames, an information window and the buttons for opening and canceling.

In the filename inputline you can type direct the file, which you want to
open or you can type any mask to list only some files. The default mask is
`*.cc', but you can change this to anything and your last typed mask is
stored as the default mask for the next use. There is also a history of your
previous typed inputs available. This is selected when you hit the down key
or click at the small symbol at the end of the inputline with your mouse.

The list of filenames shows all the files that correspond to the mask.  If
this list is selected you can choose a file with the cursor keys, or you can
type the first letters of the filename you want, and the bar is located at
the first file, which has these letters as the first characters. To open the
file simply press <ENTER> or double click with the mouse on it.

Below the list of filenames there is a small window with information about
the selected file (complete path, size, modification time).

To leave the dialog without opening a file press <ESC>

3.2.2 New
---------

This is the menu entry for creating a new file to edit. This file gets the
title 'Untitled'. If you save or close it, you will be prompted for a new
name of this file by opening the file-open dialog.

3.2.3 Save
----------

Save the file in the current editor-window to disk. If the name of the
current file is 'Untitled' you will be prompted for a new name. This function
has the hotkey <F2> .  The modification of the file on disk is set to the
time of the last modification of this file and not to the time when saving to
disk.

If the file was not modified, it is not saved!!

3.2.4 Save as
-------------

Save the file in the current editor-window to disk under a different name,
for which you will be prompted. For choosing the new name the file-open
dialog will be opened.

3.2.5 Save all
--------------

Save all the editor files to disk. If they are not modified, they will not be
saved.

3.2.6 DOS Shell
---------------

This executes a DOS-Shell. This is done by calling the program, which is set
in the environment variable COMSPEC. If this variable does not exist, the
program `c:/command.com' is executed.  To return to the IDE type `exit' at
the DOS-prompt. Before calling DOS, the program does a *Save all* (See
Section 3.2.3 all) automatically.

3.2.7 Exit
----------

Here you can quit the IDE. If there are any unsaved editor-files, you will be
prompted for saving them. (hotkey <Alt+X> )

3.3 Edit
========

In this menu you can activate functions, which are related to the integrated
editor. Most of them have a hotkey.

3.3.1 Undo
----------

This undoes your last change in the current editor-window. The hotkey for
this function is <Alt+Backspace> .

3.3.2 Redo
----------

This does the reverse to undo (See Section 3.3.1). That means, it is the undo
of the undo.

3.3.3 Cut
---------

This *moves* the selected text in the current editor-window to the clipboard.
(hotkey <Shift+Del> )

3.3.4 Copy
----------

This *copys* the selected text in the current editor-window to the clipboard.
(hotkey <Ctrl+Ins> )

3.3.5 Paste
-----------

This inserts the selected text in the clipboard in the current editor-window
at the current cursor-position. (hotkey <Shift+Ins> )

3.3.6 Show Clipboard
--------------------

This brings up an editor-window with the contents of the clipboard. The
contents of the clipboard will be lost, if you exit the IDE.

3.3.7 Clear
-----------

This erases the selected text in the current editor-window.

3.3.8 Expand all tabs
---------------------

When selecting this menu entry, all real tabs (all characters with the code
`0x9') are expaned to as many spaces as defined as the tabsize (See
Preferences).

3.3.9 Compact text
------------------

This function is the reverse to (See Section 3.3.8). That means, RHIDE tries
to make as many as possible spaces (count is taken from the defined tabsize)
to real tabs.

3.3.10 Macro
------------

Here is a submenu for handling macros. Currently there is only one recordable
macro available and it is NOT stored anywhere. That means it is lost when you
leave RHIDE and restart it. There is an other way of using macros (See
Section 4.13).

3.3.10.1 Record
...............

After selecting this function, all your keystrokes are recorded to reproduce
them later.

(hotkey <Shift+F10> )

3.3.10.2 Stop
.............

This stops the recording of a macro.

(hotkey <Alt+F10> )

3.3.10.3 Play
.............

This executes the recorded macro.

(hotkey <Ctrl+F10> )

3.4 Search
==========

Menu for searching and replacing strings in the editor-window. These functions
have also hotkeys.

3.4.1 Find
----------

Find a string in the current editor-window. You can type the string for
searching in an inputline and you can also select, if the search is case
sensitive or not and to search for whole words only or not.

(hotkey <Ctrl+Q+F> )

3.4.2 Replace
-------------

Find and replace a string in the current editor-window. This works in the
same way like searching text, but additionally you can give a string, with
which the found text will be replaced.

(hotkey <Ctrl+Q+A> )

3.4.3 Search again
------------------

This function repeats the last search or replace operation.

(hotkey <Ctrl+L> )

3.4.4 Goto line
---------------

After prompting for a line number (with range checking), the cursor will be
located at this line.

(hotkey <Ctrl+J> )

3.4.5 Jump to function
----------------------

With this feature you can easily jump to the source line of a function to
edit or see it. This is only a heuristic by parsing your source file and does
not take the information from the debugging symbols.

After selecting it you will get a dialog, from where you can select the
function to which you want to jump.

(hotkey <Alt+F2> )

3.4.6 Next message
------------------

This selects the next message in the message window (See Section 4.8), but
only, if there is a next message available.

(hotkey <Alt+F8> )

3.4.7 Previous message
----------------------

This selects the previous message in the message window (See Section 4.8),
but only, if there is a previous message available.

(hotkey <Alt+F7> )

3.5 Run
=======

In this menu you find the functions for running your program.

3.5.1 Run
---------

If your project-target is an executable, this will be run after doing a Make
(See Section 3.6.2). (hotkey <Ctrl+F9> ) If building the program was not
successful, the programm will not be started. The debugging functions are
only available if `-g' was used for compiling.  (See Section 2.2)

3.5.2 Step over
---------------

This executes the code for exactly on source line. If there is a function
call at the current line this function is executed at once without stepping
through this function.

(hotkey <F8> )

3.5.3 Trace into
----------------

This is the same as Step over (See Section 3.5.2), except when there is a
function call at the current line and for this function debugging information
is available, RHIDE steps into this function.

(hotkey <F7> )

3.5.4 Go to cursor
------------------

This will execute your program until the execution comes to the line, where
the cursor is. If the program is stopped at any other place by a breakpoint
the program will stop there and not at the cursor position.

(hotkey <F4> )

3.5.5 Program reset
-------------------

This 'kills' your debuggee at the current execution point without executing
any other code of your program

(hotkey <Ctrl+F2> )

3.5.6 Arguments
---------------

Here you can type the arguments, which will be passed to your program when
you do a *run*. (See Section 3.5.1) and (See Section 2.2).

3.6 Compile menu
================

Here are the functions to translate your source files and for updating your
project.

3.6.1 Compile
-------------

Compile the file in the current editor-window or the selected entry in the
project-window if you are there. The IDE chooses automatically the correct
compiler, depending on the suffix of the file.  (See Section 2.1)

(hotkey <Alt+F9> )

3.6.2 Make
----------

This makes your project up to date. It works like MAKE on commandline with a
makefile. (hotkey <F9> ) This is done by checking the dependencies for each
item of the project. These dependencies are automatically generated, if you
compile a file within the IDE.

3.6.3 Link
----------

This function has two different results depending on the type of your
project. If your project is an executable (See Section 2.1), the linker is
started. But if it is a library, all the object files are taken to build a
library.

3.6.4 Build all
---------------

This builds the project completely new with compiling and linking all of the
project-items.

3.7 Debug
=========

This menu conatains the functions for debugging your program. Most of them
have hotkeys and they are described more detailed later (See Section 3.7ging
with RHIDE).

3.7.1 Set/Reset Breakpoint
--------------------------

See Section 5.5.1

(hotkey <Ctrl+F8> )

3.7.2 Evaluate/Modify
---------------------

See Section 5.3.2

(hotkey <Ctrl+F4> )

3.7.3 Watch an expression
-------------------------

See Section 5.3.3

(hotkey <Ctrl+F7> )

3.7.4 Breakpoints
-----------------

See Section 5.5.2

3.7.5 Call stack
----------------

This shows a window with a list of functions, from which the current
execution point in the debugged program are called from. If you hit <Enter>
on a function which has line number debugging information, you will go to the
source line which is shown in the window.

(hotkey <Ctrl+F3> )

3.7.6 List of Functions
-----------------------

This asks first for a regular expression to list only those functions of your
program, which match that expression. The syntax for such a regular
expression is a little bit different from the wildcards you are probably
knowing from MS-DOS.

If you want to get a list of all functions you should enter either nothing
(the default), or ".*", or "?*" (both without the double quotes).  The
expression "*" does NOT mean all function. In fact, your entry will be
interpreted as a regular expression.

After you have typed the expression and pressed <Enter>, you will get a list
of  functions that match the regular expression and for which debugging
information is available.

This list is sorted by the name of the function and has three parts:

NAME | RETURN VALUE | FILE

You can walk throught the list with the cursor keys or the mouse. If you hit
<Enter> or double click a function, you will go the the source code of that
function.

3.8 Project
===========

Here you can add or remove items to or from your project

3.8.1 Open project
------------------

Here is the point to open a project. After selecting this menu item, the file
open dialog is opened to select a project. You can type the name of the
project or select one from the list.

If you open a project in an other directory than the current, RHIDE will
change the current directory to this directory and then the project will be
opened.

If you type here a name of a project, which does not exist, a new one is
created.

If no project was opened and you create a new project, all open desktop files
remain open, but they are not added to the project.  If a project was opened,
it will be automatically closed before the new project is opened.

3.8.2 Close project
-------------------

This closes the current opened project and closes all files, which are on the
desktop.

3.8.3 Add item
--------------

A dialog will be opened, from where you can choose your file to add to your
project. If you are in the project window (See Section 3.10.9 window) you can
use the <Ins>  key to activate this function within the project window.

Currently it is impossible to use relative or absolute paths as part of a
project item. If you have your files in several directories, you have to
setup either the search path for source files or you have to create for each
directory a library that can be included in your project.

3.8.4 Delete item
-----------------

This will remove the selected item in the project-window from your project.
If you are in the project window (See Section 3.10.9 window) you can use the
<Del>  key to activate this function.

3.8.5 Local options
-------------------

Here you can give the selected project-item options for compiling, which will
be in effect only for this item. If you are in the project window (See
Section 3.10.9 window) you can use <Ctrl+O>

to activate this function.  The options you give here are passed to gcc only,
when compiling this file.  For more details see (See Section 3.8.5 for a
project item).

3.8.6 Includes
--------------

This shows the dependencies for the selected item in the project window. You
can use the hotkey <Ctrl+I>  in the project window.  (See Section 3.10.9
window)

3.8.7 Main targetname
---------------------

Here you can change the name of your main target. The main target is either
an executable file or a library. RHIDE selects the type of the main target
from the suffix of this name. If it has no suffix or the suffix `.exe', an
executable will be built. If it has the suffix `.a', a library will be
created.

Remember when you give it no suffix, both, the COFF image and the `.exe' file
will created. If it has the `.exe' suffix, only the `.exe' file is created.

3.8.8 Primary file
------------------

Here you can give the primary source file, when you want to use the
'automake' feature of GPC. If you type a source name here, RHIDE assumes that
your program is written in Pascal and does NOT check any dependencies of the
project, because this is done automatically by GPC with the `--automake'
option.

If you don't want to use the 'automake' feature of GPC, even when building a
Pascal program, give here an empty name, which is the default.

3.8.9 Clear dependencies
------------------------

This function removes all internal stored dependencies. The files are not
removed. This is useful when you want to create a makefile (See Section
3.8.11) and you do not want to include  all the absolute filenames for the
dependencies (mostly the include files).

This function is a relict from earlyer versions of RHIDE, but I have not
disabled it.

3.8.10 Delete rebuildable files
-------------------------------

This function includes the function of clearing the dependencies (See Section
3.3.7 dependencies) and removes in addition to it all the files, which can be
rebuild within RHIDE.

3.8.11 Write Makefile
---------------------

Here you can create a makefile that  contains all the rules to build the
project from the command line without starting RHIDE. For this you need the
GNU make, because the generated makefile uses the features of GNU make very
extensively.

If you have used environment variables in your search paths (See Section
3.9.1), these are not expanded in the generated makefile.  But all variables
you used will be defined at the beginning of the makefile with their current
value.

3.9 Options
===========

This menu contains many submenus for anything you can customize.

3.9.1 Directories
-----------------

Here you can define all of the paths, where RHIDE and the compilers finds the
needed files and where to store some files.

All the paths you can define in the several entries have the form of a
semicolon separated list of directories, just like your environment variable
%PATH%. You can use forward slashes and back slashes, but they are all
converted to forward slashes by RHIDE. You can also use environment variables
as part of your paths. The syntax of such a variable is that of a GNU
makefile. If you want to use the variable %DJDIR%, you must type $(DJDIR).

3.9.1.1 Include directories
...........................

This is the list of directories, where gcc looks for include files and RHIDE
searches in this directory (after looking in the current directory) for
header files.

3.9.1.2 Library directories
...........................

This is the list of directories, where gcc looks for libraries when linking.
RHIDE searches in this directories (after looking in the current directory)
for libraries, if you have included them directly as a project item.

3.9.1.3 Object directories
..........................

This is the list of directories where RHIDE looks for object files.  If you
type here only one directory this has also the effect that the object files,
which are compiled, are stored in this directory.

3.9.1.4 Sources directories
...........................

This is the list of directories, where RHIDE looks for the source files
(after looking in the current directory).

3.9.2 C/C++-Compiler
--------------------

In this submenu you can change most flags, which have to do when compiling C
or C++ files or better for the options of all the currently supported
compilers.

3.9.2.1 Warnings
................

This opens a dialog where you can enable or disable most of the flags for
generating or supressing warnings when you compile a C or C++ file.  (See
Section 3.9.2.7).

For a detailed description of the available flags see See Section 'Warning
Options' in documentation for 'gcc'.

3.9.2.2 Optimizations
.....................

This opens a dialog where you can customize how the compiler optimizes your
code.  (See Section 3.9.2.7).

For a detailed description of the available flags see See Section 'Optimize
Options' in documentation for 'gcc'.

3.9.2.3 Debugging
.................

This opens a dialog where you can customize the amount of debugging
information the compiler should include in object files.  (See Section
3.9.2.7).

For a detailed description of the available flags see See Section 'Section
3.7ging Options' in documentation for 'gcc'.

3.9.2.4 C options
.................

This opens a dialog where you can select flags that are only passed to gcc
when compiling C files.  (See Section 3.9.2.7).

For a detailed description of the available flags see See Section 'C Dialect
Options' in documentation for 'gcc'.

3.9.2.5 CXX options
...................

This opens a dialog where you can select flags which are only passed to gcc
when compiling C++ files.  (See Section 3.9.2.7).

For a detailed description of the available flags see See Section 'C++
Dialect Options' in documentation for 'gcc'.

3.9.2.6 Pascal options
......................

This opens a dialog where you can select flags which are only passed to gpc
when compiling Pascal files.  (See Section 3.9.2.7).

For a detailed description of the available flags see See Section 'Pascal
Dialect Options' in documentation for 'gpc'.

3.9.2.7 How to toggle these flags
.................................

The options in the dialogs for Warnings, Debugging, C-flags and CXX-Flags are
selected with the cursor-keys or the mouse and are activated or deactivated
by pressing <SPACE>  or by double-clicking with the mouse at the first field
of the option. If an option can take an additional value or string, an
inputbox will be opened, and you can type them there. If the additional value
is optional, you can leave this input-box by pressing <ESC>  or activating
the *Cancel* button and no value, or the previous one will be appended to
this option.

3.9.3 Libraries
---------------

Here you can tell the linker which libraries will be linked in your program.
At this time the number of additional libraries is limited to 16. If you need
more, you have to type them manually (See Section 3.6.3er options).

In the input-fields of the dialog you only have to type the part of your
library name after `lib' and before `.a'. Example: If your library is
`libtv.a' you have to put only `tv' there. You can switch between the
inputlines for the libraries using <Tab> , or <Down Arrow> (next field), or
<Shift+Tab> , or <Up Arrow> (previous field). If you have typed your
libraries you can activate or disable them by switching the checkbox before
the name on or off. This is done by pressing <Alt> and the corresponding
digit or letter of the checkbox at the same time or by clicking with the
mouse.

Normally RHIDE checks the types of your source-files and automatically adds
some standard libraries, corresponding to these source-files.  These are for
C++ files the library `libiostream.a' and for Objective C files the
`libobjc.a' library.  If you want to disable this, deactivate the *Use
standard libraries* checkbox. This adds also the commandline option -NOSTDLIB
to gcc, that means, you must give the linker explicit all of the standard
libraries, which you need. This includes the `libgcc.a' and `libc.a'
libraries.

3.9.4 Linker options
--------------------

Here you can enter a space separated list of options that will be passed to
gcc when linking your program.  (See Section 2.2)

(See Section 2.2).

3.9.5 Compiler options
----------------------

Here you can enter a space separated list of additional options that will be
passed to gcc every time it is called.  (See Section 2.2)

(See Section 2.2).

3.9.6 Environment
-----------------

3.9.6.1 Colors
..............

Here you can customize all of the colors of the IDE.

3.9.6.2 Editor options
......................

autoindent
..........

When this is enabled, the editor automaticaly indents the next line by
refering to the previous line if you press enter.

For more information See Documentation for the editor in "SET's editor", or
point your Web browser to http://editor.html

(See Section 3.3or options)

Use tabs
........

When this is enabled, the character `\t' is inserted into the text if you
press the <Tab>-key. Otherwise the number of spaces (defined by tabsize) is
inserted.

For more information see See Documentation for the editor in "SET's editor",
or point your Web browser to http://editor.html

(See Section 3.3or options)

Persistent blocks
.................

Normally, RHIDE uses persistent blocks. This means the selected area will not
get unselected if you press a key. If you like the behaviour of earlier
versions of RHIDE, disable this option.

For more information see See Documentation for the editor in "SET's editor",
or point your Web browser to http://editor.html

(See Section 3.3or options)

Intelligent C indenting
.......................

This option enables the so called 'C intelligent indenting', which is an
heuristic for indenting after special key words like `if' or `while' more
than the normal autoindenting. This works only  if AUTOINDENT is enabled.

For more information see See Documentation for the editor in "SET's editor",
or point your Web browser to http://editor.html

(See Section 3.3or options)

Column cursor
.............

This is a special feature of the builtin editor. If you enable this option
you will see a vertical special color highlighted column across the whole
editor window at the cursor column.

For more information see See Documentation for the editor in "SET's editor",
or point your Web browser to http://editor.html

(See Section 3.3or options)

Row cursor
..........

This is a special feature of the builtin editor. If you enable this option
you will see a horizontal special color highlighted row across the whole
editor window at the cursor row.

For more information see See Documentation for the editor in "SET's editor",
or point your Web browser to http://editor.html

(See Section 3.3or options)

Match pair highlight
....................

If this option is enabled, you will see at any time you type a bracket, brace
or parenthesis the matching highlighted or a message, that there was no
macthing was found.

For more information see See Documentation for the editor in "SET's editor",
or point your Web browser to http://editor.html

(See Section 3.3or options)

Do not move the cursor on paste
...............................

Enable this option, when you want to leave the cursor at it's current
position when you paste some text.

(See Section 3.3or options)

Transparent Blocks
..................

When this option is enabled, the syntax highlight is still shown in selected
blocks.

(See Section 3.3or options)

Optimal fill
............

When enabling this option the editor fills the gaps in your text with an
optimal value of spaces and tabs.

(See Section 3.3or options)

Tabsize
.......

Additionaly you can select here the tabbing size for the editor. This value
is used as the global setting for all editor windows wich will be opened
after setting this value. The current opened windows will use also this
setting.

(See Section 3.3or options)

3.9.6.3 Preferences
...................

Here you can customize some basic options for the work of the IDE. A dialog
will be opened where you can turn on or off the following options:

all dependencies in makefile
............................

When this is enabled, all internally stored dependencies for a project item
are written to the makefile.  (See Section 3.8.11). You should disable this
option, if you want to give an other user the makefile of your project, and
(s)he has a different directory structure.

(See Preferences)

create backupfiles
..................

Create backupfiles when saving. When it is enabled, RHIDE creates a backup of
the file to save under the same name as the editing file, but the suffix is
replaced with `.bak'

(See Preferences)

syntax highlighting
...................

Turn the Syntax highlight on or off. RHIDE automatically checks the suffix of
the editing file to determine the correct syntax highlighting.  Currently
this is supported only for C, C++, and Pascal source files.  All other files
are not specially highlighted.

(See Preferences)

Use dual display
................

Here is an very powerfull option. If you have installed on your computer a
secondary display (monochrome monitor) in addition to your VGA monitor, RHIDE
can (when this option is enabled) switch to to the dual monitor for it's
output and you can see your program on the normal monitor.

If this option is enabled and you have not a secondary monitor installed,
RHIDE will detect this and does not switch to it.

(See Preferences)

redirect stderr
...............

Turn this on, if you want to redirect the output to stderr of your program to
a window in the IDE. This is also needed, if you want to use the builtin
analyzing of a call frame traceback, when your program crashes.

(See Preferences)

redirect stdout
...............

Turn this option on, if you want to redirect the output to stdout from your
program to a window in the IDE.

(See Preferences)

show process information
........................

Turn this option on if you want to see which files are checked, when you do a
make (See Section 3.6.2), and to see the commandlines how the compilers are
started by RHIDE.

(See Preferences)

show free memory
................

Turn this option on to show in the upper right corner of the screen a readout
of the free memory of your system.  This shows both, the virtual and the
physical free memory.

(See Preferences)

No file caching
...............

If this option is enabled, RHIDE does not use the internal caching of
information about searching files and modification times. Use this only if
you have problems with the automatic checking of dependencies, because this
slows down RHIDE.

(See Preferences)

16 background colors
....................

On EGA/VGA video cards it is possible to use 16 background colors instead of
normal 8. This is done by telling the video card how to interpret the highest
bit of the color attribute. If you enable this, you can use up to 16
background colors, otherwise there are only 8 colors for the background
available. To get blinking foreground colors, you must use a little trick.
Enable at first this option here. Then change  the color attribute you want
to highlight background color you want and then reset the '16 background
colors' option.

(See Preferences)

Show GDB commands
.................

When this option is enabled you can see in the GDB output window which
commands are sent to the builtin GDB from RHIDE.

(See Preferences)

Use no shadows
..............

When this option is enabled RHIDE uses no shadows at all for the windows and
dialogs and so on.

(See Preferences)

Save text palette
.................

When you debug a program, which modifies the palette when in text mode, you
should enable this option.

Save project only when closing
..............................

Enable this option only, when you get a system crash after starting your
program and because of the use of disk cache the project, which RHIDE
automatical saves before your program is runned, is corrupted.

Screen mode
...........

Here you can select the video mode. If you want to use a video mode other
than  the ones shown, you have to select the USER MODE mode and type the
value of this mode (see in the reference of your video card) as a decimal or
hexadecimal (preceeded by `0x') number. But you can use only textmodes (modes
with starting video ram address at `0xB800:0000'. For the numbers of the
videomodes refer to the documentation of your video card.  If you type an
invalid videomode (RHIDE checks it), the 80x25-Mode will automatically
selected.

I have tested all available text modes with my et4000-card, and they work.
For some modes, (mostly every high resolution text mode) the mouse cursor is
shown by my own routine.  That means that you can use the mouse also in the
high resolution text modes.

(See Preferences)

3.9.6.4 Mouse options
.....................

Here you can customize a little bit the speed of the double click intervall
and you can also tell RHIDE to reverse the mouse buttons.

3.9.6.5 Reserved words
......................

This opens a dialog, where you can modify the list of reserved words the
editor knows. If you choose the *Default* button in this dialog, the default
reserved words are generated and any previous words are lost.

3.9.6.6 Pascal reserved words
.............................

This opens a dialog, where you can modify the list of reserved words for
Pascal the editor knows. If you choose the *Default* button in this dialog,
the default reserved words are generated and any previous words are lost.

3.9.6.7 C-Flags
...............

Here you can modify the list of C options, which you can turn on or off. (See
Section 3.9.2.4)

(See How to change the list of flags)

3.9.6.8 CXX-Flags
.................

Here you can modify the list of CXX options, which you can turn on or off.
(See Section 3.9.2.5)

(See How to change the list of flags)

3.9.6.9 Pascal-Flags
....................

Here you can modify the list of Pascal options, which you can turn on or off.
(See Section 3.9.2.6)

(See How to change the list of flags)

3.9.6.10 Warning-Flags
......................

Here you can modify the list of Warning-Flags, which you can turn on or off.
(See Section 3.9.2.1)

(See How to change the list of flags)

3.9.6.11 Debugging-Flags
........................

Here you can modify the list of Debugging-Flags, which you can turn on or off.
(See Section 3.7ging)

(See How to change the list of flags)

3.9.6.12 Optimization-Flags
...........................

Here you can modify the list of Optimization-Flags, which you can turn on or
off.  (See Section 3.9.2.2)

(See How to change the list of flags)

3.9.6.13 User words
...................

Here you can define your own list of words, which can be specially
highlighted, when syntax highlighting is enabled. (See Preferences)

How to change the list of flags
...............................

The syntax of the strings, which you can modify or add with the last
menu-entries is any string followed by an optional modifier with the
following meaning:

`%d'
     if you activate this option, you *must* enter an integer there

`%d?'
     if you activate this option, you *can* enter an integer there

`%c'
     if you activate this option, you *must* enter a character there

`%c?'
     if you activate this option, you *can* enter a character there

`%s'
     if you activate this option, you *must* enter a string there

`%s?'
     if you activate this option, you *can* enter a string there

`%s(STRING)'
     if you activate this option, you *must* enter a string, which contains
     only characters defined by the string STRING, there

`%s?(STRING)'
     if you activate this option, you *can* enter a string, which contains
     only characters defined by the string STRING, there

As an example: the string for the `-O' option is defined as `-O%d?' and the
`-d' option (See Section 3.7ging) is defined as
 `-d%s(MNDyrxjsLtfcSlgRJdkamp)'
which means, the string after `-d' must be a combination of the characters in
 `MNDyrxjsLtfcSlgRJdkamp'
If you leave the dialogs for modifying the flag lists with the *Ok* button or
if you activate the *Default* button, all flags are disabled

3.9.7 Save options
------------------

Here you can save all the options you currently customized to a file.  RHIDE
restricts this to saving them only to a file with the `.gpr' suffix (and
`.gdt' for the desktop file).

3.9.8 Load options
------------------

Here you can load the options from any existing project file.

3.10 Windows
============

In this menu you get the functions for arranging, resizing and switching
between the windows on the desktop:

3.10.1 Size/move
----------------

With this function you can resize and/or move the current window. After
selecting this, the frame of the current window will be drawn light-green and
you can move it with the cursor-keys. To resize it, press <Shift+>
cursor-keys. To exit the moving/resizing function, press <ESC> or <ENTER>.
Alternatively you can use the mouse.  For moving, click on the top of the
window and hold the left button down. Now you can move the window by moving
the mouse. To resize it, click on lower right corner of the window, hold the
button down and resize the window by moving the mouse. (This function has the
hotkey <Ctrl+F5> )

3.10.2 Zoom
-----------

This brings up the window to maximal size or to previous size.  (hotkey <F5>
or click with the mouse at the symbol on the right upper corner of the window)

3.10.3 Tile
-----------

This arranges all the editor-windows on the desktop, to see them all
simultaneously.

3.10.4 Cascade
--------------

This arranges all the editor-windows on the desktop, to see the contents of
the current editor-window and the top-frame of all the others.

3.10.5 Next
-----------

This switches to the next window on the desktop. (hotkey <F6> )

3.10.6 Previous
---------------

This switches to the previous window on the desktop.  (hotkey <Shift+F6> )

3.10.7 Close
------------

This closes the current window. If it is an editor-window and its contents
were modified, you will be prompted to save it. (hotkey <Alt+F3> ) or click
with the mouse on the upper-left symbol of the frame.

3.10.8 List
-----------

This brings up a list of all windows that are currently on the desktop. You
can select one of them and press <ENTER>  to switch to it. With <Del>  you
can close the selected window.  (hotkey <Alt+0> ).

3.10.9 Project
--------------

With this function you can select the project window (See Section 3.10.9
window). If it was closed, it will be opened.

3.10.10 UserScreen
------------------

This shows the contents of the DOS-Screen. To leave this function, do any
event, that means, press any key or click with the mouse. (hotkey <Alt+F5> )

3.11 Help
=========

In this menu you have access to many predefined help entries in the big
helpsystem.

3.11.1 Help
-----------

This opens the INFO viewer. Many thanks at this point to Salvadore Eduardo
Tropea (SET). He wrote the very good INFO viewer for use with RHIDE. This was
also the most important reason for me to write the documentation in Texinfo,
because you have now an online help available with the produced INFO file
`rhide.inf'.

The help system can be invoked from everywhere by pressing <F1> . For help on
using the INFO viewer, press <F1>  within the help window.  But the above
things work only if you have correctly installed the INFO files that come
with RHIDE.

If you have installed the binary archive of RHIDE as described in the
`readme.bin', the INFO files are in `%DJDIR%/info'. If you have not modified
your `djgpp.env' file, this directory is searched for the INFO files.

But you can put the INFO files in any directory you want, if you add this
directory to the %INFOPATH% variable in your `djgpp.env' file in the section
for `info'.

3.11.2 RHIDE Help index
-----------------------

This brings up the help window with the main index for getting help for RHIDE.

3.11.3 Syntax help
------------------

If you are in an editor window, and you press <Ctrl+F1> , you get help about
the function under the cursor.  But only if this function is documented in
`libc.inf'. If there was no help found you will be informed.  This feature
can be used also by clicking with the right mouse button on the word.

3.11.4 libc reference
---------------------

This is a separate menu entry to open the libc reference, because this is
used very often when writing C programs.

3.11.5 Help about help
----------------------

This brings up a helpwindow for instructions and available keystokes when
using the integrated INFO viewer.  (See  in "infview.inf", or point your Web
browser to http://INFO Viewer)

4. Detailed description of some parts of RHIDE
**********************************************

4.1 Selecting a window
======================

To select a window you can do the following. If the window has a number, this
is right on the top-frame, you can select this window by pressing <Alt>  and
this number (but only if the number is a single digit).  Or you click
anywhere in the window or on the frame of the window with your mouse.

4.2 How the editor works
========================

This section should describe the work of the editor. But because the editor
is now so complex and not my own work, there is now a separate documentation
for it. Look at See Documentation for the editor in "SET's editor", or point
your Web browser to http://editor.html for a detailed and better doc. But you
can read also more from my doc, which describes the most common (for me)
usage of the editor.

Here I describe most of the editor commands. If there is a key command like
<Ctrl+Q+Y>, you have to press <Ctrl> and <Q> simultaneously and after this
press <Y>.

4.2.1 Erasing commands
----------------------

   * <Ctrl+G>  or <Del>

       erases the character under the cursor or the selected text

   * <Ctrl+H>  or <Backspace>

      erases the character before the cursor or the selected text

   * <Ctrl+Y>  erases the current line

   * <Ctrl+Q+Y>  erases from the cursor to the  end of the line

   * <Ctrl+Q+H>  erases from the cursor  to the beginning of the line

   * <Ctrl+T>  erases from the cursor to  the beginning of the next word on
     this line

   * <Ctrl+Backspace>  erases from the  cursor to the beginning of the
     previous word

4.2.2 Cursor moving commands
----------------------------

   * <Ctrl+S>  or <Arrow left> moves the cursor one character left

   * <Ctrl+D>  or <Arrow right> moves the cusor one character right

   * <Ctrl+E>  or <Arrow up> moves the cursor one line up

   * <Ctrl+X>  or <Arrow down> moves the cursor one line down

   * <Ctrl+A>  moves the cursor one word left

   * <Ctrl+F>  moves the cursor one word right

   * <Ctrl+C>  or <Page down> moves the cursor one page down

   * <Ctrl+R>  or <Page up> moves the cursor one page up

   * <Ctrl+Q+D>  or <End> moves the cursor to the end of the line

   * <Ctrl+Q+S>  or <Home> moves the cursor to the beginning of the line

   * <Ctrl+Q+R>  or <Ctrl+PgUp>

     or <Ctrl+Home> moves the cursor to the beginning of the file

   * <Ctrl+Q+C>  or <Ctrl+PgDown>

     or <Ctrl+End> moves the cursor to the end of the file

4.2.3 Text selecting and searching commands
-------------------------------------------

   * <Shift>  cursor keys select the text like the cursor moves

   * <Ctrl+Ins>  or <Ctrl+K+K>  copy the selected text to the clipboard

   * <Shift+Del>  or <Ctrl+K+Y>  move the selected text to the clipboard

   * <Shift+Ins>  or <Ctrl+K+C>  copy the selected text from the clipboard to
     the current cursor position

   * <Ctrl+Del>  delete the selected text

   * <Ctrl+Q+A>   open the replace dialog

   * <Ctrl+Q+F>  open the find dialog

   * <Ctrl+L>  repeat the last replace or find operation

   * <Ctrl+K+H>  unselect all

4.2.4 Block commands
--------------------

   * <Ctrl+K+B>  this sets the start of the selected block

   * <Ctrl+K+K>  this sets the end of the selected block

   * <Ctrl+K+I>  this indents the selected block by inserting a space at the
     beginning of each line inside the block

   * <Ctrl+K+U>  the unindents the selected block by erasing from each line
     inside the block, which starts with a tab or space one character.

   * <Ctrl+K+M>  this converts all alpha characters inside the selected block
     to upper case

   * <Ctrl+K+O>  this converts all alpha characters inside the selected block
     to lower case

   * <Ctrl+K+V>  this moves the selected block to the current cursor position

   * <Ctrl+K+Tab>  this is indents the selected block by using the last
     nonselected line as reference for indenting.

   * <Ctrl+K+Shift+Tab>  this unindents the selected block by using the last
     nonselected line as reference for unindenting

   * <Ctrl+K+R>  Inserts the contents of a file at the current cursor position

   * <Ctrl+K+W>  Write the selected block to a file

4.2.5 Other commands
--------------------

   * <Ctrl+V>  toggle insert-/overwrite-mode

   * <Ctrl+O>  toggle auto-indent-mode on/off

   * <Ctrl+J>  goto to line (will be prompted for)

   * <Ctrl+K+>  a digit (<0> - <9>). Set a marker in the text (up to ten
     different markers)

   * <Ctrl+Q+>  a digit (<0> - <9>). Jump to a marker, which you have
     previously set.

   * <Shift+Space>  this executes a macro, which can be defined external by
     analyzing the last two characters before the cursor (See Section 4.13)

If you have set some markers, they will be stored, so you can use them later
when restarting RHIDE.

4.3 Some hints and problems
===========================

To compile only a single file, you don't need to include it in a project.
You only have to open it and do a compile. If a file is in your project, you
can compile it, if you are in its editor-window or if you are in the
project-window and this file is selected.

Warnings and errors from compiling a file are listed in the message-window.
If there are warnings or errors, you can jump to the corresponding source by
hitting <ENTER>  on this message. If this file wasn't already opened, it will
be opened.

4.3.1 Problems with automatic dependencies
------------------------------------------

Most checking of the dependencies works correctly, but there are some few
situations, where this checking gets confused. The first results in the fact
that I implemented a cache function for getting the modification time of
files, that means, most files are 'stat'ed only once, after starting RHIDE.
But if someone modifies one of the files, which are in the cache, (this can
be an other program, when you run RHIDE in a multitasking environment, such
Windows) or if you run your project and it modifies some of these files, the
internal cache is after this not up to date.

Here is an other situation. Your source files are not in the current
directory. You have opened a source file for editing and successfully built
your project. Now you leave RHIDE, because you want to debug your program
with `fsdb', you copy the source file (in this case it is the file, which you
have opened in the IDE) to the current directoy. Now you debug it and there
are some errors. You restart RHIDE to make the changes in the file. The
previously opened file will be opened automatically and you edit it. If you
do now a *Make*, RHIDE tells you, that your project is up to date, because it
searches for source files at first in the current directory, and there is the
unmodified file.

In this chapter I will give you for some special parts a more detailed
description of what they do.

4.4 Project window
==================

The project window shows you every file, which you have included in your
project. Most time you work with RHIDE this window should be visible, but you
can also close it (See Section 3.10.7).

4.4.1 Items of your project
---------------------------

The items in the project window, and therefore also in your project, are
sorted in alphabetical order. This has the effect of faster finding an item
and you can also move the selecting bar to a specified item by typing the
name of this item.

Normally, the alphabetic order of the project items causes no problems because
the linker searches at first *every* object file for unresolved symbols
before any library. The statement, the the GNU linker is a one pass linker
makes sense only for libraries, because they are checked only once for
unresolved references. That means, if you include libraries in your project
you must know about the order, where this library is put on the command line
when linking your program.

If you have problems with that order, or if you really want to have one
object file (or library) before some others, you have to rename them, to get
the right position from the name.

4.4.2 Open a project item
-------------------------

To open an editor window with the selected item press either <SPACE> or
<ENTER> . If here was already a window with this file opened on the desktop,
this window will be selected. This works only if the selected item has a know
suffix (See Section 2.1). If the selected item is a project file, that
project will be opened with the side effect that if you close this project,
the previous one will be reopened.

4.4.3 Dependencies of project item
----------------------------------

If you have compiled a file already in RHIDE, you bring up a list with all
dependencies of that file. In this list the files are show by their basename
followed by the directory and they are also sorted in alphabetical order.
From here you can also open an editor window with the selected dependency by
pressing <SPACE> or <ENTER>  on that item.

4.4.4 Local options for a project item
--------------------------------------

You can change many options for a project item, which are in effect only for
this file. To do this, hit <Ctrl+O>  on the selected item and a dialog is
shown, where you can change the options.

At this time you can change the following options.

Local comandline options
........................

Here you can give some additional defines or any other commandline options,
when compiling this item.

Exclude from link
.................

This is a switch to tell RHIDE, that this file should not linked with your
program, but it is compiled and it is checked to determine if your program is
up to date.

Name of the output file
.......................

Here you can specify an other name as the compiled file. Put here only the
basename of the file (without any directory)

Compiler type
.............

From that list you can select exactly one type of the compiler, which is used
to create your output file. Possible values are:

`Auto'
     This is the default and should be used in most cases. When this type is
     selected, RHIDE selects the correct compiler depending on the suffixes
     of your source and output file.

`User'
     If you have any special compiler, which is not known to RHIDE, to create
     your output file, you must select this and give RHIDE also the calling
     syntax of that compiler (see below)

`None'
     If you don't want to compile this item select this.

`GNU C compiler'
     Tell RHIDE to compile this file like a normal GNU C source file.

`GNU C++ compiler'
     Tell RHIDE to compile this file like a normal GNU C++ source file.

`GNU assembler'
     Tell RHIDE to compile this file like a normal GNU assembler file.

`GNU Pascal compiler'
     Tell RHIDE to compile this file like a normal GNU Pascal file.

If you have selected the User compiler type, you have to put in the next
inputline the specs how to call the compiler. This specs can use any
variables that are known to RHIDE (See Section 4.6) together with normal
text. As an example I show here, how the builtin C compiler is defined (the
backslashes at the end of the lines are used only here to show, that the line
is continued, they are NOT part of the specs):


$(RHIDE_GCC) $(INCLUDE_DIRS) $(C_DEBUG_FLAGS) $(C_OPT_FLAGS) \
$(C_WARN_FLAGS) $(C_C_LANG_FLAGS) $(C_EXTRA_FLAGS) $(LOCAL_OPT) \
-c $(SOURCE_NAME) -o $(OUTFILE)

Error checking
..............

Here you can select how  errors or warnings that  are produced by the
compiler, are checked. Possible values are:

`Auto'
     Let RHIDE select the correct way for checking the errors

`User'
     Use your own external program to check the output of the compiler to
     `stderr'

`None'
     Do not check any errors, assume that the compiler does it's job every
     time successfull

`builtin C'
     Check the errors like when compiling a C file

`builtin assembler'
     Check the errors like when copiling an assembler file

`builtin linker'
     Check the errors like when linking

`return value'
     Determine only if the compiling was successfull or not by checking the
     return value of the compiler (zero for success)

Error program
.............

If you have selected above the User error checking, type here the program,
which should check for errors and/or warnings.  What the external error
checking program should do:

   - The program must take a filename as argument, which contain the output
     to stderr from the compiler (Error and warning messages)

   - The program has to write to stdout the Warnings, Errors or messages in a
     special format.

    `Errors'
          A line that starts with the string "!Error" (without the double
          quotes) optionally follwed by "!File" and a filename in single
          quotes and "!Line" and a line number.  The next line contain the
          error text.  Example:


          !Error!File'test.c'!line17
          This is a sample error message

          This means, that in file 'test.c' at line 17 has an error occoured
          with the description 'This is a sample error message'

    `Warnings'
          Warnings have the same format, except that !Error is replaced by
          !Warning.

    `Any other line'
          is treated as a simple message optionally preceeded by !File and
          !Line.

4.5 Builtin compiler specs
==========================

RHIDE uses for compiling, linking, and the other stages of generating a file
also specs, like you can change in the local options for a project item (See
Section 3.8.5). Here the specs, which are used currently:

$(RHIDE_COMPILE_C)
     For compiling C source files

$(RHIDE_COMPILE_CC)
     For compiling C++ source files

$(RHIDE_COMPILE_ASM)
     For compiling assembler source files

$(RHIDE_COMPILE_PASCAL)
     For compiling pascal source files

$(RHIDE_COMPILE_OBJC)
     For compiling objective C source files

$(RHIDE_COMPILE_LINK)
     For linking

$(RHIDE_COMPILE_LINK_PASCAL)
     For linking when the project contain pascal source files

$(RHIDE_COMPILE_LINK_PASCAL_AUTOMAKE)
     This spec is used only, when you have set the (See Section 3.8.8), to
     tell RHIDE, not to check for dependencies but to use the 'automake'
     feature of GPC.

$(RHIDE_COMPILE_ARCHIVE)
     For creating a library

$(RHIDE_FSDB)
     For calling fsdb.

$(RHIDE_GDB)
     For calling gdb.

$(RHIDE_GPROF)
     For calling gprof.

$(RHIDE_GREP)
     For calling grep.

All of these specs have a default contentents in RHIDE, but they can be
overwritten by setting the environment variable with the same name and any
other contents.

4.6 Builtin variables
=====================

This section describe, which variables can be used within RHIDE to get values
from some of the configurations, which you have made inside RHIDE.

All of these variables are refernced by a name enclosed in parantheses
preceeded by a dollar sign. Example: `$(RHIDE_GCC)'. You can overwrite any of
the following variables, if you define in your environment the same variable
with any contents you want.

When RHIDE tries to get the contents of such a variable, it searches at first
if it is found in it's internal database. If it was not found, the environment
is checked for such a variable and if that fails, the resulting value is the
variable itself.

In addition to the use of variables, RHIDE has a limited ability of using
string manipulating functions. I have implemented some of the functions,
which are available with GNU make. They have the same name and should work
exactly like the GNU make counterpart.

`$(strip arg)'
     This function removes any leading and trailing whitespace and converts
     all multispaces to single spaces from the (whitespace separated list)
     `arg'.

`$(addsuffix arg1,arg2)'
     These functions append on each argument from the whitespace separated
     list `arg2' the string `arg1'.

`$(addprefix arg1,arg2)'
     This is the same as `$(addsuffix arg1,arg2)', except that it puts the
     string `arg1' before each argument from `arg2'.

`$(notdir arg)'
     This removes any directory part from the argument `arg'.

`$(dir)'
     This extracts only the directory part from the argument `arg'. If there
     was not directory in `arg', an empty string is returned. (The directory
     contains also the drive letter, if there was one)

`$(subst arg1,arg2,arg3)'
     This replaces every occoureance of `arg1' in `arg3' with `arg2'

The following variables have a special meaning in RHIDE with the default
contents:
$(RHIDE_GCC)
     gcc

$(RHIDE_AS)
     gcc

$(RHIDE_GXX)
     gcc

$(RHIDE_GPC)
     gpc

$(RHIDE_AR)
     ar

$(RHIDE_LD)
     gcc

$(RHIDE_LD_PASCAL)
     gpc

$(RHIDE_ARFLAGS)
     rcs

$(RHIDE_INCLUDES)
     $(SPECIAL_CFLAGS) $(addprefix -I,$(INCLUDE_DIRS))

$(RHIDE_LIBDIRS)
     $(addprefix -L,$(LIB_DIRS))

$(RHIDE_LIBS)
     $(addprefix -l,$(LIBS))

$(RHIDE_LDFLAGS)
     $(SPECIAL_LDFLAGS) $(addprefix -Xlinker ,$(LD_EXTRA_FLAGS))

$(RHIDE_COMPILE_C)
     $(RHIDE_GCC) $(RHIDE_INCLUDES) $(C_DEBUG_FLAGS) \
     $(C_OPT_FLAGS) $(C_WARN_FLAGS) $(C_C_LANG_FLAGS) \
     $(C_EXTRA_FLAGS) $(LOCAL_OPT) -c $(SOURCE_NAME) \
     -o $(OUTFILE)

$(RHIDE_COMPILE_CC)
     $(RHIDE_GXX) $(RHIDE_INCLUDES) $(C_DEBUG_FLAGS) \
     $(C_OPT_FLAGS) $(C_WARN_FLAGS) $(C_CXX_LANG_FLAGS) \
     $(C_EXTRA_FLAGS) $(LOCAL_OPT) -c $(SOURCE_NAME) \
     -o $(OUTFILE)

$(RHIDE_COMPILE_ASM)
     $(RHIDE_AS) $(RHIDE_INCLUDES) $(C_DEBUG_FLAGS) \
     $(C_OPT_FLAGS) $(C_WARN_FLAGS) $(C_EXTRA_FLAGS) \
     $(LOCAL_OPT) -c $(SOURCE_NAME) -o $(OUTFILE)

$(RHIDE_GPC_FLAGS)
     $(RHIDE_INCLUDES) $(C_DEBUG_FLAGS) $(C_OPT_FLAGS) \
     $(C_WARN_FLAGS) $(C_P_LANG_FLAGS) $(C_EXTRA_FLAGS)

$(RHIDE_COMPILE_PASCAL)
     $(RHIDE_GPC) $(RHIDE_GPC_FLAGS) $(LOCAL_OPT) \
     -c $(SOURCE_NAME) -o $(OUTFILE)

$(RHIDE_COMPILE_LINK)
     $(RHIDE_LD) $(RHIDE_LIBDIRS) $(C_EXTRA_FLAGS) \
     $(RHIDE_LDFLAGS) -o $(OUTFILE) $(OBJFILES) \
     $(LIBRARIES) $(RHIDE_LIBS)

$(RHIDE_COMPILE_LINK_PASCAL)
     $(RHIDE_LD_PASCAL) $(RHIDE_LIBDIRS) $(C_EXTRA_FLAGS) \
     $(RHIDE_LDFLAGS) -o $(OUTFILE) $(OBJFILES) \
     $(LIBRARIES) $(RHIDE_LIBS)

$(RHIDE_COMPILE_LINK_PASCAL_AUTOMAKE)
     $(RHIDE_LD_PASCAL) $(RHIDE_LIBDIRS) $(RHIDE_LDFLAGS) \
     -o $(OUTFILE) \
     --automake=\"$(strip $(RHIDE_GPC_FLAGS))\" \
     $(RHIDE_GPC_FLAGS) $(SOURCE_NAME) $(LIBRARIES) $(RHIDE_LIBS)

$(RHIDE_COMPILE_ARCHIVE)
     $(RHIDE_AR) $(RHIDE_ARFLAGS) $(OUTFILE) $(OBJFILES)

$(RHIDE_FSDB)
     fsdb $(OUTFILE) $(addprefix -p ,$(SRC_DIRS)) $(PROG_ARGS)

$(RHIDE_GDB)
     gdb $(OUTFILE) $(addprefix -d ,$(SRC_DIRS))

$(RHIDE_GREP)
     grep -n $(prompt arguments for GREP)

$(RHIDE_GPROF)
     gprof $(OUTFILE)

The following are not used as real variables, but they are used to get the
contents of options from RHIDE. But you can override them also by setting
them as an environment variable.

$(INCLUDE_DIRS)
     All the include directories

$(LIB_DIRS)
     All the library directories

$(SOURCE_NAME)
     The actual compiled source file

$(OUTFILE)
     The actual created file

$(C_DEBUG_FLAGS)
     All the debugging flags

$(C_OPT_FLAGS)
     All the optimization flags

$(C_WARN_FLAGS)
     All the warning flags

$(C_C_LANG_FLAGS)
     All the C language flags

$(C_CXX_LANG_FLAGS)
     ALL the C++ language flags

$(C_P_LANG_FLAGS)
     All the pascal language flags

$(LIBS)
     All the libraries, which are given in the libraries options

$(LD_EXTRA_FLAGS)
     All the additional linker options

$(LOCAL_OPT)
     All the local options for that project item

$(OBJFILES)
     All the destination files, which are part of the project and which are
     not a library and not excluded from linking

$(LIBRARIES)
     All the libraries, which are explicit included in the project and not
     exlcuded from linking

$(SPECIAL_CFLAGS)
     Some special flags for `gcc'. Currently only the `-nostdlib' switch.

$(SPECIAL_LDFLAGS)
     Some special flags for `gcc' when linking. Currently only the switches
     `-pg' and `-nostdlib'.

$(prompt TITLE)
     RHIDE prompts for arguments which get the title `TITLE' and insert the
     parameters here.

4.7 Change the defaults of RHIDE
================================

If you have special wishes for compiling your source files, you can configure
for RHIDE mostly everything. For adding support for other than the builtin
known file types (See Section 4.6). If you want to change the behaviour of
RHIDE for compiling all the known file types you should know at first really
what you do. If you think, this is a good idea or if you only want only check
if it works you can do it.

Before RHIDE compiles any file (this includes also linking and building a
library) it searches the environment for a variable after the following
scheme: When compiling a file with suffix `.c' to a file with suffix `.o'
RHIDE checks for the variable $(RHIDE_COMPILE.c.o). If this variable is
defined the contents of this variable is taken as the compile spec.

If you want to change the specs for linking you must take as destiniation
suffix `.exe' or `.' and as source suffix the suffix of your object files.
Example:

$(RHIDE_COMPILE.o.)

4.8 Message window
==================

This window shows every time you compile a file the resulting messages, which
gcc produces. These messages were converted in a special format to show them
in the window. Some of the messages contain a file eventually combined with a
line number. If you press <ENTER>  on such a message, the corresponding
source line in the file will be highlighted and the window with this file
will be selected. If this file is not already on the dektop, it will be
opened.

If the file, to which the messages refer, is already in the foreground you can
see the selected source line for your messages directly on the screen.

4.9 Syntax highlighting
=======================

Syntax highlighting is now supported directly by the editor. It should work
in mostly every situation for all the supported types. Currently (in RHIDE)
only the C/C++ style syntax highlight and the Pascal style syntax highlight
are supported.

With which style a file is highlighted is choosen by RHIDE by checking the
suffix of the file and determining the file type from that suffix.  (See
Section 2.1)

4.10 Checking the dependencies
==============================

This is one of the main parts of RHIDE. To speed up the work, I have added a
cache for checking the modification time of a file and for finding a file
(computing the full name of a file). But sometimes the data in the cache
isn't valid, especialy when running under Windows. If you see this, you can
clear the cache by leaving RHIDE and starting again.

If you didn't any special things but have problems with it, please run RHIDE
with the `-df' switch and try to find out, where the problem is and post it
to me so I can fix it.

4.11 What is Turbo Vision
=========================

The Turbo Vision library is part of Turbo C++ version 3.1. I have ported this
library to use with DJGPP because I think it is the most powerful text
windowing library, which is available for MS-DOS. With the help of this
library you can write front end application which looks very well and the
interface is easy to use.

The Turbo Vision library is not only a window based text user interface, it
is also a very good event handling mechanism. It supports the use of the
mouse and keyboard with the ability of defining and using of hotkeys, that
means, you can assign to some keys or combinations of keys, which function
should be executed.

The main parts of an application, which is using this library, are the
desktop, the menu bar and the statusline. The menu bar is usualy shown as the
topmost line of the screen. There are shown the main parts of the pull down
menus, from where you can select the most functions, which are implemented in
an application.

To use the menu you can use the mouse as well the keyboard. With the mouse
you can click every where on a menu entry and the corresponding function will
be executed. There are some different actions, which a menu entry can have.
At first some of them, these are for example all the entries in the menu bar,
open a submenu with more menu entries which are related to the name of this
main entry. And the others, most in such a submenu, execute a definite
function of the application.

With the keyboard you can walk through the menu very simply. To activate the
menu bar, you have to press <F10> . In the pull down menus you can use the
cursor keys to move the highlighted bar up and down and with the cursor right
and left keys you can switch to next or previous menu. With the <ENTER>  key
you activate the function, which corresponds to this entry. If this was a
submenu, which is indicated with a symbol like a small right arrow, this will
be opened.

If you walk through the menu with the cursor keys or the mouse (hold the left
mouse button down and move the mouse) in the statusline will be shown for
each entry a short hint for the function of this menu entry.

4.12 How the dialogs work
=========================

In a dialog, like the file open dialog, are many things which you can select
or where you can type in some data. At first some general functions. If you
press <ESC> , the dialog will be closed and nothing will be changed. The same
can be done with the mouse by clicking on the close symbol (this is the small
symbol on upper left frame of the dialog).

In the next paragraphs I will describe the most used elements of a dialog.
For selecting each element of a dialog you can use the <Tab> key to select
the next element in the dialog or the <Shift+Tab> key, to select the previous
element.

A button is a rectangle with some text on it. If you activate such a button a
specified action is executed. To select a button you can use the <Tab> key,
until the button is special highlighted and press then <ENTER> . Or most
times a character of the text on this button has a different color. So you
can press <Alt+> this charcter to activate the button. With the mouse you can
simply click on a button to activate it.

A listbox is a collection of some strings in one or more columns and rows as
needed. The project window (See Section 3.10.9 window) is such a listbox with
the names of the project items. You can use the cursor keys to move the focus
bar in the list, or if it is a sorted listbox, you can also type some
characters and the focus will moved to the item, which starts with this
characters. To select a item in a list box, press <SPACE> or <ENTER>  or
double click with mouse on it.

In an input line you can type some text which can be edited with the usual
editing keys.

A checkbox is a collection of options, which can be turned on or off.  Each
option has in front of it a small indicator, if it is turned on (an X is
shown) or not (the X is not shown). To toggle such an option, use the cursor
keys to move the focus to the option you want and press <SPACE> . If a
character in an optionstring is highlighted you can press this key and the
option will be turned on or off or click with the mouse on the option.

Radiobuttons are similar to checkboxes, but there you can select only one of
all the shown options.

4.13 Defining macros
====================

Please look for a detailed documentation here: See Documentation about Pseudo
Macros in "SET's editor", or point your Web browser to http://editor.html

4.14 The INFO Viewer
====================

The integrated helpsystem of RHIDE is based on the INFO Viewer written by
Salvador Eduardo Tropea (SET) <ice@inti.edu.ar>. It gives you access to all
the INFO files which you have installed in the correct directories like for
`info.exe'.

To get help about the INFO Viewer hit <F1>

when the helpwindow is opened or follow this link See Section 'Top' in
documentation for 'The Info Viewer'.

In addition to getting help with this system you can also copy text from the
helpscreen to the clippboard. This is usefull if you want for instance to
copy an example from the libc reference in your program. This feature is not
so powerfull like in the editor, but it is good enough. To mark some text use
the <Shift> and cursor keys and copy the selected text with <Ctrl+Ins> to the
clipboard.

In RHIDE you have also the possiblility to get help about a specific
function. Currently this works only for functions, which are documneted in
the libc reference. For doing this, move the cursor to the function and hit
<Ctrl+F1>  or click with the right button of the mouse on that word.

5. Debugging with RHIDE
***********************

For debugging your programs you need now no external debugger, because RHIDE
has one integrated. The integrated debugger is not code which I have written,
but it is GDB 4.16, which is linked in RHIDE.

Because RHIDE uses a special method to communicated with GDB it is currently
not possible to use all of the features, which GDB has. I have implemented at
this time the most important functions, which are needed to debug your
program. So it is not possible to give GDB the same commands as when running
GDB standalone. That means, if you need any very special feature of GDB you
have to run GDB.

The integrated debugger is a real source level debugger like GDB. If you step
trough your program you will see every time exactly where in the sources you
are. But to use the aibility to debug your program needs, that you have
compiled your source files with debugging information and this symbols must
not be stripped from the executable.

5.1 Limitations of the integrated debugger
==========================================

Because the integrated debugger is GDB, you will have all the limitations
which GDB has in addition to well known DJGPP and/or MS-DOS limitations.
Here is a (not completely) list of known misfeatures:

   * Signals are not handled every time correct by distinguishing between the
     debuggee and RHIDE

   * Remote debugging is NOT supported

   * Debugging of graphic programs may work or not depending on the software
     you are using. Currently only the VESA modes and the standard VGA
     graphic modes are supported.

   * When using the integrated debugger under Windows 3.1x (in Windows 95
     there is no such limitation) the number of breakpoints is limited to 3,
     because you can use there only hardware breakpoints. The i386 supports
     only 4 hardware breakpoints and 1 is needed for internal use.  This is a
     common problem for all DJGPP debuggers. (Try to use FSDB with more than
     3 breakpoints under Windows 3.1x)

   * Sometimes the source line, which is shown by RHIDE in assuming that the
     execution is there, is not correct. But this is NOT a bug of RHIDE and
     NOT of GDB. This is a bug in GCC which produces wrong line number
     information in the object files. Here is a very simple test program,
     with which you can see this problem.

          /* This is an example, that gcc produces wrong line number
             information for code which is optimized out. (compile this
             with -O) */
          
          int a = 1;
          int b = 2;
          
          int main()
          {
            if (a == b) return 0;
            if ((a + 1) == b) return 1;
            return 0; /* The debugger should never come here,
                         but it comes */
          }

5.2 Dual display debugging
==========================

RHIDE supports now also to use an installed dual display. This is when you
have installed in addition to your VGA card a monochrome display card
together with a monitor. RHIDE checks this by asking the BIOS if it is
present and if this is true and the option is enabled (See Preferences) then
RHIDE switches automatically to the secondary display when debugging and your
program will run on the primary display.

With this debugging technique you will get the best debugging results
especially when debugging graphics programs.

To use the dual display with RHGDB use the `-D' switch for RHGDB.

5.3 Using the integrated debugger
=================================

If you are familiar with Borland's debugger, you will see, that most of the
function of that debaugger are implemented in the same or in a similar way
(this includes the key bindings).

5.3.1 Stepping trough the source code
-------------------------------------

For stepping trough your code, there are three ways. This is at first the
Step-function <F8>. With this you execute a complete source line. If there is
a function call at the current execution point, this function is called
without debugging it. This technique is the same like the `next'-command from
GDB.

The next way is the Trace-function.  It does the same like the Step-function
<f7>, except if there is a function call at the current execution point, you
will go into this function, if there is debugging information for that
function available.  This technique is the same like the `step'-command from
GDB.

And the third way is the Goto-Cursor-function. For this, move the cursor to
the line in yur source code and press <F4>. Now the execution of your program
is continued until it comes to that line. Sometimes you will get an error
message, that for the specified line is no code generated.  This comes from
the optimization of yor code by GCC. In this case try a line below or above.

5.3.2 Evaluating the contents of variables
------------------------------------------

You can evaluate also the the contents of variables, when your program has
been started. For this you can press <Ctrl+F4> and you will see a dialog,
where you can type in the expression to evaluate, a line with the result and
a line, where you can give the expression a new value. If you have pressed
this in an editor window, RHIDE tries to find the a word under the cursor and
copies this as default in the expression-inputline. To get the contents of
this expression you have to press the *Evaluate*-button.

If the expression could not be evaluated so it is shown in the result line.
For the exact syntax of getting the contents of an expression See Section
'Expressions' in documentation for 'gdb'. You can also show the value of the
expression in several formats See Section 'Output Formats' in documentation
for 'gdb'.

In addition to the functionallity of the Borland debuggers, GDB (and of
course also RHIDE) can evaluate the result of function calls. If you have for
example in your debugged program a function
     int foo(int arg1)
     {
     /* do something and return a value */
     }
defined, you can type in the expression inputline
foo(16)
and you will get as result, what the function would return, if it is called
with the argument `16'. As arguments you can also use any known variable or
complex expressions.

A known limitation is, that the expressions are NOT checked for validity.
That means, you can produce any exception there, which will terminate your
program. As an example type in the expression inputline
3/0
And, of course, you cannot assign to a function call a new value.

As an special side effect you can use this also as a calculator. You can
evaluate any trivial or complex expression and this is also available, if you
didn't started the integrated debugger.

5.3.3 Watching the contents of variables
----------------------------------------

In addition to a single look at the contents of a variable, you can add the
variable to a list which is updated after each debugger step and is shown in
the watching window. For this function you can use the hotkey <Ctrl+F7> .

Within the watch window you can press <Enter> on an expression to change that
expression (NOT the contents of that expression) or you can press <Del>  to
remove the variable from the watch window.

5.4 Problems with C++ programs
==============================

Because GDB cannot handle correct C++ debugging information you will have
many problems when debugging C++ programs to get the contents of a variable
when it is a member of a class. Because GDB does not detect, that your
program is a C++ program, it sees it as a normal C program and so GDB does
nothing know about classes and all what have to do with it.

For accessing the member of a baseclass you must do some tricks. Let me
explain it on an example:

     class A
     {
     public:
       int a;
     };
     
     class B : public A
     {
     public:
       void test();
     };
     
     void B::test()
     {
       fprintf(stdout,"%d\n",a);
     }

If you debug the program in the function `B::test()' and you want to get the
contents of the member `a', you have to access it with `this->A.a' !!! That
means: At first you must access all members with the implicit `this' variable
and at second you must give all baseclasses until that, where the member was
declared.

5.5 Using Breakpoints
=====================

Breakpoints are a very usefull thing when debugging a program. You can set a
breakpont at any location of your program and run it. It will be
automatically stopped, if the program execution reaches the breakpoint.

5.5.1 Setting a breakpoint
--------------------------

For setting a breakpoint there are two different ways. The first is by
setting a breakpoint at any line by pressing <Ctrk+F8> . You will see, that
there is a breakpoint set, that this line is shown in an other color. If you
hit <Ctrl+F8>  on a line, which has already a breakpoint, the breakpoint at
this line is removed.

5.5.2 Modifying and setting a breakpoint
----------------------------------------

The second way is by setting a breakpoint with the breakpoint dialog which is
selectable only from the menu. There you will see any breakpoint for your
program. These breakpoints can be modified now in many things.  In this
dialog you can enable/disable a breakpoint. This is not the same as deleting
and resetting it. If you disable a brekpoint, it is stored internal but it is
not used. If you enable it again all the sttings for that breakpoint, which
you have already made, are remembered.

In the breakpoint dialog you can also set or delete a breakpoint with the
given buttons. If you want to set a new breakpoint, use the New-Button. Then
you will get a dialog which you also get when you press the Modify-Button. In
this dialog you can change many things of the breakpoint.

In this dialog is the only point for setting a breakpoint at a specified
function. For doing this you must set at first the type of the breakpoint to
Function. Then you can type in the function inputline the name of the
function or hit <Ctrl+F1>

to get a list of functions which are available from where you can select one
with <Enter>.

For setting a breakpoint at a specified line, set the breakpoint type to Line
and type in the filename and the linenumber.

The next what you can modify on a breakpoint is a condition. That means that
the breakpoint should stop your program only, if the condition is true. Write
the condition in the programming language of your source file and you can use
any accessable variable and you can call also functions of the debugged
program. For other information about the syntax See Section 'Conditions' in
documentation for 'gdb'.

And at last you can give your breakpoints also a count. A breakpoint count is
a number, how often this breakpoint is ignored. That means, if you type there
for example 10, then the RHIDE stops the execution of the program only, if it
comes to that point the 10th time. WARNING: This count is set by RHIDE only
once. After the breakpoint is realy hit, from now on the breakpoint stops
your program every time, the breakpoint is reached.

5.5.3 Problems with breakpoints
-------------------------------

Currently there is a big problem, when you have set a breakpoint at a line
(not at a function) of your program and you edit now the source code. If you
insert or delete some lines the breakpoints, which are set at lines after or
at the modified lines are NOT updated to the correct line number.

6. Debugging with RHGDB
***********************

In addition to RHIDE, which has an integrated debugger, there is also a
standalone debugger called RHGDB. (The name comes from my initials and GDB)

RHGDB has the same aibilities like RHIDE for debugging your program. But it
has no editor. The source files are shown in read only windows where you can
move the curser and other things (except editing) like in RHIDE.

The menu tree is anolog to RHIDE but (of course) it has not all the menu
entries of RHIDE, becuse RHGDB should be used only for debugging and nothing
else.

I have written it to debug DJGPP programs, for which there is no RHIDE
project file available but the program has debugging information and, if you
are small of memory, it is much smaller than RHIDE.

The syntax for using RHGDB is very simple. Run it with your program as the
first argument followed by any argument, which should be passed to your
program.

RHGDB saves and reads the options from files with the suffix `.rgd'.  This
done automatacly when you run RHGDB with your program as argument by
searching a file with the same basename of your program and the suffix `.rgd'
and in this file the options are also automaticaly stored, when you exit
RHGDB.

Alternatively you can also save/read the options from within RHIDE by
selecting the corresponding menu entries from the Options menu.

To use the the "Dual display debugging" feature of RHGDB you must give on
commandline the `-D' switch.

7. Some FAQs
************

**Question*: I have enabled the `Use tabs' option, but if I move the cursor
through that tab, it seems, that RHIDE uses spaces*

*Answer*:This behaviour cannot (currently) not changed. Even when you have
enabled the use of real tabs (charcaters with the code 9), the cursor is
moved like as there are spaces.

**Question*: If I write an ALL UPPERCASE TEXT while pressing down the shift
key and typing the characters, the SPACE key is not recognized*

*Answer*: This correct, because RHIDE uses as default the key combination
<Shift+Space> for executing a Pseudo Macro (See Section 4.13).  If you don't
like this behaviour, or when you also want to change some other keybindings,
please read in the documentation about the editor, how you can configure the
keybindings.

See Documentation about the keyboard in "SET's editor", or point your Web
browser to http://editor.html

**Question*: Are there any sample project files, to show how RHIDE works?*

*Answer*:The sources of RHIDE include many project files to rebuild at least
RHIDE with itself and many others.

**Question*: I have written some libraries. How can I use them in a project?*

**Question*: How I can use a library, which I got?*

*Answer*: There are some different ways to do this. On the one side you can
include them directly in the project with the *Add to project item* function
(See Section 3.8.3). But if they are not in the current directory, you must
also set the library search path to the directory, where they are. (See
Section 3.9.1.2). The other variant is to include them in the list of
libraries. (See Section 3.9.3)

If this library is created with RHIDE, that means you have a project file for
building this library you can also simply include that project file in you
project. For examples look at the RHIDE sources in the project file for RHIDE.

**Question*: I have a directory, where all my include files are. Can I setup
RHIDE to have this directory every time in the include search path, when
creating a new project?*

**Question*: I prefer the 80x28 video mode over the default 80x25 mode. How I
can turn this mode on by default for all newly created project files?*

*Answer*: You can create a default project file. From this file RHIDE reads
all the options, if it creates a new project. The default project must have
the same basename as the executable of RHIDE and must be located in the same
directory.

The creation of such a default project file is very simple. Change to the
directory, where `rhide.exe' is located and run there
rhide rhide

Now make any changes in the options which you want to have as default for all
new created projects. This includes also settings in the various search
paths. If you are ready, exit RHIDE and this project file will be your
default project file.

**Question*: I know, that I can create a default project file. Can I create
and use more than one?*

*Answer*:Since DJGPP supports a quasi-Unix-like link for executables, you can
create such a link also for RHIDE. As an example I will create a link to
`rhide.exe' with the name `myrhide.exe'. At first I have to create the new
file.
     stubify -g myrhide.exe
Now I must tell `myrhide.exe' which program it really should run.
     stubedit myrhide.exe runfile=rhide
Thats all. Or, if you have installed the GNU fileutils, you can use also now
the `ln.exe' program to create the link:
     ln -s rhide.exe myrhide.exe

**Question*: I don't want to type every time I start RHIDE the commandline -L
DE to use the german user interface. Is there any better way?*

*Answer*: Create an environment variable LANGUAGE with your preferred
language like
     set LANGUAGE=de
and your problem is solved.

**Question*: I have 4 Mb RAM in my computer and every time, when I compile
large files with optimizations enabled, my hard disk is working very hard.*

*Answer*:Buy more RAM!

**Question*: I heard something about a newer version RHIDE. From where I can
get exact information about this?*

*Answer*: See at the RHIDE home page, at this URL:

     http://www.tu-chemnitz.de/~rho/rhide.html

.  This page contains the latest news and the latest version of RHIDE.

**Question*: I have a lot of money and don't know what to do with it. Can you
help me?*

*Answer*: Send it to me, so I can spend more time for developing RHIDE. My
Address is:
     Robert H”hne
     Am Berg 3
     D-09573 Dittmannsdorf
     Germany

**Question*: I think, I found a bug in RHIDE. How can I report it?*

*Answer*:At first try for your own to solve the problem by checking the
documentation.  See at the RHIDE home page, at this URL:

     http://www.tu-chemnitz.de/~rho/rhide.html

, if this problem was already reported by other users. As the next ask the
problem in the news group comp.os.msdos.djgpp Newsgroup, because there may be
some other people with the same problem, and they can give you an answer or
I, because I read this group also.

If this don't help you, do the following:

     Try to reproduce the error with the smallest possible project or source
     file. Run RHIDE with all debugging options enabled and redirect the
     printed output to a file. (See Section 1.5.2) Send me this file and a
     detailed as possible description of the problem and include in your
     report the exact version of RHIDE you are using.

     The exact version is shown in the About-Dialog and means the version
     number together with the build date.


8. Index
********



* Adding a file to the project: Section 3.8.3.
* Additional options for gcc: Section 3.9.5.
* Arguments for your program: Section 3.5.6.
* Assembler files, which must be preprocessed: Section 2.1.
* Automatic dependencies, problems with it: Section 4.3.1.
* Automatic indention:                   autoindent.
* Automatic intention:                   Intelligent C indenting.
* Background colors, 16:                 16 background colors.
* Backup files:                          create backupfiles.
* Blinking colors:                       16 background colors.
* block commands: Section 4.2.4.
* Bug report: Section 3.1.2.
* Bug, reporting it: Chapter 7.
* Build: Section 3.6.4.
* Build the library: Section 3.6.3.
* Building a library: Section 3.8.7.
* Building an executable: Section 3.8.7.
* Builtin calculator: Section 5.3.2.
* Button: Section 4.12.
* C  flags, edit them: Section 3.9.6.7.
* C language specific flags: Section 3.9.2.4.
* C++ flags, edit them: Section 3.9.6.8.
* Caching of files:                      No file caching.
* Calculator: Section 3.1.7.
* Call stack: Section 3.7.5.
* Cascade the windows: Section 3.10.4.
* Change the keybindings: Chapter 7.
* Changing the name of the library: Section 3.8.7.
* Changing the name of the program: Section 3.8.7.
* Changing the search paths for files: Section 3.9.1.
* Checkbox: Section 4.12.
* Checking dependencies: Section 4.10.
* Clear: Section 3.3.7.
* Clearing the dependencies: Section 3.8.9.
* Clearing the project: Section 3.8.10.
* Clipboard: Section 3.3.6.
* Close a project: Section 3.8.2.
* Close a window: Section 3.10.7.
* COFF file, Creating: Section 3.8.7.
* Colors: Section 3.9.6.1.
* Column cursor:                         Column cursor.
* Commandline arguments for your program: Section 3.5.6.
* Commandline options: Section 1.5.
* Compile: Section 3.6.1.
* Compile without a project: Section 4.3.
* Compiler options: Section 3.9.5.
* COMSPEC: Section 3.2.6.
* Configuring RHIDE <1>: Section 4.7.
* Configuring RHIDE: Section 1.2.1.
* Context help: Section 4.14.
* Controlling the optimization of the code: Section 3.9.2.2.
* Controlling the warnings: Section 3.9.2.1.
* Copy: Section 3.3.4.
* Cplusplus options: Section 3.9.2.5.
* Creating a COFF file: Section 3.8.7.
* Creating a makefile <1>: Section 3.8.11.
* Creating a makefile <2>:               all dependencies in makefile.
* Creating a makefile: Section 1.6.
* Creating a new file: Section 3.2.2.
* Creating a new project: Section 3.8.1.
* Creating backup files:                 create backupfiles.
* Cross cursor <1>:                      Column cursor.
* Cross cursor:                          Row cursor.
* Cursor moving: Section 4.2.2.
* Cursor through tabs: Chapter 7.
* Cut: Section 3.3.3.
* CXX options: Section 3.9.2.5.
* Debugging: Section 1.5.2.
* Debugging info: Section 3.9.2.3.
* Debugging RHIDE <1>:                   Show GDB commands.
* Debugging RHIDE:                       show process information.
* Debugging with RHIDE: Section 3.7.
* Debugging, dual display:               Use dual display.
* Debugging, edit the flags: Section 3.9.6.11.
* Default file mask: Section 3.2.1.
* Default language: Chapter 7.
* Default project file: Chapter 7.
* Default project file, more than one: Chapter 7.
* Define your own reserved words: Section 3.9.6.13.
* Defines: Section 3.9.5.
* Delete a file from the project: Section 3.8.4.
* Delete the selected text: Section 3.3.7.
* Deleting commands: Section 4.2.1.
* Dependencies for a file: Section 3.8.6.
* Dependencies in makefile:              all dependencies in makefile.
* Dependencies, checking: Section 4.10.
* Dependencies, problems with it: Section 4.3.1.
* Dialog function keys: Section 4.12.
* Different name for RHIDE: Chapter 7.
* Directory for temp files: Section 2.3.
* Disable shadows:                       Use no shadows.
* Donations to the author: Chapter 7.
* DOS: Section 3.2.6.
* Dual display: Section 5.2.
* Dual display when debugging:           Use dual display.
* Dual display with RHGDB: Chapter 6.
* Edit a file: Section 3.2.1.
* Edit the list of C flags: Section 3.9.6.7.
* Edit the list of C++ flags: Section 3.9.6.8.
* Edit the list of debugging flags: Section 3.9.6.11.
* Edit the list of optimization flags: Section 3.9.6.12.
* Edit the list of Pascal flags: Section 3.9.6.9.
* Edit the list of reserved words: Section 3.9.6.5.
* Edit the list of reserved words for pascal: Section 3.9.6.6.
* Edit the list of user defined words: Section 3.9.6.13.
* Edit the list of warning flags: Section 3.9.6.10.
* Editor: Section 4.2.
* Editor options: Section 3.9.6.2.
* Editor, block commands: Section 4.2.4.
* Editor, cursor moving: Section 4.2.2.
* Editor, erasing commands: Section 4.2.1.
* Editor, other useful commands: Section 4.2.5.
* Editor, select some text: Section 4.2.3.
* Environment variables: Section 3.9.1.
* Erasing commands: Section 4.2.1.
* Executing your program: Section 3.5.1.
* Exit: Section 3.2.7.
* Expanding tabs: Section 3.3.8.
* File caching:                          No file caching.
* File open dialog: Section 3.2.1.
* Finding text: Section 3.4.1.
* Flags for C files: Section 3.9.2.4.
* Flags for C++ files: Section 3.9.2.5.
* Flags for Pascal file: Section 3.9.2.6.
* Free memory:                           show free memory.
* Function call stack: Section 3.7.5.
* Generating of warnigs: Section 3.9.2.1.
* Global editor options: Section 3.9.6.2.
* Goto a line number: Section 3.4.4.
* GPC, -automake: Section 3.8.8.
* Header files: Section 3.9.1.1.
* Help: Section 3.11.1.
* Help about a function: Section 3.11.3.
* Help about help: Section 3.11.5.
* Help about the Infoviewer: Section 3.11.5.
* Helpsystem: Section 4.14.
* Highlight the syntax: Section 4.9.
* Highlighting the matching parenthesis: Match pair highlight.
* Highlighting the syntax:               syntax highlighting.
* Hints: Section 4.3.
* How the editor works: Section 4.2.
* Include directories: Section 3.9.1.1.
* Include files: Section 3.9.1.1.
* Info Viewer: Section 4.14.
* Input line: Section 4.12.
* Intelligent C indenting:               Intelligent C indenting.
* Language, setting the default: Chapter 7.
* Languages: Section 1.5.1.
* Latest version of RHIDE: Chapter 7.
* Leaving RHIDE: Section 3.2.7.
* LFN: Section 2.3.
* Libc reference: Section 3.11.4.
* Libraries: Section 3.9.3.
* Libraries in a project: Chapter 7.
* Library search path: Section 3.9.1.2.
* Link the program: Section 3.6.3.
* Linker options: Section 3.9.4.
* List of all windows: Section 3.10.8.
* Listbox: Section 4.12.
* Lists: Section 4.12.
* Load options <1>: Section 2.5.3.
* Load options: Section 3.9.8.
* Loading a file: Section 3.2.1.
* Local options for a project item: Section 3.8.5.
* Long filenames: Section 2.3.
* Macro executing: Section 3.3.10.3.
* Macro recording: Section 3.3.10.1.
* Macro stop recording: Section 3.3.10.2.
* Macros <1>: Section 3.3.10.
* Macros: Section 4.13.
* Main targetname: Section 3.8.7.
* Make: Section 3.6.2.
* Make clear: Section 3.8.10.
* Makefile: Section 3.8.11.
* Mark some text: Section 4.2.3.
* Message window: Section 4.8.
* Miscellaneous commands: Section 4.2.5.
* Mouse options:                         Mouse options.
* Moving a window: Section 3.10.1.
* MS-DOS: Section 3.2.6.
* Name of the main target: Section 3.8.7.
* Next message: Section 3.4.6.
* Next window: Section 3.10.5.
* No shadows:                            Use no shadows.
* Object file search path: Section 3.9.1.3.
* Object files in a different directory: Section 3.9.1.3.
* Open a file: Section 3.2.1.
* Open a project: Section 3.8.1.
* Optimal filling:                       Optimal fill.
* Optimizations, edit the flags: Section 3.9.6.12.
* Optimizing the code: Section 3.9.2.2.
* Options for a single file: Section 3.8.5.
* Options for the linker: Section 3.9.4.
* Order of the project items: Section 4.4.1.
* OS/2: Section 2.4.
* Other compilers: Section 4.7.
* Pascal flags, edit them: Section 3.9.6.9.
* Pascal options: Section 3.9.2.6.
* Pascal reserved words: Section 3.9.6.6.
* Paste: Section 3.3.5.
* Persistent blocks:                     Persistent blocks.
* Playing the macro: Section 3.3.10.3.
* Preprocessing Assembler files: Section 2.1.
* Previous message: Section 3.4.7.
* Previous window: Section 3.10.6.
* Problems: Section 4.3.
* Project window: Section 4.4.
* Pseudo Macros: Section 4.13.
* Quit: Section 3.2.7.
* Radiobuttons: Section 4.12.
* Rebuilding RHIDE: Chapter 7.
* Redirecting stderr:                    redirect stderr.
* Redirecting stdout:                    redirect stdout.
* Redo: Section 3.3.2.
* Remove a file from the project: Section 3.8.4.
* Removing all targets: Section 3.8.10.
* Removing the internal dependencies: Section 3.8.9.
* Repeat of replacing: Section 3.4.3.
* Repeat of searching: Section 3.4.3.
* Replacing text: Section 3.4.2.
* Reporting bugs <1>: Chapter 7.
* Reporting bugs: Section 3.1.2.
* Reserved words: Section 3.9.6.5.
* Resizing a window: Section 3.10.1.
* Reverse mouse buttons:                 Mouse options.
* RHIDE project files: Chapter 7.
* RHIDE, latest version: Chapter 7.
* Row cursor:                            Row cursor.
* Running your program: Section 3.5.1.
* Sample projects: Chapter 7.
* Save all files to disk: Section 3.2.5.
* Save options <1>:                      Save options.
* Save options: Section 2.5.3.
* Save the file to disk: Section 3.2.3.
* Save the file under a different name: Section 3.2.4.
* Search a function: Section 3.4.5.
* Search path for include files: Section 3.9.1.1.
* Search path for libraries: Section 3.9.1.2.
* Search path for opbject files: Section 3.9.1.3.
* Search path for source files: Section 3.9.1.4.
* Searching text: Section 3.4.1.
* Select a window: Section 4.1.
* Select the project window: Section 3.10.9.
* Selecting some text: Section 4.2.3.
* Shift+Space: Chapter 7.
* Show free memory:                      show free memory.
* Show the includes for a file: Section 3.8.6.
* Show the project window: Section 3.10.9.
* Show the user screen: Section 3.10.10.
* Show what RHIDE does:                  show process information.
* Single file compiling: Section 4.3.
* Size for the tabs:                     Tabsize.
* Source file search path: Section 3.9.1.4.
* Source files in a different directory: Section 3.9.1.4.
* Space as part of an argument: Section 2.2.
* Start: Section 1.5.
* Starting a macro: Section 3.3.10.1.
* Starting your program: Section 3.5.1.
* stderr redirecting:                    redirect stderr.
* stdout redirecting:                    redirect stdout.
* Stopping a macro: Section 3.3.10.2.
* Store a file: Section 3.2.3.
* Supressing of warnings: Section 3.9.2.1.
* Syntax help: Section 3.11.3.
* Syntax highlighting <1>: Section 4.9.
* Syntax highlighting:                   syntax highlighting.
* Tab size:                              Tabsize.
* Tabs:                                  Use tabs.
* Tabs to spaces: Section 3.3.8.
* Temp directory: Section 2.3.
* temporary do to DOS: Section 3.2.6.
* Text mode:                             Screen mode.
* Tile the windows: Section 3.10.3.
* Transparent blocks:                    Transparent Blocks.
* Turbo Vision: Section 4.11.
* Type of the main target: Section 3.8.7.
* Undo: Section 3.3.1.
* Use of libraries: Chapter 7.
* User defined reserved words: Section 3.9.6.13.
* User screen: Section 3.10.10.
* Using the dialog: Section 4.12.
* Using the macro: Section 3.3.10.3.
* Using true tabs:                       Use tabs.
* Version of RHIDE: Section 3.1.1.
* Video mode:                            Screen mode.
* Warnings: Section 3.9.2.1.
* Warnings, edit the flags: Section 3.9.6.10.
* Window, close it: Section 3.10.7.
* Window, moving: Section 3.10.1.
* Window, resizing: Section 3.10.1.
* Window, select it: Section 4.1.
* Window, select the next: Section 3.10.5.
* Window, select the previous: Section 3.10.6.
* Window, zoom it: Section 3.10.2.
* Windows: Section 3.10.
* Windows 95: Section 2.3.
* Windows, cascade them: Section 3.10.4.
* Windows, show a list of all: Section 3.10.8.
* Windows, tile all: Section 3.10.3.
* Write a makefile: Section 3.8.11.
* Zoom a window: Section 3.10.2.

9. Index of key commands
************************



* <Alt+0> | List of all windows: Section 3.10.8.
* <Alt+Backspace> | Undo: Section 3.3.1.
* <Alt+F10> | Macro stop: Section 3.3.10.2.
* <Alt+F2> | Jump to function: Section 3.4.5.
* <Alt+F3> | Close a window: Section 3.10.7.
* <Alt+F5> | User screen: Section 3.10.10.
* <Alt+F7> | Previous message: Section 3.4.7.
* <Alt+F8> | Next message: Section 3.4.6.
* <Alt+F9> | Compile: Section 3.6.1.
* <Alt+SPACE> | System Menu: Section 3.1.
* <Alt+X> | Leaving RHIDE: Section 3.2.7.
* <Alt> | Selecting a window: Section 4.1.
* <Backspace> | Erase a character: Section 4.2.1.
* <Ctrk+F8> | Breakpoint at a line: Section 5.5.1.
* <Ctrl+A> | Word left: Section 4.2.2.
* <Ctrl+Backspace> | Delete to the previous word: Section 4.2.1.
* <Ctrl+Break> | Interrupting the compilers: Section 1.3.
* <Ctrl+C> | Ignoring: Section 1.3.
* <Ctrl+C> | Page down: Section 4.2.2.
* <Ctrl+D> | Cursor right: Section 4.2.2.
* <Ctrl+Del> | Delete selected text: Section 4.2.3.
* <Ctrl+E> | Cursor up: Section 4.2.2.
* <Ctrl+F10> | Macro play: Section 3.3.10.3.
* <Ctrl+F1> | Context help: Section 4.14.
* <Ctrl+F1> | List of functions: Section 5.5.2.
* <Ctrl+F1> | Syntax help: Section 3.11.3.
* <Ctrl+F2> | Program reset: Section 3.5.5.
* <Ctrl+F3> | Call stack: Section 3.7.5.
* <Ctrl+F4> | Evaluate/Modify: Section 3.7.2.
* <Ctrl+F5> | Resize/move a window: Section 3.10.1.
* <Ctrl+F7> | Add to the watches: Section 5.3.3.
* <Ctrl+F7> | Watch an expression: Section 3.7.3.
* <Ctrl+F8> | Breakpoint delete: Section 5.5.1.
* <Ctrl+F8> | Toggle a breakpoint: Section 3.7.1.
* <Ctrl+F9> | Run: Section 3.5.1.
* <Ctrl+F> | Word right: Section 4.2.2.
* <Ctrl+G> | Delete a character: Section 4.2.1.
* <Ctrl+H> | Delete a character: Section 4.2.1.
* <Ctrl+I> | Show includes: Section 3.8.6.
* <Ctrl+Ins> | Copy <1>: Section 4.2.3.
* <Ctrl+Ins> | Copy: Section 3.3.4.
* <Ctrl+J> | Goto line: Section 3.4.4.
* <Ctrl+J> | Jump to a line: Section 4.2.5.
* <Ctrl+K+> | Set a marker: Section 4.2.5.
* <Ctrl+K+B> | Start of block: Section 4.2.4.
* <Ctrl+K+C> | Paste: Section 4.2.3.
* <Ctrl+K+H> | Unselect: Section 4.2.3.
* <Ctrl+K+I> | Indent block: Section 4.2.4.
* <Ctrl+K+K> | Copy: Section 4.2.3.
* <Ctrl+K+K> | End of block: Section 4.2.4.
* <Ctrl+K+M> | To upper: Section 4.2.4.
* <Ctrl+K+O> | To lower: Section 4.2.4.
* <Ctrl+K+R> | Read block from file: Section 4.2.4.
* <Ctrl+K+Shift+Tab> | Block unindenting: Section 4.2.4.
* <Ctrl+K+Tab> | Block indenting: Section 4.2.4.
* <Ctrl+K+U> | Unindent block: Section 4.2.4.
* <Ctrl+K+V> | Move block: Section 4.2.4.
* <Ctrl+K+W> | Write block to file: Section 4.2.4.
* <Ctrl+K+Y> | Cut: Section 4.2.3.
* <Ctrl+L> | Again find/replace: Section 4.2.3.
* <Ctrl+L> | Search again: Section 3.4.3.
* <Ctrl+O> | Auto indent: Section 4.2.5.
* <Ctrl+O> | Local options <1>: Section 3.8.5.
* <Ctrl+O> | Local options: Section 4.4.4.
* <Ctrl+PgDown> | Bottom of file: Section 4.2.2.
* <Ctrl+PgUp> | Begin of file: Section 4.2.2.
* <Ctrl+Q+> | Jump to a marker: Section 4.2.5.
* <Ctrl+Q+A> | Replace <1>: Section 3.4.2.
* <Ctrl+Q+A> | Replace: Section 4.2.3.
* <Ctrl+Q+C> | End of file: Section 4.2.2.
* <Ctrl+Q+D> | End of line: Section 4.2.2.
* <Ctrl+Q+F> | Find <1>: Section 3.4.1.
* <Ctrl+Q+F> | Find: Section 4.2.3.
* <Ctrl+Q+H> | Delete to the beginning of line: Section 4.2.1.
* <Ctrl+Q+R> | Start of file: Section 4.2.2.
* <Ctrl+Q+S> | Start of line: Section 4.2.2.
* <Ctrl+Q+Y> | Delete to the end of line: Section 4.2.1.
* <Ctrl+R> | Page up: Section 4.2.2.
* <Ctrl+S> | Cursor left: Section 4.2.2.
* <Ctrl+T> | Delete to the next word: Section 4.2.1.
* <Ctrl+V> | Overwrite mode: Section 4.2.5.
* <Ctrl+X> | Cursor down: Section 4.2.2.
* <Ctrl+Y> | Erase a line: Section 4.2.1.
* <Del> | Close a window: Section 3.10.8.
* <Del> | Erase a character: Section 4.2.1.
* <Del> | Remove a project item: Section 3.8.4.
* <Del> | Remove from the watches: Section 5.3.3.
* <ENTER> | Activate a button: Section 4.12.
* <ENTER> | Jump to the source line: Section 4.8.
* <ENTER> | Open a project item: Section 4.4.2.
* <ENTER> | Open an include file: Section 4.4.3.
* <ENTER> | Select a item in a listbox: Section 4.12.
* <ENTER> | Select a menu entry: Section 4.11.
* <ENTER> | Select a message: Section 4.3.
* <ENTER> | Select a window: Section 3.10.8.
* <ENTER> | Select menu item: Chapter 3.
* <ESC> | Leaving a dialog <1>: Section 3.2.1.
* <ESC> | Leaving a dialog <2>: Section 4.12.
* <ESC> | Leaving a dialog: Section 3.9.2.7.
* <F10> | Activate menu bar: Section 4.11.
* <F10> | Menu <1>: Chapter 3.
* <F10> | Menu: Section 1.5.
* <F1> | Help: Section 3.11.1.
* <F1> | Help about the INFO viewer: Section 3.11.1.
* <F1> | Help about the INFO Viewer: Section 4.14.
* <F2> | saving a file: Section 3.2.3.
* <F3> | open a file: Section 3.2.1.
* <F4> | Go to cursor: Section 3.5.4.
* <F5> | Zoom a window: Section 3.10.2.
* <F6> | Next window: Section 3.10.5.
* <F7> | Trace into: Section 3.5.3.
* <F8> | Step over: Section 3.5.2.
* <F9> | Make: Section 3.6.2.
* <Ins> | Add a project item: Section 3.8.3.
* <Shift+> | Resizing a window: Section 3.10.1.
* <Shift+Del> | Cut <1>: Section 3.3.3.
* <Shift+Del> | Cut: Section 4.2.3.
* <Shift+F10> | Macro start: Section 3.3.10.1.
* <Shift+F6> | Previous window: Section 3.10.6.
* <Shift+Ins> | Paste <1>: Section 3.3.5.
* <Shift+Ins> | Paste: Section 4.2.3.
* <Shift+Space> | Execute a macro: Section 4.2.5.
* <Shift+Tab> | Previous inputline: Section 3.9.3.
* <Shift> | Select text: Section 4.2.3.
* <SPACE> | Activate a flag: Section 3.9.2.7.
* <SPACE> | Toggle an option: Section 4.12.
* <Tab> | Next inputline: Section 3.9.3.
* Activate a button | <ENTER> |: Section 4.12.
* Activate a flag | <SPACE> |: Section 3.9.2.7.
* Activate menu bar | <F10> |: Section 4.11.
* Add a project item | <Ins> |: Section 3.8.3.
* Add to the watches | <Ctrl+F7> |: Section 5.3.3.
* Again find/replace | <Ctrl+L> |: Section 4.2.3.
* Auto indent | <Ctrl+O> |: Section 4.2.5.
* Begin of file | <Ctrl+PgUp> |: Section 4.2.2.
* Block indenting | <Ctrl+K+Tab> |: Section 4.2.4.
* Block unindenting | <Ctrl+K+Shift+Tab> |: Section 4.2.4.
* Bottom of file | <Ctrl+PgDown> |: Section 4.2.2.
* Breakpoint at a line | <Ctrk+F8> |: Section 5.5.1.
* Breakpoint delete | <Ctrl+F8> |: Section 5.5.1.
* Call stack | <Ctrl+F3> |: Section 3.7.5.
* Close a window | <Alt+F3> |: Section 3.10.7.
* Close a window | <Del> |: Section 3.10.8.
* Compile | <Alt+F9> |: Section 3.6.1.
* Context help | <Ctrl+F1> |: Section 4.14.
* Copy | <Ctrl+Ins> | <1>: Section 3.3.4.
* Copy | <Ctrl+Ins> |: Section 4.2.3.
* Copy | <Ctrl+K+K> |: Section 4.2.3.
* Cursor down | <Ctrl+X> |: Section 4.2.2.
* Cursor left | <Ctrl+S> |: Section 4.2.2.
* Cursor right | <Ctrl+D> |: Section 4.2.2.
* Cursor up | <Ctrl+E> |: Section 4.2.2.
* Cut | <Ctrl+K+Y> |: Section 4.2.3.
* Cut | <Shift+Del> | <1>: Section 4.2.3.
* Cut | <Shift+Del> |: Section 3.3.3.
* Delete a character | <Ctrl+G> |: Section 4.2.1.
* Delete a character | <Ctrl+H> |: Section 4.2.1.
* Delete selected text | <Ctrl+Del> |: Section 4.2.3.
* Delete to the beginning of line | <Ctrl+Q+H> |: Section 4.2.1.
* Delete to the end of line | <Ctrl+Q+Y> |: Section 4.2.1.
* Delete to the next word | <Ctrl+T> |: Section 4.2.1.
* Delete to the previous word | <Ctrl+Backspace> |: Section 4.2.1.
* End of block | <Ctrl+K+K> |: Section 4.2.4.
* End of file | <Ctrl+Q+C> |: Section 4.2.2.
* End of line | <Ctrl+Q+D> |: Section 4.2.2.
* Erase a character | <Backspace> |: Section 4.2.1.
* Erase a character | <Del> |: Section 4.2.1.
* Erase a line | <Ctrl+Y> |: Section 4.2.1.
* Evaluate/Modify | <Ctrl+F4> |: Section 3.7.2.
* Execute a macro | <Shift+Space> |: Section 4.2.5.
* Find | <Ctrl+Q+F> | <1>: Section 3.4.1.
* Find | <Ctrl+Q+F> |: Section 4.2.3.
* Go to cursor | <F4> |: Section 3.5.4.
* Goto line | <Ctrl+J> |: Section 3.4.4.
* Help about the INFO Viewer | <F1> |: Section 4.14.
* Help about the INFO viewer | <F1> |: Section 3.11.1.
* Help | <F1> |: Section 3.11.1.
* Ignoring | <Ctrl+C> |: Section 1.3.
* Indent block | <Ctrl+K+I> |: Section 4.2.4.
* Interrupting the compilers | <Ctrl+Break> |: Section 1.3.
* Jump to a line | <Ctrl+J> |: Section 4.2.5.
* Jump to a marker | <Ctrl+Q+> |: Section 4.2.5.
* Jump to function | <Alt+F2> |: Section 3.4.5.
* Jump to the source line | <ENTER> |: Section 4.8.
* Leaving a dialog | <ESC> | <1>: Section 3.9.2.7.
* Leaving a dialog | <ESC> | <2>: Section 3.2.1.
* Leaving a dialog | <ESC> |: Section 4.12.
* Leaving RHIDE | <Alt+X> |: Section 3.2.7.
* List of all windows | <Alt+0> |: Section 3.10.8.
* List of functions | <Ctrl+F1> |: Section 5.5.2.
* Local options | <Ctrl+O> | <1>: Section 3.8.5.
* Local options | <Ctrl+O> |: Section 4.4.4.
* Macro play | <Ctrl+F10> |: Section 3.3.10.3.
* Macro start | <Shift+F10> |: Section 3.3.10.1.
* Macro stop | <Alt+F10> |: Section 3.3.10.2.
* Make | <F9> |: Section 3.6.2.
* Menu | <F10> | <1>: Chapter 3.
* Menu | <F10> |: Section 1.5.
* Move block | <Ctrl+K+V> |: Section 4.2.4.
* Next inputline | <Tab> |: Section 3.9.3.
* Next message | <Alt+F8> |: Section 3.4.6.
* Next window | <F6> |: Section 3.10.5.
* open a file | <F3> |: Section 3.2.1.
* Open a project item | <ENTER> |: Section 4.4.2.
* Open an include file | <ENTER> |: Section 4.4.3.
* Overwrite mode | <Ctrl+V> |: Section 4.2.5.
* Page down | <Ctrl+C> |: Section 4.2.2.
* Page up | <Ctrl+R> |: Section 4.2.2.
* Paste | <Ctrl+K+C> |: Section 4.2.3.
* Paste | <Shift+Ins> | <1>: Section 4.2.3.
* Paste | <Shift+Ins> |: Section 3.3.5.
* Previous inputline | <Shift+Tab> |: Section 3.9.3.
* Previous message | <Alt+F7> |: Section 3.4.7.
* Previous window | <Shift+F6> |: Section 3.10.6.
* Program reset | <Ctrl+F2> |: Section 3.5.5.
* Read block from file | <Ctrl+K+R> |: Section 4.2.4.
* Remove a project item | <Del> |: Section 3.8.4.
* Remove from the watches | <Del> |: Section 5.3.3.
* Replace | <Ctrl+Q+A> | <1>: Section 3.4.2.
* Replace | <Ctrl+Q+A> |: Section 4.2.3.
* Resize/move a window | <Ctrl+F5> |: Section 3.10.1.
* Resizing a window | <Shift+> |: Section 3.10.1.
* Run | <Ctrl+F9> |: Section 3.5.1.
* saving a file | <F2> |: Section 3.2.3.
* Search again | <Ctrl+L> |: Section 3.4.3.
* Select a item in a listbox | <ENTER> |: Section 4.12.
* Select a menu entry | <ENTER> |: Section 4.11.
* Select a message | <ENTER> |: Section 4.3.
* Select a window | <ENTER> |: Section 3.10.8.
* Select menu item | <ENTER> |: Chapter 3.
* Select text | <Shift> |: Section 4.2.3.
* Selecting a window | <Alt> |: Section 4.1.
* Set a marker | <Ctrl+K+> |: Section 4.2.5.
* Show includes | <Ctrl+I> |: Section 3.8.6.
* Start of block | <Ctrl+K+B> |: Section 4.2.4.
* Start of file | <Ctrl+Q+R> |: Section 4.2.2.
* Start of line | <Ctrl+Q+S> |: Section 4.2.2.
* Step over | <F8> |: Section 3.5.2.
* Syntax help | <Ctrl+F1> |: Section 3.11.3.
* System Menu | <Alt+SPACE> |: Section 3.1.
* To lower | <Ctrl+K+O> |: Section 4.2.4.
* To upper | <Ctrl+K+M> |: Section 4.2.4.
* Toggle a breakpoint | <Ctrl+F8> |: Section 3.7.1.
* Toggle an option | <SPACE> |: Section 4.12.
* Trace into | <F7> |: Section 3.5.3.
* Undo | <Alt+Backspace> |: Section 3.3.1.
* Unindent block | <Ctrl+K+U> |: Section 4.2.4.
* Unselect | <Ctrl+K+H> |: Section 4.2.3.
* User screen | <Alt+F5> |: Section 3.10.10.
* Watch an expression | <Ctrl+F7> |: Section 3.7.3.
* Word left | <Ctrl+A> |: Section 4.2.2.
* Word right | <Ctrl+F> |: Section 4.2.2.
* Write block to file | <Ctrl+K+W> |: Section 4.2.4.
* Zoom a window | <F5> |: Section 3.10.2.

